int SYSTEM_HW_DEVICES(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
char tmp[MAX_STRING_LEN];
if (1 < num_param(param))
return SYSINFO_RET_FAIL;
if (0 != get_param(param, 1, tmp, sizeof(tmp)) || '\0' == *tmp || 0 == strcmp(tmp, "pci"))
return EXECUTE_STR(cmd, "lspci", flags, result); /* list PCI devices by default */
else if (0 == strcmp(tmp, "usb"))
return EXECUTE_STR(cmd, "lsusb", flags, result);
return SYSINFO_RET_FAIL;
}
int SYSTEM_HW_DEVICES(AGENT_REQUEST *request, AGENT_RESULT *result)
{
char *type;
if (1 < request->nparam)
return SYSINFO_RET_FAIL;
type = get_rparam(request, 0);
if (NULL == type || '\0' == *type || 0 == strcmp(type, "pci"))
return EXECUTE_STR("lspci", result); /* list PCI devices by default */
else if (0 == strcmp(type, "usb"))
return EXECUTE_STR("lsusb", result);
return SYSINFO_RET_FAIL;
}
static int SYSTEM_RUN(AGENT_REQUEST *request, AGENT_RESULT *result)
{
char *command, *flag;
if (2 < request->nparam)
return SYSINFO_RET_FAIL;
command = get_rparam(request, 0);
flag = get_rparam(request, 1);
if (NULL == command || '\0' == *command)
return SYSINFO_RET_FAIL;
if (1 == CONFIG_LOG_REMOTE_COMMANDS)
zabbix_log(LOG_LEVEL_WARNING, "Executing command '%s'", command);
else
zabbix_log(LOG_LEVEL_DEBUG, "Executing command '%s'", command);
if (NULL == flag || '\0' == *flag || 0 == strcmp(flag, "wait")) /* default parameter */
return EXECUTE_STR(command, result);
else if (0 != strcmp(flag, "nowait") || SUCCEED != zbx_execute_nowait(command))
return SYSINFO_RET_FAIL;
SET_UI64_RESULT(result, 1);
return SYSINFO_RET_OK;
}
int SYSTEM_HOSTNAME(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
#ifdef _WINDOWS
DWORD dwSize = 256;
TCHAR computerName[256];
char buffer[256];
int netbios, ret;
WSADATA sockInfo;
if (1 < num_param(param))
return SYSINFO_RET_FAIL;
if (0 != get_param(param, 1, buffer, sizeof(buffer)))
*buffer = '\0';
if ('\0' == *buffer || 0 == strcmp(buffer, "netbios"))
netbios = 1;
else if (0 == strcmp(buffer, "host"))
netbios = 0;
else
return SYSINFO_RET_FAIL;
if (1 == netbios)
{
/* Buffer size is chosen large enough to contain any DNS name, not just MAX_COMPUTERNAME_LENGTH + 1 */
/* characters. MAX_COMPUTERNAME_LENGTH is usually less than 32, but it varies among systems, so we */
/* cannot use the constant in a precompiled Windows agent, which is expected to work on any system. */
if (0 == GetComputerName(computerName, &dwSize))
zabbix_log(LOG_LEVEL_ERR, "GetComputerName() failed: %s", strerror_from_system(GetLastError()));
else
SET_STR_RESULT(result, zbx_unicode_to_utf8(computerName));
}
else
{
if (0 != (ret = WSAStartup(MAKEWORD(2, 2), &sockInfo)))
zabbix_log(LOG_LEVEL_ERR, "WSAStartup() failed: %s", strerror_from_system(ret));
else if (SUCCEED != gethostname(buffer, sizeof(buffer)))
zabbix_log(LOG_LEVEL_ERR, "gethostname() failed: %s", strerror_from_system(WSAGetLastError()));
else
SET_STR_RESULT(result, zbx_strdup(NULL, buffer));
}
if (ISSET_STR(result))
return SYSINFO_RET_OK;
else
return SYSINFO_RET_FAIL;
#else
return EXECUTE_STR(cmd, "hostname", flags, result);
#endif
}
int EXECUTE_INT(const char *command, AGENT_RESULT *result)
{
if (SYSINFO_RET_OK != EXECUTE_STR(command, result))
return SYSINFO_RET_FAIL;
if (NULL == GET_UI64_RESULT(result))
{
zabbix_log(LOG_LEVEL_WARNING, "Remote command [%s] result is not unsigned integer", command);
return SYSINFO_RET_FAIL;
}
UNSET_RESULT_EXCLUDING(result, AR_UINT64);
return SYSINFO_RET_OK;
}
int EXECUTE_DBL(const char *command, AGENT_RESULT *result)
{
if (SYSINFO_RET_OK != EXECUTE_STR(command, result))
return SYSINFO_RET_FAIL;
if (NULL == GET_DBL_RESULT(result))
{
zabbix_log(LOG_LEVEL_WARNING, "Remote command [%s] result is not double", command);
return SYSINFO_RET_FAIL;
}
UNSET_RESULT_EXCLUDING(result, AR_DOUBLE);
return SYSINFO_RET_OK;
}
int EXECUTE_INT(const char *cmd, const char *command, unsigned flags, AGENT_RESULT *result)
{
int ret = SYSINFO_RET_FAIL;
ret = EXECUTE_STR(cmd,command,flags,result);
if(SYSINFO_RET_OK == ret)
{
if( NULL == GET_DBL_RESULT(result) )
{
zabbix_log(LOG_LEVEL_WARNING, "Remote command [%s] result is not double", command);
ret = SYSINFO_RET_FAIL;
}
UNSET_RESULT_EXCLUDING(result, AR_DOUBLE);
}
return ret;
}
int EXECUTE_USER_PARAMETER(AGENT_REQUEST *request, AGENT_RESULT *result)
{
int ret;
char *command;
if (1 != request->nparam)
return SYSINFO_RET_FAIL;
command = get_rparam(request, 0);
ret = EXECUTE_STR(command, result);
if (SYSINFO_RET_FAIL == ret && 0 == result->type)
{
/* only whitespace */
SET_TEXT_RESULT(result, zbx_strdup(NULL, ""));
ret = SYSINFO_RET_OK;
}
return ret;
}
int RUN_COMMAND(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
#define MAX_FLAG_LEN 10
char command[MAX_STRING_LEN];
char flag[MAX_FLAG_LEN];
#if defined (_WINDOWS)
STARTUPINFO si;
PROCESS_INFORMATION pi;
char full_command[MAX_STRING_LEN];
#else /* not _WINDOWS */
pid_t pid;
#endif
assert(result);
init_result(result);
if (CONFIG_ENABLE_REMOTE_COMMANDS != 1)
{
SET_MSG_RESULT(result, strdup("ZBX_NOTSUPPORTED"));
return SYSINFO_RET_FAIL;
}
if (num_param(param) > 2)
return SYSINFO_RET_FAIL;
if (0 != get_param(param, 1, command, sizeof(command)))
return SYSINFO_RET_FAIL;
if (*command == '\0')
return SYSINFO_RET_FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "Run command '%s'", command);
if (0 != get_param(param, 2, flag, sizeof(flag)))
*flag = '\0';
if (*flag == '\0')
zbx_snprintf(flag, sizeof(flag), "wait");
if (0 == strcmp(flag, "wait"))
return EXECUTE_STR(cmd,command,flags,result);
else if(0 != strcmp(flag,"nowait"))
return SYSINFO_RET_FAIL;
#if defined(_WINDOWS)
zbx_snprintf(full_command, sizeof(full_command), "cmd /C \"%s\"", command);
GetStartupInfo(&si);
zabbix_log(LOG_LEVEL_DEBUG, "Execute command '%s'",full_command);
if(!CreateProcess(
NULL, /* No module name (use command line) */
full_command,/* Name of app to launch */
NULL, /* Default process security attributes */
NULL, /* Default thread security attributes */
FALSE, /* Don't inherit handles from the parent */
0, /* Normal priority */
NULL, /* Use the same environment as the parent */
NULL, /* Launch in the current directory */
&si, /* Startup Information */
&pi)) /* Process information stored upon return */
{
return SYSINFO_RET_FAIL;
}
#else /* not _WINDOWS */
pid = zbx_fork(); /* run new thread 1 */
switch(pid)
{
case -1:
zabbix_log(LOG_LEVEL_WARNING, "fork failed for command '%s'",command);
return SYSINFO_RET_FAIL;
case 0:
pid = zbx_fork(); /* run new tread 2 to replace by command */
switch(pid)
{
case -1:
zabbix_log(LOG_LEVEL_WARNING, "fork2 failed for '%s'",command);
return SYSINFO_RET_FAIL;
case 0:
/*
* DON'T REMOVE SLEEP
* sleep needed to return server result as "1"
* then we can run "execl"
* otherwise command print result into socket with STDOUT id
*/
sleep(3);
/**/
/* replace thread 2 by the execution of command */
if(execl("/bin/sh", "sh", "-c", command, (char *)0))
{
zabbix_log(LOG_LEVEL_WARNING, "execl failed for command '%s'",command);
}
/* In normal case the program will never reach this point */
exit(0);
default:
waitpid(pid, NULL, WNOHANG); /* NO WAIT can be used for thread 2 closing */
exit(0); /* close thread 1 and transmit thread 2 to system (solve zombie state) */
break;
}
default:
waitpid(pid, NULL, 0); /* wait thread 1 closing */
break;
}
#endif /* _WINDOWS */
SET_UI64_RESULT(result, 1);
return SYSINFO_RET_OK;
}
int SYSTEM_UNAME(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
#ifdef _WINDOWS
typedef void (WINAPI *PGNSI)(LPSYSTEM_INFO);
DWORD dwSize = 256;
TCHAR computer_name[256];
SYSTEM_INFO si;
OSVERSIONINFOEX vi;
char *os = NULL, *utf8;
size_t os_alloc = 256, os_offset = 0;
PGNSI pGNSI;
/* Buffer size is chosen large enough to contain any DNS name, not just MAX_COMPUTERNAME_LENGTH + 1 */
/* characters. MAX_COMPUTERNAME_LENGTH is usually less than 32, but it varies among systems, so we */
/* cannot use the constant in a precompiled Windows agent, which is expected to work on any system. */
if (0 == GetComputerName(computer_name, &dwSize))
*computer_name = '\0';
memset(&si, 0, sizeof(si));
memset(&vi, 0, sizeof(vi));
vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
if (TRUE != GetVersionEx((OSVERSIONINFO *)&vi))
return SYSINFO_RET_FAIL;
if (NULL != (pGNSI = (PGNSI)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetNativeSystemInfo")))
pGNSI(&si);
else
GetSystemInfo(&si);
os = zbx_malloc(os, os_alloc);
zbx_strcpy_alloc(&os, &os_alloc, &os_offset, "Windows");
if ('\0' != *computer_name)
{
utf8 = zbx_unicode_to_utf8(computer_name);
zbx_snprintf_alloc(&os, &os_alloc, &os_offset, " %s", utf8);
zbx_free(utf8);
}
zbx_snprintf_alloc(&os, &os_alloc, &os_offset, " %d.%d.%d",
vi.dwMajorVersion, vi.dwMinorVersion, vi.dwBuildNumber);
if (VER_PLATFORM_WIN32_NT == vi.dwPlatformId)
{
switch (vi.dwMajorVersion)
{
case 5:
switch (vi.dwMinorVersion)
{
case 0:
get_50_version(&os, &os_alloc, &os_offset, &vi);
break;
case 1:
get_51_version(&os, &os_alloc, &os_offset, &vi);
break;
case 2:
get_52_version(&os, &os_alloc, &os_offset, &vi, &si);
break;
}
break;
case 6:
get_6x_version(&os, &os_alloc, &os_offset, &vi, &si);
break;
}
}
if ('\0' != *vi.szCSDVersion)
{
utf8 = zbx_unicode_to_utf8(vi.szCSDVersion);
zbx_snprintf_alloc(&os, &os_alloc, &os_offset, " %s", utf8);
zbx_free(utf8);
}
get_cpu_type(&os, &os_alloc, &os_offset, &si);
SET_STR_RESULT(result, os);
return SYSINFO_RET_OK;
#else
return EXECUTE_STR(cmd, "uname -a", flags, result);
#endif
}
int SYSTEM_UNAME(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
#if defined(_WINDOWS)
DWORD dwSize = 256;
TCHAR computerName[256], osVersion[256], *cpuType, wide_buffer[MAX_STRING_LEN];
SYSTEM_INFO
sysInfo;
OSVERSIONINFO
versionInfo;
/* Buffer size is chosen large enough to contain any DNS name, not just MAX_COMPUTERNAME_LENGTH + 1 */
/* characters. MAX_COMPUTERNAME_LENGTH is usually less than 32, but it varies among systems, so we */
/* cannot use the constant in a precompiled Windows agent, which is expected to work on any system. */
if (0 == GetComputerName(computerName, &dwSize))
*computerName = '\0';
versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&versionInfo);
switch (versionInfo.dwPlatformId) {
case VER_PLATFORM_WIN32_WINDOWS:
switch (versionInfo.dwMinorVersion) {
case 0:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows 95-%s"), versionInfo.szCSDVersion);
break;
case 10:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows 98-%s"), versionInfo.szCSDVersion);
break;
case 90:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows Me-%s"), versionInfo.szCSDVersion);
break;
default:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows [Unknown Version]"));
}
break;
case VER_PLATFORM_WIN32_NT:
switch (versionInfo.dwMajorVersion) {
case 4:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows NT 4.0 %s"), versionInfo.szCSDVersion);
break;
case 5:
switch (versionInfo.dwMinorVersion) {
case 1:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows XP %s"), versionInfo.szCSDVersion);
break;
case 2:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows Server 2003 %s"),
versionInfo.szCSDVersion);
break;
default:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows [Unknown Version]"));
}
break;
case 6:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows Server 2008 %s"), versionInfo.szCSDVersion);
break;
default:
zbx_wsnprintf(osVersion, sizeof(osVersion)/sizeof(TCHAR), TEXT("Windows [Unknown Version]"));
break;
}
}
GetSystemInfo(&sysInfo);
switch(sysInfo.wProcessorArchitecture)
{
case PROCESSOR_ARCHITECTURE_INTEL:
cpuType=TEXT("Intel IA-32");
break;
case PROCESSOR_ARCHITECTURE_MIPS:
cpuType=TEXT("MIPS");
break;
case PROCESSOR_ARCHITECTURE_ALPHA:
cpuType=TEXT("Alpha");
break;
case PROCESSOR_ARCHITECTURE_PPC:
cpuType=TEXT("PowerPC");
break;
case PROCESSOR_ARCHITECTURE_IA64:
cpuType=TEXT("Intel IA-64");
break;
case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
cpuType=TEXT("IA-32 on IA-64");
break;
case PROCESSOR_ARCHITECTURE_AMD64:
cpuType=TEXT("AMD-64");
break;
default:
cpuType=TEXT("unknown");
break;
}
zbx_wsnprintf(wide_buffer, MAX_STRING_LEN,
TEXT("Windows %s %d.%d.%d %s %s"),
computerName,
versionInfo.dwMajorVersion,
versionInfo.dwMinorVersion,
versionInfo.dwBuildNumber,
osVersion,
cpuType);
SET_STR_RESULT(result, zbx_unicode_to_utf8(wide_buffer));
return SYSINFO_RET_OK;
#else
return EXECUTE_STR(cmd, "uname -a", flags, result);
#endif /* _WINDOWS */
}
