自学教程：C++ zbx_json_free函数代码示例

/****************************************************************************** *                                                                            * * Function: get_data_from_server                                             * *                                                                            * * Purpose: get configuration and other data from server                      * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value: SUCCESS - processed successfully                             * *               FAIL - an error occurred                                     * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/int	get_data_from_server(zbx_sock_t *sock, const char *request){	const char	*__function_name = "get_data_from_server";	int		ret = FAIL;	struct zbx_json	j;	zabbix_log(LOG_LEVEL_DEBUG, "In %s() request:'%s'", __function_name, request);	zbx_json_init(&j, 128);	zbx_json_addstring(&j, "request", request, ZBX_JSON_TYPE_STRING);	zbx_json_addstring(&j, "host", CONFIG_HOSTNAME, ZBX_JSON_TYPE_STRING);	if (FAIL == send_data_to_server(sock, j.buffer))		goto exit;	if (FAIL == recv_data_from_server(sock))		goto exit;	ret = SUCCEED;exit:	zbx_json_free(&j);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));	return ret;}

/* * Custom key pg.table.discovery * * Returns all known Tables in a PostgreSQL database * * Parameter [0-4]:     <host,port,db,user,passwd> * * * Returns: * { *        "data":[ *                { *                        "{#DATABASE}":"MyDatabase", *                        "{#SCHEMA}":"public", *                        "{#TABLESPACE}":"pg_default", *                        "{#TABLE}":"MyTable", *                        "{#TYPE}":"MyTable", *                        "{#OWNER}":"postgres", *                        "{#PERSISTENCE":"permenant|temporary", *                        "{#ISSUBCLASS}":"0"}]} */int    PG_TABLE_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result){    int         ret = SYSINFO_RET_FAIL;                     // Request result code    const char  *__function_name = "PG_TABLE_DISCOVERY";    // Function name for log file    struct      zbx_json j;                                 // JSON response for discovery rule        PGconn      *conn = NULL;    PGresult    *res = NULL;        char        query[MAX_STRING_LEN] = PGSQL_DISCOVER_TABLES;    int         i = 0, count = 0;        zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);        // Connect to PostreSQL    if(NULL == (conn = pg_connect(request)))        goto out;        // Execute a query    res = PQexec(conn, query);    if(PQresultStatus(res) != PGRES_TUPLES_OK) {        zabbix_log(LOG_LEVEL_ERR, "Failed to execute PostgreSQL query in %s() with: %s", __function_name, PQresultErrorMessage(res));        goto out;    }        if(0 == (count = PQntuples(res))) {        zabbix_log(LOG_LEVEL_DEBUG, "No results returned for query /"%s/" in %s()", query, __function_name);    }                 // Create JSON array of discovered objects    zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);    zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);        for(i = 0; i < count; i++) {        zbx_json_addobject(&j, NULL);                zbx_json_addstring(&j, "{#OID}", PQgetvalue(res, i, 0), ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&j, "{#DATABASE}", PQgetvalue(res, i, 1), ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&j, "{#SCHEMA}", PQgetvalue(res, i, 2), ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&j, "{#TABLESPACE}", PQgetvalue(res, i, 3), ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&j, "{#TABLE}", PQgetvalue(res, i, 4), ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&j, "{#TYPE}", PQgetvalue(res, i, 5), ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&j, "{#OWNER}", PQgetvalue(res, i, 6), ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&j, "{#PERSISTENCE}", PQgetvalue(res, i, 7), ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&j, "{#ISSUBCLASS}", PQgetvalue(res, i, 8), ZBX_JSON_TYPE_STRING);        zbx_json_close(&j);             }        // Finalize JSON response    zbx_json_close(&j);    SET_STR_RESULT(result, strdup(j.buffer));    zbx_json_free(&j);    ret = SYSINFO_RET_OK;        out:    PQclear(res);    PQfinish(conn);        zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);    return ret;}

int	NET_IF_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result){	int			ret = SYSINFO_RET_FAIL, i;	struct zbx_json		j;	struct if_nameindex	*interfaces;	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	if (NULL != (interfaces = if_nameindex()))	{		i = 0;		while (0 != interfaces[i].if_index)		{			zbx_json_addobject(&j, NULL);			zbx_json_addstring(&j, "{#IFNAME}", interfaces[i].if_name, ZBX_JSON_TYPE_STRING);			zbx_json_close(&j);			i++;		}		ret = SYSINFO_RET_OK;	}	zbx_json_close(&j);	SET_STR_RESULT(result, strdup(j.buffer));	zbx_json_free(&j);	return ret;}

int	NET_IF_DISCOVERY(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result){	struct if_nameindex	*ni;	struct zbx_json		j;	int			i;	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	for (ni = if_nameindex(), i = 0; 0 != ni[i].if_index; i++)	{		zbx_json_addobject(&j, NULL);		zbx_json_addstring(&j, "{#IFNAME}", ni[i].if_name, ZBX_JSON_TYPE_STRING);		zbx_json_close(&j);	}	if_freenameindex(ni);	zbx_json_close(&j);	SET_STR_RESULT(result, strdup(j.buffer));	zbx_json_free(&j);	return SYSINFO_RET_OK;}

