/******************************************************************************
* *
* 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 NET_IF_DISCOVERY(AGENT_REQUEST *request, AGENT_RESULT *result)
{
char line[MAX_STRING_LEN], *p;
FILE *f;
struct zbx_json j;
if (NULL == (f = fopen("/proc/net/dev", "r")))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot open /proc/net/dev: %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);
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);
zbx_json_close(&j);
SET_STR_RESULT(result, strdup(j.buffer));
zbx_json_free(&j);
return SYSINFO_RET_OK;
}
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;
}