static void svc_get_fullpath(const char *path, wchar_t *fullpath, size_t max_fullpath)
{
wchar_t *wpath;
wpath = zbx_acp_to_unicode(path);
_wfullpath(fullpath, wpath, max_fullpath);
zbx_free(wpath);
}
static void svc_get_fullpath(const char *path, LPTSTR fullpath, size_t max_fullpath)
{
LPTSTR wpath;
wpath = zbx_acp_to_unicode(path);
zbx_fullpath(fullpath, wpath, max_fullpath);
zbx_free(wpath);
}
/******************************************************************************
* *
* Function: load_perf_counters *
* *
* Purpose: load performance counters from configuration *
* *
* Parameters: lines - array of PerfCounter configuration entries *
* *
* Return value: *
* *
* Author: Vladimir Levijev *
* *
* Comments: *
* *
******************************************************************************/
void load_perf_counters(const char **lines)
{
char name[MAX_STRING_LEN], counterpath[PDH_MAX_COUNTER_PATH], interval[8];
const char **pline, *msg;
LPTSTR wcounterPath;
#define ZBX_PC_FAIL(_msg) {msg = _msg; goto pc_fail;}
for (pline = lines; NULL != *pline; pline++)
{
if (3 < num_param(*pline))
ZBX_PC_FAIL("required parameter missing");
if (0 != get_param(*pline, 1, name, sizeof(name)))
ZBX_PC_FAIL("cannot parse key");
if (0 != get_param(*pline, 2, counterpath, sizeof(counterpath)))
ZBX_PC_FAIL("cannot parse counter path");
if (0 != get_param(*pline, 3, interval, sizeof(interval)))
ZBX_PC_FAIL("cannot parse interval");
wcounterPath = zbx_acp_to_unicode(counterpath);
zbx_unicode_to_utf8_static(wcounterPath, counterpath, PDH_MAX_COUNTER_PATH);
zbx_free(wcounterPath);
if (FAIL == check_counter_path(counterpath))
ZBX_PC_FAIL("invalid counter path");
if (NULL == add_perf_counter(name, counterpath, atoi(interval)))
ZBX_PC_FAIL("cannot add counter");
continue;
pc_fail:
zabbix_log(LOG_LEVEL_CRIT, "PerfCounter '%s' FAILED: %s", *pline, msg);
exit(FAIL);
}
#undef ZBX_PC_FAIL
}
int NET_IF_LIST(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
DWORD dwSize, dwRetVal, i, j;
char *buf = NULL;
size_t buf_alloc = 512, buf_offset = 0;
int ret = SYSINFO_RET_FAIL;
/* variables used for GetIfTable and GetIfEntry */
MIB_IFTABLE *pIfTable = NULL;
MIB_IFROW pIfRow;
/* variables used for GetIpAddrTable */
MIB_IPADDRTABLE *pIPAddrTable = NULL;
IN_ADDR in_addr;
/* Allocate memory for our pointers. */
dwSize = sizeof(MIB_IPADDRTABLE);
pIPAddrTable = (MIB_IPADDRTABLE *)zbx_malloc(pIPAddrTable, sizeof(MIB_IPADDRTABLE));
/* Make an initial call to GetIpAddrTable to get the
necessary size into the dwSize variable */
if (ERROR_INSUFFICIENT_BUFFER == GetIpAddrTable(pIPAddrTable, &dwSize, 0))
pIPAddrTable = (MIB_IPADDRTABLE *)zbx_realloc(pIPAddrTable, dwSize);
/* Make a second call to GetIpAddrTable to get the
actual data we want */
if (NO_ERROR != (dwRetVal = GetIpAddrTable(pIPAddrTable, &dwSize, 0)))
{
zabbix_log(LOG_LEVEL_DEBUG, "GetIpAddrTable failed with error: %s", strerror_from_system(dwRetVal));
goto clean;
}
/* Allocate memory for our pointers. */
dwSize = sizeof(MIB_IFTABLE);
pIfTable = (MIB_IFTABLE *)zbx_malloc(pIfTable, dwSize);
/* Before calling GetIfEntry, we call GetIfTable to make
sure there are entries to get and retrieve the interface index.
Make an initial call to GetIfTable to get the necessary size into dwSize */
if (ERROR_INSUFFICIENT_BUFFER == GetIfTable(pIfTable, &dwSize, 0))
pIfTable = (MIB_IFTABLE *)zbx_realloc(pIfTable, dwSize);
/* Make a second call to GetIfTable to get the actual data we want. */
if (NO_ERROR != (dwRetVal = GetIfTable(pIfTable, &dwSize, 0)))
{
zabbix_log(LOG_LEVEL_DEBUG, "GetIfTable failed with error: %s", strerror_from_system(dwRetVal));
goto clean;
}
buf = (char *)zbx_malloc(buf, sizeof(char) * buf_alloc);
if (pIfTable->dwNumEntries > 0)
{
for (i = 0; i < (int)pIfTable->dwNumEntries; i++)
{
LPTSTR wdescr;
LPSTR utf8_descr;
pIfRow.dwIndex = pIfTable->table[i].dwIndex;
if (NO_ERROR != (dwRetVal = GetIfEntry(&pIfRow)))
{
zabbix_log(LOG_LEVEL_DEBUG, "GetIfEntry failed with error: %s",
strerror_from_system(dwRetVal));
continue;
}
zbx_snprintf_alloc(&buf, &buf_alloc, &buf_offset,
"%-25s", get_if_type_string(pIfRow.dwType));
zbx_snprintf_alloc(&buf, &buf_alloc, &buf_offset,
" %-8s", get_if_adminstatus_string(pIfRow.dwAdminStatus));
for (j = 0; j < pIPAddrTable->dwNumEntries; j++)
if (pIPAddrTable->table[j].dwIndex == pIfRow.dwIndex)
{
in_addr.S_un.S_addr = pIPAddrTable->table[j].dwAddr;
zbx_snprintf_alloc(&buf, &buf_alloc, &buf_offset,
" %-15s", inet_ntoa(in_addr));
break;
}
if (j == pIPAddrTable->dwNumEntries)
zbx_strcpy_alloc(&buf, &buf_alloc, &buf_offset, " -");
wdescr = zbx_acp_to_unicode(pIfRow.bDescr);
utf8_descr = zbx_unicode_to_utf8(wdescr);
zbx_snprintf_alloc(&buf, &buf_alloc, &buf_offset, " %s\n", utf8_descr);
zbx_free(utf8_descr);
zbx_free(wdescr);
}
}
SET_TEXT_RESULT(result, buf);
ret = SYSINFO_RET_OK;
clean:
zbx_free(pIfTable);
zbx_free(pIPAddrTable);
return ret;
}
/*
* returns interface statistics by IP address or interface name
*/
static int get_if_stats(const char *if_name, MIB_IFROW *pIfRow)
{
DWORD dwSize, dwRetVal, i, j;
int ret = FAIL;
char ip[16];
/* variables used for GetIfTable and GetIfEntry */
MIB_IFTABLE *pIfTable = NULL;
/* variables used for GetIpAddrTable */
MIB_IPADDRTABLE *pIPAddrTable = NULL;
IN_ADDR in_addr;
/* Allocate memory for our pointers. */
dwSize = sizeof(MIB_IPADDRTABLE);
pIPAddrTable = (MIB_IPADDRTABLE *)zbx_malloc(pIPAddrTable, sizeof(MIB_IPADDRTABLE));
/* Make an initial call to GetIpAddrTable to get the
necessary size into the dwSize variable */
if (ERROR_INSUFFICIENT_BUFFER == GetIpAddrTable(pIPAddrTable, &dwSize, 0))
pIPAddrTable = (MIB_IPADDRTABLE *)zbx_realloc(pIPAddrTable, dwSize);
/* Make a second call to GetIpAddrTable to get the
actual data we want */
if (NO_ERROR != (dwRetVal = GetIpAddrTable(pIPAddrTable, &dwSize, 0)))
{
zabbix_log(LOG_LEVEL_DEBUG, "GetIpAddrTable failed with error: %s", strerror_from_system(dwRetVal));
goto clean;
}
/* Allocate memory for our pointers. */
dwSize = sizeof(MIB_IFTABLE);
pIfTable = (MIB_IFTABLE *)zbx_malloc(pIfTable, dwSize);
/* Before calling GetIfEntry, we call GetIfTable to make
sure there are entries to get and retrieve the interface index.
Make an initial call to GetIfTable to get the necessary size into dwSize */
if (ERROR_INSUFFICIENT_BUFFER == GetIfTable(pIfTable, &dwSize, 0))
pIfTable = (MIB_IFTABLE *)zbx_realloc(pIfTable, dwSize);
/* Make a second call to GetIfTable to get the actual data we want. */
if (NO_ERROR != (dwRetVal = GetIfTable(pIfTable, &dwSize, 0)))
{
zabbix_log(LOG_LEVEL_DEBUG, "GetIfTable failed with error: %s", strerror_from_system(dwRetVal));
goto clean;
}
for (i = 0; i < pIfTable->dwNumEntries; i++)
{
LPTSTR wdescr;
LPSTR utf8_descr;
pIfRow->dwIndex = pIfTable->table[i].dwIndex;
if (NO_ERROR != (dwRetVal = GetIfEntry(pIfRow)))
{
zabbix_log(LOG_LEVEL_DEBUG, "GetIfEntry failed with error: %s",
strerror_from_system(dwRetVal));
continue;
}
wdescr = zbx_acp_to_unicode(pIfRow->bDescr);
utf8_descr = zbx_unicode_to_utf8(wdescr);
if (0 == strcmp(if_name, utf8_descr))
ret = SUCCEED;
zbx_free(utf8_descr);
zbx_free(wdescr);
if (SUCCEED == ret)
break;
for (j = 0; j < pIPAddrTable->dwNumEntries; j++)
{
if (pIPAddrTable->table[j].dwIndex == pIfRow->dwIndex)
{
in_addr.S_un.S_addr = pIPAddrTable->table[j].dwAddr;
zbx_snprintf(ip, sizeof(ip), "%s", inet_ntoa(in_addr));
if (0 == strcmp(if_name, ip))
{
ret = SUCCEED;
break;
}
}
}
if (SUCCEED == ret)
break;
}
clean:
zbx_free(pIfTable);
zbx_free(pIPAddrTable);
return ret;
}
int NET_IF_DISCOVERY(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
DWORD dwSize, dwRetVal, i;
int ret = SYSINFO_RET_FAIL;
/* variables used for GetIfTable and GetIfEntry */
MIB_IFTABLE *pIfTable = NULL;
MIB_IFROW pIfRow;
struct zbx_json j;
LPTSTR wdescr;
LPSTR utf8_descr;
zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);
/* Allocate memory for our pointers. */
dwSize = sizeof(MIB_IFTABLE);
pIfTable = (MIB_IFTABLE *)zbx_malloc(pIfTable, dwSize);
/* Before calling GetIfEntry, we call GetIfTable to make
sure there are entries to get and retrieve the interface index.
Make an initial call to GetIfTable to get the necessary size into dwSize */
if (ERROR_INSUFFICIENT_BUFFER == GetIfTable(pIfTable, &dwSize, 0))
pIfTable = (MIB_IFTABLE *)zbx_realloc(pIfTable, dwSize);
/* Make a second call to GetIfTable to get the actual data we want. */
if (NO_ERROR != (dwRetVal = GetIfTable(pIfTable, &dwSize, 0)))
{
zabbix_log(LOG_LEVEL_DEBUG, "GetIfTable failed with error: %s", strerror_from_system(dwRetVal));
goto clean;
}
for (i = 0; i < pIfTable->dwNumEntries; i++)
{
pIfRow.dwIndex = pIfTable->table[i].dwIndex;
if (NO_ERROR != (dwRetVal = GetIfEntry(&pIfRow)))
{
zabbix_log(LOG_LEVEL_DEBUG, "GetIfEntry failed with error: %s", strerror_from_system(dwRetVal));
continue;
}
zbx_json_addobject(&j, NULL);
wdescr = zbx_acp_to_unicode(pIfRow.bDescr);
utf8_descr = zbx_unicode_to_utf8(wdescr);
zbx_json_addstring(&j, "{#IFNAME}", utf8_descr, ZBX_JSON_TYPE_STRING);
zbx_free(utf8_descr);
zbx_free(wdescr);
zbx_json_close(&j);
}
zbx_json_close(&j);
SET_STR_RESULT(result, strdup(j.buffer));
zbx_json_free(&j);
ret = SYSINFO_RET_OK;
clean:
zbx_free(pIfTable);
return ret;
}
/******************************************************************************
* *
* Function: load_perf_counters *
* *
* Purpose: load performance counters from configuration *
* *
* Parameters: lines - array of PerfCounter configuration entries *
* *
* Return value: *
* *
* Author: Vladimir Levijev *
* *
* Comments: *
* *
******************************************************************************/
void load_perf_counters(const char **lines)
{
char name[MAX_STRING_LEN], counterpath[PDH_MAX_COUNTER_PATH], interval[8];
const char **pline;
char *error = NULL;
LPTSTR wcounterPath;
int period;
for (pline = lines; NULL != *pline; pline++)
{
if (3 < num_param(*pline))
{
error = zbx_strdup(error, "Required parameter missing.");
goto pc_fail;
}
if (0 != get_param(*pline, 1, name, sizeof(name)))
{
error = zbx_strdup(error, "Cannot parse key.");
goto pc_fail;
}
if (0 != get_param(*pline, 2, counterpath, sizeof(counterpath)))
{
error = zbx_strdup(error, "Cannot parse counter path.");
goto pc_fail;
}
if (0 != get_param(*pline, 3, interval, sizeof(interval)))
{
error = zbx_strdup(error, "Cannot parse interval.");
goto pc_fail;
}
wcounterPath = zbx_acp_to_unicode(counterpath);
zbx_unicode_to_utf8_static(wcounterPath, counterpath, PDH_MAX_COUNTER_PATH);
zbx_free(wcounterPath);
if (FAIL == check_counter_path(counterpath))
{
error = zbx_strdup(error, "Invalid counter path.");
goto pc_fail;
}
period = atoi(interval);
if (1 > period || MAX_COLLECTOR_PERIOD < period)
{
error = zbx_strdup(NULL, "Interval out of range.");
goto pc_fail;
}
if (NULL == add_perf_counter(name, counterpath, period, &error))
{
if (NULL == error)
error = zbx_strdup(error, "Failed to add new performance counter.");
goto pc_fail;
}
continue;
pc_fail:
zabbix_log(LOG_LEVEL_CRIT, "cannot add performance counter \"%s\": %s", *pline, error);
zbx_free(error);
exit(EXIT_FAILURE);
}
}