/****************************************************************************** *                                                                            * * Function: zbx_send_response                                                * *                                                                            * * Purpose: send json SUCCEED or FAIL to socket along with an info message    * *                                                                            * * Parameters: sock    - [IN] socket descriptor                               * *             result  - [IN] SUCCEED or FAIL                                 * *             info    - [IN] info message                                    * *             timeout - [IN] timeout for this operation                      * *                                                                            * * Return value: SUCCEED - data successfully transmited                       * *               NETWORK_ERROR - network related error occurred               * *                                                                            * * Author: Alexander Vladishev, Alexei Vladishev                              * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/int	zbx_send_response_ext(zbx_socket_t *sock, int result, const char *info, int protocol, int timeout){	const char	*__function_name = "zbx_send_response";	struct zbx_json	json;	const char	*resp;	int		ret = SUCCEED;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);	resp = SUCCEED == result ? ZBX_PROTO_VALUE_SUCCESS : ZBX_PROTO_VALUE_FAILED;	zbx_json_addstring(&json, ZBX_PROTO_TAG_RESPONSE, resp, ZBX_JSON_TYPE_STRING);	if (NULL != info && '/0' != *info)		zbx_json_addstring(&json, ZBX_PROTO_TAG_INFO, info, ZBX_JSON_TYPE_STRING);	zabbix_log(LOG_LEVEL_DEBUG, "%s() '%s'", __function_name, json.buffer);	if (FAIL == (ret = zbx_tcp_send_ext(sock, json.buffer, strlen(json.buffer), protocol, timeout)))	{		zabbix_log(LOG_LEVEL_DEBUG, "Error sending result back: %s", zbx_socket_strerror());		ret = NETWORK_ERROR;	}	zbx_json_free(&json);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));	return ret;}

int	VFS_FS_DISCOVERY(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result){	int		i, rc, ret = SYSINFO_RET_FAIL;	struct statfs	*mntbuf;	struct zbx_json	j;	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	if (0 != (rc = getmntinfo(&mntbuf, MNT_WAIT)))	{		for (i = 0; i < rc; i++)		{			zbx_json_addobject(&j, NULL);			zbx_json_addstring(&j, "{#FSNAME}", mntbuf[i].f_mntonname, ZBX_JSON_TYPE_STRING);			zbx_json_addstring(&j, "{#FSTYPE}", mntbuf[i].f_fstypename, ZBX_JSON_TYPE_STRING);			zbx_json_close(&j);		}		ret = SYSINFO_RET_OK;	}	zbx_json_close(&j);	SET_STR_RESULT(result, zbx_strdup(NULL, j.buffer));	zbx_json_free(&j);	return ret;}

/****************************************************************************** *                                                                            * * Function: send_proxyconfig                                                 * *                                                                            * * Purpose: send configuration tables to the proxy                            * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value:  SUCCEED - processed successfully                            * *                FAIL - an error occurred                                    * *                                                                            * * Author: Aleksander Vladishev                                               * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/int	send_proxyconfig(zbx_sock_t *sock, struct zbx_json_parse *jp){	zbx_uint64_t	proxy_hostid;	struct zbx_json	j;	int		res = FAIL;	zabbix_log(LOG_LEVEL_DEBUG, "In send_proxyconfig()");	if (FAIL == get_proxy_id(jp, &proxy_hostid))		goto exit;	update_proxy_lastaccess(proxy_hostid);	zbx_json_init(&j, 512*1024);	if (SUCCEED == (res = get_proxyconfig_data(proxy_hostid, &j))) {		zabbix_log(LOG_LEVEL_WARNING, "Sending configuration data to proxy. Datalen %d",				(int)j.buffer_size);		zabbix_log(LOG_LEVEL_DEBUG, "%s",				j.buffer);		if (FAIL == (res = zbx_tcp_send(sock, j.buffer)))			zabbix_log(LOG_LEVEL_WARNING, "Error while sending configuration. %s",					zbx_tcp_strerror());	}	zbx_json_free(&j);exit:	return res;}

int	VFS_FS_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result){	int		i, rc;	struct statvfs	*mntbuf;	struct zbx_json	j;	if (0 == (rc = getmntinfo(&mntbuf, MNT_WAIT)))	{		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno)));		return SYSINFO_RET_FAIL;	}	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	for (i = 0; i < rc; i++)	{		zbx_json_addobject(&j, NULL);		zbx_json_addstring(&j, "{#FSNAME}", mntbuf[i].f_mntonname, ZBX_JSON_TYPE_STRING);		zbx_json_addstring(&j, "{#FSTYPE}", mntbuf[i].f_fstypename, ZBX_JSON_TYPE_STRING);		zbx_json_close(&j);	}	zbx_json_close(&j);	SET_STR_RESULT(result, zbx_strdup(NULL, j.buffer));	zbx_json_free(&j);	return SYSINFO_RET_OK;}

/****************************************************************************** *                                                                            * * Function: send_proxyhistory                                                * *                                                                            * * Purpose: send history data to a Zabbix server                              * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value:                                                              * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/static void	send_proxyhistory(zbx_sock_t *sock){	const char	*__function_name = "send_proxyhistory";	struct zbx_json	j;	zbx_uint64_t	lastid;	int		records;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	records = proxy_get_hist_data(&j, &lastid);	zbx_json_close(&j);	zbx_json_adduint64(&j, ZBX_PROTO_TAG_CLOCK, (int)time(NULL));	if (FAIL == zbx_tcp_send_to(sock, j.buffer, CONFIG_TIMEOUT))		zabbix_log(LOG_LEVEL_WARNING, "Error while sending availability of hosts. %s",				zbx_tcp_strerror());	else if (SUCCEED == zbx_recv_response(sock, NULL, 0, CONFIG_TIMEOUT) && 0 != records)		proxy_set_hist_lastid(lastid);	zbx_json_free(&j);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

int	NET_IF_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result){	struct if_nameindex	*ni;	struct zbx_json		j;	int			i;	if (NULL == (ni = if_nameindex()))	{		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno)));		return SYSINFO_RET_FAIL;	}	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	for (i = 0; 0 != ni[i].if_index; i++)	{		zbx_json_addobject(&j, NULL);		zbx_json_addstring(&j, "{#IFNAME}", ni[i].if_name, ZBX_JSON_TYPE_STRING);		zbx_json_close(&j);	}	if_freenameindex(ni);	zbx_json_close(&j);	SET_STR_RESULT(result, strdup(j.buffer));	zbx_json_free(&j);	return SYSINFO_RET_OK;}

/****************************************************************************** *                                                                            * * Function: get_data_from_proxy                                              * *                                                                            * * Purpose: get historical data from proxy                                    * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value: SUCCESS - processed successfully                             * *               FAIL - an error occurred                                     * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/static int	get_data_from_proxy(DC_PROXY *proxy, const char *request, char **data){	const char	*__function_name = "get_data_from_proxy";	zbx_socket_t	s;	struct zbx_json	j;	int		ret = FAIL;	zabbix_log(LOG_LEVEL_DEBUG, "In %s() request:'%s'", __function_name, request);	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addstring(&j, "request", request, ZBX_JSON_TYPE_STRING);	if (SUCCEED == (ret = connect_to_proxy(proxy, &s, CONFIG_TRAPPER_TIMEOUT)))	{		if (SUCCEED == (ret = send_data_to_proxy(proxy, &s, j.buffer)))			if (SUCCEED == (ret = recv_data_from_proxy(proxy, &s)))				if (SUCCEED == (ret = zbx_send_response(&s, SUCCEED, NULL, 0)))					*data = zbx_strdup(*data, s.buffer);		disconnect_proxy(&s);	}	zbx_json_free(&j);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));	return ret;}

int	NET_IF_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result){#if defined(HAVE_LIBPERFSTAT)	int			rc, i, ret = SYSINFO_RET_FAIL;	perfstat_id_t		ps_id;	perfstat_netinterface_t	*ps_netif = NULL;	struct zbx_json		j;	/* check how many perfstat_netinterface_t structures are available */	if (-1 == (rc = perfstat_netinterface(NULL, NULL, sizeof(perfstat_netinterface_t), 0)))	{		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno)));		return SYSINFO_RET_FAIL;	}	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	if (0 == rc)	/* no network interfaces found */	{		ret = SYSINFO_RET_OK;		goto end;	}	ps_netif = zbx_malloc(ps_netif, rc * sizeof(perfstat_netinterface_t));	/* set name to first interface */	strscpy(ps_id.name, FIRST_NETINTERFACE);	/* pseudo-name for the first network interface */	/* ask to get all the structures available in one call */	/* return code is number of structures returned */	if (-1 != (rc = perfstat_netinterface(&ps_id, ps_netif, sizeof(perfstat_netinterface_t), rc)))		ret = SYSINFO_RET_OK;	/* collecting of the information for each of the interfaces */	for (i = 0; i < rc; i++)	{		zbx_json_addobject(&j, NULL);		zbx_json_addstring(&j, "{#IFNAME}", ps_netif[i].name, ZBX_JSON_TYPE_STRING);		zbx_json_close(&j);	}	zbx_free(ps_netif);end:	zbx_json_close(&j);	SET_STR_RESULT(result, strdup(j.buffer));	zbx_json_free(&j);	return ret;#else	SET_MSG_RESULT(result, zbx_strdup(NULL, "Agent was compiled without support for Perfstat API."));	return SYSINFO_RET_FAIL;#endif}

int	check_vcenter_vm_vfs_fs_discovery(AGENT_REQUEST *request, const char *username, const char *password,		AGENT_RESULT *result){	struct zbx_json		json_data;	zbx_vmware_service_t	*service;	zbx_vmware_vm_t		*vm = NULL;	char			*url, *uuid;	zbx_vector_str_t	disks;	int			i, ret = SYSINFO_RET_FAIL;	if (2 != request->nparam)		return SYSINFO_RET_FAIL;	url = get_rparam(request, 0);	uuid = get_rparam(request, 1);	if ('/0' == *uuid)		return SYSINFO_RET_FAIL;	zbx_vmware_lock();	if (NULL == (service = get_vmware_service(url, username, password, result, &ret)))		goto unlock;	if (NULL == (vm = service_vm_get(service, uuid)))		goto unlock;	zbx_vector_str_create(&disks);	zbx_xml_read_values(vm->details, ZBX_XPATH_LN2("disk", "diskPath"), &disks);	zbx_json_init(&json_data, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&json_data, ZBX_PROTO_TAG_DATA);	for (i = 0; i < disks.values_num; i++)	{		zbx_json_addobject(&json_data, NULL);		zbx_json_addstring(&json_data, "{#FSNAME}", disks.values[i], ZBX_JSON_TYPE_STRING);		zbx_json_close(&json_data);	}	zbx_json_close(&json_data);	zbx_vector_str_clean(&disks);	zbx_vector_str_destroy(&disks);	SET_STR_RESULT(result, zbx_strdup(NULL, json_data.buffer));	zbx_json_free(&json_data);	ret = SYSINFO_RET_OK;unlock:	zbx_vmware_unlock();	return ret;}

int	check_vcenter_hv_discovery(AGENT_REQUEST *request, const char *username, const char *password,		AGENT_RESULT *result){	struct zbx_json		json_data;	int			i, ret = SYSINFO_RET_FAIL;	char			*url, *name;	zbx_vmware_service_t	*service;	if (1 != request->nparam)		return SYSINFO_RET_FAIL;	url = get_rparam(request, 0);	zbx_vmware_lock();	if (NULL == (service = get_vmware_service(url, username, password, result, &ret)))		goto unlock;	zbx_json_init(&json_data, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&json_data, ZBX_PROTO_TAG_DATA);	for (i = 0; i < service->data->hvs.values_num; i++)	{		zbx_vmware_cluster_t	*cluster = NULL;		zbx_vmware_hv_t	*hv = (zbx_vmware_hv_t *)service->data->hvs.values[i];		if (NULL == (name = zbx_xml_read_value(hv->details, ZBX_XPATH_LN2("config", "name"))))			continue;		if (NULL != hv->clusterid)			cluster = cluster_get(&service->data->clusters, hv->clusterid);		zbx_json_addobject(&json_data, NULL);		zbx_json_addstring(&json_data, "{#HV.UUID}", hv->uuid, ZBX_JSON_TYPE_STRING);		zbx_json_addstring(&json_data, "{#HV.ID}", hv->id, ZBX_JSON_TYPE_STRING);		zbx_json_addstring(&json_data, "{#HV.NAME}", name, ZBX_JSON_TYPE_STRING);		zbx_json_addstring(&json_data, "{#CLUSTER.NAME}",				(NULL != cluster ? cluster->name : ""), ZBX_JSON_TYPE_STRING);		zbx_json_close(&json_data);		zbx_free(name);	}	zbx_json_close(&json_data);	SET_STR_RESULT(result, zbx_strdup(NULL, json_data.buffer));	zbx_json_free(&json_data);	ret = SYSINFO_RET_OK;unlock:	zbx_vmware_unlock();	return ret;}

/****************************************************************************** *                                                                            * * Function: send_proxyconfig                                                 * *                                                                            * * Purpose: send configuration tables to the proxy from server                * *          (for active proxies)                                              * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * ******************************************************************************/void	send_proxyconfig(zbx_socket_t *sock, struct zbx_json_parse *jp){	char		*error = NULL;	struct zbx_json	j;	DC_PROXY	proxy;	int		flags = ZBX_TCP_PROTOCOL;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__);	if (SUCCEED != get_active_proxy_from_request(jp, &proxy, &error))	{		zabbix_log(LOG_LEVEL_WARNING, "cannot parse proxy configuration data request from active proxy at"				" /"%s/": %s", sock->peer, error);		goto out;	}	if (SUCCEED != zbx_proxy_check_permissions(&proxy, sock, &error))	{		zabbix_log(LOG_LEVEL_WARNING, "cannot accept connection from proxy /"%s/" at /"%s/", allowed address:"				" /"%s/": %s", proxy.host, sock->peer, proxy.proxy_address, error);		goto out;	}	zbx_update_proxy_data(&proxy, zbx_get_protocol_version(jp), time(NULL),			(0 != (sock->protocol & ZBX_TCP_COMPRESS) ? 1 : 0));	if (0 != proxy.auto_compress)		flags |= ZBX_TCP_COMPRESS;	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	if (SUCCEED != get_proxyconfig_data(proxy.hostid, &j, &error))	{		zbx_send_response_ext(sock, FAIL, error, NULL, flags, CONFIG_TIMEOUT);		zabbix_log(LOG_LEVEL_WARNING, "cannot collect configuration data for proxy /"%s/" at /"%s/": %s",				proxy.host, sock->peer, error);		goto clean;	}	zabbix_log(LOG_LEVEL_WARNING, "sending configuration data to proxy /"%s/" at /"%s/", datalen " ZBX_FS_SIZE_T,			proxy.host, sock->peer, (zbx_fs_size_t)j.buffer_size);	zabbix_log(LOG_LEVEL_DEBUG, "%s", j.buffer);	if (SUCCEED != zbx_tcp_send_ext(sock, j.buffer, strlen(j.buffer), flags, CONFIG_TRAPPER_TIMEOUT))	{		zabbix_log(LOG_LEVEL_WARNING, "cannot send configuration data to proxy /"%s/" at /"%s/": %s",				proxy.host, sock->peer, zbx_socket_strerror());	}clean:	zbx_json_free(&j);out:	zbx_free(error);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__);}

int	check_vcenter_vm_vfs_dev_discovery(AGENT_REQUEST *request, const char *username, const char *password,		AGENT_RESULT *result){	struct zbx_json		json_data;	zbx_vmware_service_t	*service;	zbx_vmware_vm_t		*vm = NULL;	zbx_vmware_dev_t	*dev;	char			*url, *uuid;	int			i, ret = SYSINFO_RET_FAIL;	if (2 != request->nparam)		return SYSINFO_RET_FAIL;	url = get_rparam(request, 0);	uuid = get_rparam(request, 1);	if ('/0' == *uuid)		return SYSINFO_RET_FAIL;	zbx_vmware_lock();	if (NULL == (service = get_vmware_service(url, username, password, result, &ret)))		goto unlock;	if (NULL == (vm = service_vm_get(service, uuid)))		goto unlock;	zbx_json_init(&json_data, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&json_data, ZBX_PROTO_TAG_DATA);	for (i = 0; i < vm->devs.values_num; i++)	{		dev = (zbx_vmware_dev_t *)vm->devs.values[i];		if (ZBX_VMWARE_DEV_TYPE_DISK != dev->type)			continue;		zbx_json_addobject(&json_data, NULL);		zbx_json_addstring(&json_data, "{#DISKNAME}", dev->instance, ZBX_JSON_TYPE_STRING);		zbx_json_close(&json_data);	}	zbx_json_close(&json_data);	SET_STR_RESULT(result, zbx_strdup(NULL, json_data.buffer));	zbx_json_free(&json_data);	ret = SYSINFO_RET_OK;unlock:	zbx_vmware_unlock();	return ret;}

/****************************************************************************** *                                                                            * * Function:                                                                  * *                                                                            * * Purpose:                                                                   * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value:                                                              * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/void reply_jobnetstatusrq_response(zbx_sock_t * sock, int ret,                                   JOBARG_JOBNET_INFO * ji, char *message){    struct zbx_json json;    /*JSON Data */    zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);    zbx_json_addstring(&json, JA_PROTO_TAG_KIND,                       JA_PROTO_VALUE_JOBNETSTATUSRQ_RES,                       ZBX_JSON_TYPE_STRING);    zbx_json_adduint64(&json, JA_PROTO_TAG_VERSION, JA_PROTO_VALUE_VERSION_1);  /*data version */    zbx_json_addstring(&json, JA_PROTO_TAG_SERVERID, serverid,                       ZBX_JSON_TYPE_STRING);    zbx_json_addobject(&json, JA_PROTO_TAG_DATA);    zbx_json_adduint64(&json, JA_PROTO_TAG_RESULT, FAIL == ret ? 1 : 0);    if (ret != FAIL) {        zbx_json_addstring(&json, JA_PROTO_TAG_JOBNETID, ji->jobnetid,                           ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&json, JA_PROTO_TAG_JOBNETNAME, ji->jobnetname,                           ZBX_JSON_TYPE_STRING);        zbx_json_adduint64(&json, JA_PROTO_TAG_SCHEDULEDTIME,                           ji->scheduled_time);        zbx_json_adduint64(&json, JA_PROTO_TAG_STARTTIME, ji->start_time);        zbx_json_adduint64(&json, JA_PROTO_TAG_ENDTIME, ji->end_time);        zbx_json_adduint64(&json, JA_PROTO_TAG_JOBNETRUNTYPE,                           ji->jobnetruntype);        zbx_json_adduint64(&json, JA_PROTO_TAG_JOBNETSTATUS,                           ji->jobnetstatus);        zbx_json_adduint64(&json, JA_PROTO_TAG_JOBSTATUS, ji->jobstatus);        zbx_json_addstring(&json, JA_PROTO_TAG_LASTEXITCD, ji->lastexitcd,                           ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&json, JA_PROTO_TAG_LASTSTDOUT, ji->laststdout,                           ZBX_JSON_TYPE_STRING);        zbx_json_addstring(&json, JA_PROTO_TAG_LASTSTDERR, ji->laststderr,                           ZBX_JSON_TYPE_STRING);    } else {        zbx_json_addstring(&json, JA_PROTO_TAG_MESSAGE, message,                           ZBX_JSON_TYPE_STRING);    }    zbx_json_close(&json);    zbx_json_close(&json);    zabbix_log(LOG_LEVEL_DEBUG, "JSON before sending [%s]", json.buffer);    if (FAIL == (ret = zbx_tcp_send_to(sock, json.buffer, CONFIG_TIMEOUT))) {        zbx_free(ji->jobnetid);        zbx_free(ji->jobnetname);        ja_log("JATRAPPER200038", 0, NULL, 0, zbx_tcp_strerror());        ret = NETWORK_ERROR;    }    zbx_free(ji->jobnetid);    zbx_free(ji->jobnetname);    zbx_json_free(&json);}

/****************************************************************************** *                                                                            * * Function: send_host_availability                                           * *                                                                            * * Purpose: send hosts availability data from proxy                           * *                                                                            * ******************************************************************************/void	send_host_availability(zbx_socket_t *sock){	const char	*__function_name = "send_host_availability";	struct zbx_json	j;	int		ret = FAIL, ts;	char		*error = NULL;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	if (SUCCEED != check_access_passive_proxy(sock, ZBX_DO_NOT_SEND_RESPONSE, "host availability data request"))	{		/* do not send any reply to server in this case as the server expects host availability data */		goto out1;	}	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	/* if there are no host availability changes we still have to send empty data in response */	if (SUCCEED != get_host_availability_data(&j, &ts))	{		zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);		zbx_json_close(&j);	}	zabbix_log(LOG_LEVEL_DEBUG, "%s() [%s]", __function_name, j.buffer);	if (SUCCEED != zbx_tcp_send_to(sock, j.buffer, CONFIG_TIMEOUT))	{		error = zbx_strdup(error, zbx_socket_strerror());		goto out;	}	if (SUCCEED != zbx_recv_response(sock, CONFIG_TIMEOUT, &error))		goto out;	zbx_set_availability_diff_ts(ts);	ret = SUCCEED;out:	if (SUCCEED != ret)	{		zabbix_log(LOG_LEVEL_WARNING, "cannot send host availability data to server at /"%s/": %s",				sock->peer, error);	}	zbx_json_free(&j);	zbx_free(error);out1:	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

int	VFS_FS_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result){	int		ret = SYSINFO_RET_FAIL;	char		line[MAX_STRING_LEN], *p, *mpoint, *mtype;	FILE		*f;	struct zbx_json	j;	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	if (NULL != (f = fopen("/proc/mounts", "r")))	{		while (NULL != fgets(line, sizeof(line), f))		{			if (NULL == (p = strchr(line, ' ')))				continue;			mpoint = ++p;			if (NULL == (p = strchr(mpoint, ' ')))				continue;			*p = '/0';			mtype = ++p;			if (NULL == (p = strchr(mtype, ' ')))				continue;			*p = '/0';			zbx_json_addobject(&j, NULL);			zbx_json_addstring(&j, "{#FSNAME}", mpoint, ZBX_JSON_TYPE_STRING);			zbx_json_addstring(&j, "{#FSTYPE}", mtype, ZBX_JSON_TYPE_STRING);			zbx_json_close(&j);		}		zbx_fclose(f);		ret = SYSINFO_RET_OK;	}	zbx_json_close(&j);	SET_STR_RESULT(result, zbx_strdup(NULL, j.buffer));	zbx_json_free(&j);	return ret;}

int	VFS_FS_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result){	int		rc, sz, i, ret = SYSINFO_RET_FAIL;	struct vmount	*vms = NULL, *vm;	struct zbx_json	j;	/* check how many bytes to allocate for the mounted filesystems */	if (-1 == (rc = mntctl(MCTL_QUERY, sizeof(sz), (char *)&sz)))	{		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno)));		return SYSINFO_RET_FAIL;	}	vms = zbx_malloc(vms, (size_t)sz);	/* get the list of mounted filesystems */	/* return code is number of filesystems returned */	if (-1 == (rc = mntctl(MCTL_QUERY, sz, (char *)vms)))	{		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno)));		goto error;	}	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	for (i = 0, vm = vms; i < rc; i++)	{		zbx_json_addobject(&j, NULL);		zbx_json_addstring(&j, "{#FSNAME}", (char *)vm + vm->vmt_data[VMT_STUB].vmt_off, ZBX_JSON_TYPE_STRING);		zbx_json_addstring(&j, "{#FSTYPE}", zbx_get_vfs_name_by_type(vm->vmt_gfstype), ZBX_JSON_TYPE_STRING);		zbx_json_close(&j);		/* go to the next vmount structure */		vm = (struct vmount *)((char *)vm + vm->vmt_length);	}	zbx_json_close(&j);	SET_STR_RESULT(result, zbx_strdup(NULL, j.buffer));	zbx_json_free(&j);	ret = SYSINFO_RET_OK;error:	zbx_free(vms);	return ret;}

/****************************************************************************** *                                                                            * * Function: send_proxyhistory                                                * *                                                                            * * Purpose: send history data to a Zabbix server                              * *                                                                            * ******************************************************************************/static void	send_proxyhistory(zbx_socket_t *sock, zbx_timespec_t *ts){	const char	*__function_name = "send_proxyhistory";	struct zbx_json	j;	zbx_uint64_t	lastid;	int		records, ret = FAIL;	char		*error = NULL;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	if (SUCCEED != check_access_passive_proxy(sock, ZBX_DO_NOT_SEND_RESPONSE, "history data request"))	{		/* do not send any reply to server in this case as the server expects history data */		goto out1;	}	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	records = proxy_get_hist_data(&j, &lastid);	zbx_json_close(&j);	zbx_json_adduint64(&j, ZBX_PROTO_TAG_CLOCK, ts->sec);	zbx_json_adduint64(&j, ZBX_PROTO_TAG_NS, ts->ns);	if (SUCCEED != zbx_tcp_send_to(sock, j.buffer, CONFIG_TIMEOUT))	{		error = zbx_strdup(error, zbx_socket_strerror());		goto out;	}	if (SUCCEED != zbx_recv_response(sock, CONFIG_TIMEOUT, &error))		goto out;	if (0 != records)		proxy_set_hist_lastid(lastid);	ret = SUCCEED;out:	if (SUCCEED != ret)		zabbix_log(LOG_LEVEL_WARNING, "cannot send history data to server at /"%s/": %s", sock->peer, error);	zbx_json_free(&j);	zbx_free(error);out1:	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

int	check_vcenter_hv_datastore_discovery(AGENT_REQUEST *request, const char *username, const char *password,		AGENT_RESULT *result){	char			*url, *uuid;	zbx_vmware_service_t	*service;	zbx_vmware_hv_t		*hv;	struct zbx_json		json_data;	int			i, ret = SYSINFO_RET_FAIL;	if (2 != request->nparam)		return SYSINFO_RET_FAIL;	url = get_rparam(request, 0);	uuid = get_rparam(request, 1);	zbx_vmware_lock();	if (NULL == (service = get_vmware_service(url, username, password, result, &ret)))		goto unlock;	if (NULL == (hv = hv_get(&service->data->hvs, uuid)))		goto unlock;	zbx_json_init(&json_data, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&json_data, ZBX_PROTO_TAG_DATA);	for (i = 0; i < hv->datastores.values_num; i++)	{		zbx_vmware_datastore_t	*datastore = hv->datastores.values[i];		zbx_json_addobject(&json_data, NULL);		zbx_json_addstring(&json_data, "{#DATASTORE}", datastore->name, ZBX_JSON_TYPE_STRING);		zbx_json_close(&json_data);	}	zbx_json_close(&json_data);	SET_STR_RESULT(result, zbx_strdup(NULL, json_data.buffer));	zbx_json_free(&json_data);	ret = SYSINFO_RET_OK;unlock:	zbx_vmware_unlock();	return ret;}

/****************************************************************************** *                                                                            * * Function: send_proxyconfig                                                 * *                                                                            * * Purpose: send configuration tables to the proxy from server                * *          (for active proxies)                                              * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * ******************************************************************************/void	send_proxyconfig(zbx_socket_t *sock, struct zbx_json_parse *jp){	const char	*__function_name = "send_proxyconfig";	zbx_uint64_t	proxy_hostid;	char		host[HOST_HOST_LEN_MAX], *error = NULL;	struct zbx_json	j;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	if (SUCCEED != get_active_proxy_id(jp, &proxy_hostid, host, sock, &error))	{		zbx_send_response(sock, FAIL, error, CONFIG_TIMEOUT);		zabbix_log(LOG_LEVEL_WARNING, "cannot parse proxy configuration data request from active proxy at"				" /"%s/": %s", sock->peer, error);		goto out;	}	update_proxy_lastaccess(proxy_hostid);	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	if (SUCCEED != get_proxyconfig_data(proxy_hostid, &j, &error))	{		zbx_send_response(sock, FAIL, error, CONFIG_TIMEOUT);		zabbix_log(LOG_LEVEL_WARNING, "cannot collect configuration data for proxy /"%s/" at /"%s/": %s",				host, sock->peer, error);		goto clean;	}	zabbix_log(LOG_LEVEL_WARNING, "sending configuration data to proxy /"%s/" at /"%s/", datalen " ZBX_FS_SIZE_T,			host, sock->peer, (zbx_fs_size_t)j.buffer_size);	zabbix_log(LOG_LEVEL_DEBUG, "%s", j.buffer);	if (SUCCEED != zbx_tcp_send_to(sock, j.buffer, CONFIG_TRAPPER_TIMEOUT))	{		zabbix_log(LOG_LEVEL_WARNING, "cannot send configuration data to proxy /"%s/" at /"%s/": %s",				host, sock->peer, zbx_socket_strerror());	}clean:	zbx_json_free(&j);out:	zbx_free(error);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

/****************************************************************************** *                                                                            * * Function: send_result                                                      * *                                                                            * * Purpose: send json SUCCEED or FAIL to socket along with an info message    * *                                                                            * * Parameters: result SUCCEED or FAIL                                         * *                                                                            * * Return value:  SUCCEED - processed successfully                            * *                FAIL - an error occured                                     * *                                                                            * * Author: Alexei Vladishev                                                   * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/int	send_result(zbx_sock_t *sock, int result, char *info){	int	ret = SUCCEED;	struct	zbx_json json;	zbx_json_init(&json, 1024);	zbx_json_addstring(&json, ZBX_PROTO_TAG_RESPONSE, SUCCEED == result ? ZBX_PROTO_VALUE_SUCCESS : ZBX_PROTO_VALUE_FAILED, ZBX_JSON_TYPE_STRING);	if(info != NULL && info[0]!='/0')	{		zbx_json_addstring(&json, ZBX_PROTO_TAG_INFO, info, ZBX_JSON_TYPE_STRING);	}	ret = zbx_tcp_send(sock, json.buffer);	zbx_json_free(&json);	return ret;}

/****************************************************************************** *                                                                            * * Function: send_areg_data                                                   * *                                                                            * * Purpose: send auto-registration data from proxy to a server                * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * ******************************************************************************/void	send_areg_data(zbx_sock_t *sock){	const char	*__function_name = "send_areg_data";	struct zbx_json	j;	zbx_uint64_t	lastid;	int		records;	char		*info = NULL, *error = NULL;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	records = proxy_get_areg_data(&j, &lastid);	zbx_json_close(&j);	zbx_json_adduint64(&j, ZBX_PROTO_TAG_CLOCK, (int)time(NULL));	if (SUCCEED != zbx_tcp_send_to(sock, j.buffer, CONFIG_TIMEOUT))	{		zabbix_log(LOG_LEVEL_WARNING, "error while sending auto-registration data to server: %s",				zbx_tcp_strerror());		goto out;	}	if (SUCCEED != zbx_recv_response(sock, &info, CONFIG_TIMEOUT, &error))	{		zabbix_log(LOG_LEVEL_WARNING, "sending auto-registration data to server: error:/"%s/", info:/"%s/"",				ZBX_NULL2EMPTY_STR(error), ZBX_NULL2EMPTY_STR(info));		goto out;	}	if (0 != records)		proxy_set_areg_lastid(lastid);out:	zbx_json_free(&j);	zbx_free(info);	zbx_free(error);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

int	VFS_FS_DISCOVERY(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result){	int		rc, sz, i, ret = SYSINFO_RET_FAIL;	struct vmount	*vm = NULL;	struct zbx_json	j;	/* check how many bytes to allocate for the mounted filesystems */	if (-1 == (rc = mntctl(MCTL_QUERY, sizeof(sz), (char *)&sz)))		return ret;	vm = zbx_malloc(vm, (size_t)sz);	/* get the list of mounted filesystems */	/* return code is number of filesystems returned */	if (-1 == (rc = mntctl(MCTL_QUERY, sz, (char *)vm)))		goto error;	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	for (i = 0; i < rc; i++)	{		zbx_json_addobject(&j, NULL);		zbx_json_addstring(&j, "{#FSNAME}", (char *)vm + vm->vmt_data[VMT_STUB].vmt_off, ZBX_JSON_TYPE_STRING);		zbx_json_addstring(&j, "{#FSTYPE}", zbx_get_vfs_name_by_type(vm->vmt_gfstype), ZBX_JSON_TYPE_STRING);		zbx_json_close(&j);		/* go to the next vmount structure */		vm = (struct vmount *)((char *)vm + vm->vmt_length);	}	zbx_json_close(&j);	SET_STR_RESULT(result, zbx_strdup(NULL, j.buffer));	zbx_json_free(&j);	ret = SYSINFO_RET_OK;error:	zbx_free(vm);	return ret;}

int	check_vcenter_cluster_discovery(AGENT_REQUEST *request, const char *username, const char *password,		AGENT_RESULT *result){	struct zbx_json		json_data;	int			i, ret = SYSINFO_RET_FAIL;	char			*url;	zbx_vmware_service_t	*service;	if (1 != request->nparam)		return SYSINFO_RET_FAIL;	url = get_rparam(request, 0);	zbx_vmware_lock();	if (NULL == (service = get_vmware_service(url, username, password, result, &ret)))		goto unlock;	zbx_json_init(&json_data, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&json_data, ZBX_PROTO_TAG_DATA);	for (i = 0; i < service->data->clusters.values_num; i++)	{		zbx_vmware_cluster_t	*cluster = (zbx_vmware_cluster_t *)service->data->clusters.values[i];		zbx_json_addobject(&json_data, NULL);		zbx_json_addstring(&json_data, "{#CLUSTER.ID}", cluster->id, ZBX_JSON_TYPE_STRING);		zbx_json_addstring(&json_data, "{#CLUSTER.NAME}", cluster->name, ZBX_JSON_TYPE_STRING);		zbx_json_close(&json_data);	}	zbx_json_close(&json_data);	SET_STR_RESULT(result, zbx_strdup(NULL, json_data.buffer));	zbx_json_free(&json_data);	ret = SYSINFO_RET_OK;unlock:	zbx_vmware_unlock();	return ret;}

int	NET_IF_DISCOVERY(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result){	int		ret = SYSINFO_RET_FAIL;	char		line[MAX_STRING_LEN], *p;	FILE		*f;	struct zbx_json	j;	zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);	if (NULL != (f = fopen("/proc/net/dev", "r")))	{		while (NULL != fgets(line, sizeof(line), f))		{			if (NULL == (p = strstr(line, ":")))				continue;			*p = '/0';			/* trim left spaces */			for (p = line; ' ' == *p && '/0' != *p; p++)				;			zbx_json_addobject(&j, NULL);			zbx_json_addstring(&j, "{#IFNAME}", p, ZBX_JSON_TYPE_STRING);			zbx_json_close(&j);		}		zbx_fclose(f);		ret = SYSINFO_RET_OK;	}	zbx_json_close(&j);	SET_STR_RESULT(result, strdup(j.buffer));	zbx_json_free(&j);	return ret;}

int	SYSTEM_CPU_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result){	int			i;	zbx_vector_uint64_t	cpus;	struct zbx_json		json;	zbx_vector_uint64_create(&cpus);	if (SUCCEED != get_cpu_statuses(&cpus))	{		SET_MSG_RESULT(result, zbx_strdup(NULL, "Collector in not started."));		zbx_vector_uint64_destroy(&cpus);		return SYSINFO_RET_FAIL;	}	zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);	zbx_json_addarray(&json, ZBX_PROTO_TAG_DATA);	for (i = 0; i < cpus.values_num; i++)	{		zbx_json_addobject(&json, NULL);		zbx_json_adduint64(&json, "{#CPU.NUMBER}", i);		zbx_json_addstring(&json, "{#CPU.STATUS}", (PERF_COUNTER_ACTIVE == cpus.values[i]) ?				"online" :				(PERF_COUNTER_INITIALIZED == cpus.values[i]) ? "unknown" : "offline",				ZBX_JSON_TYPE_STRING);		zbx_json_close(&json);	}	zbx_json_close(&json);	SET_STR_RESULT(result, zbx_strdup(result->str, json.buffer));	zbx_json_free(&json);	zbx_vector_uint64_destroy(&cpus);	return SYSINFO_RET_OK;}