/******************************************************************************
* *
* Function: parse_rtc_options *
* *
* Purpose: parse runtime control options and create a runtime control *
* message *
* *
* Parameters: opt - [IN] the command line argument *
* daemon_type - [IN] the daemon type *
* message - [OUT] the message containing options for log *
* level change or cache reload *
* *
* Return value: SUCCEED - the message was created successfully *
* FAIL - an error occurred *
* *
******************************************************************************/
int parse_rtc_options(const char *opt, unsigned char daemon_type, int *message)
{
int scope, data, command;
if (0 == strncmp(opt, ZBX_LOG_LEVEL_INCREASE, ZBX_CONST_STRLEN(ZBX_LOG_LEVEL_INCREASE)))
{
command = ZBX_RTC_LOG_LEVEL_INCREASE;
if (SUCCEED != parse_log_level_options(opt, ZBX_CONST_STRLEN(ZBX_LOG_LEVEL_INCREASE), &scope, &data))
return FAIL;
}
else if (0 == strncmp(opt, ZBX_LOG_LEVEL_DECREASE, ZBX_CONST_STRLEN(ZBX_LOG_LEVEL_DECREASE)))
{
command = ZBX_RTC_LOG_LEVEL_DECREASE;
if (SUCCEED != parse_log_level_options(opt, ZBX_CONST_STRLEN(ZBX_LOG_LEVEL_DECREASE), &scope, &data))
return FAIL;
}
else if (ZBX_DAEMON_TYPE_AGENT != daemon_type && 0 == strcmp(opt, ZBX_CONFIG_CACHE_RELOAD))
{
command = ZBX_RTC_CONFIG_CACHE_RELOAD;
scope = 0;
data = 0;
}
else
{
zbx_error("invalid runtime control option: %s", opt);
return FAIL;
}
*message = ZBX_RTC_MAKE_MESSAGE(command, scope, data);
return SUCCEED;
}
/******************************************************************************
* *
* Comments: Translate device name to the one used internally by kernel. The *
* translation is done based on minor and major device numbers *
* listed in INFO_FILE_NAME . If the names differ it is usually an *
* LVM device which is listed in kernel device mapper. *
* *
******************************************************************************/
static int get_kernel_devname(const char *devname, char *kernel_devname, size_t max_kernel_devname_len)
{
FILE *f;
char tmp[MAX_STRING_LEN], name[MAX_STRING_LEN], dev_path[MAX_STRING_LEN];
int ret = FAIL;
zbx_uint64_t ds[ZBX_DSTAT_MAX], rdev_major, rdev_minor;
zbx_stat_t dev_st;
if ('\0' == *devname)
return ret;
*dev_path = '\0';
if (0 != strncmp(devname, ZBX_DEV_PFX, ZBX_CONST_STRLEN(ZBX_DEV_PFX)))
strscpy(dev_path, ZBX_DEV_PFX);
strscat(dev_path, devname);
if (zbx_stat(dev_path, &dev_st) < 0 || NULL == (f = fopen(INFO_FILE_NAME, "r")))
return ret;
while (NULL != fgets(tmp, sizeof(tmp), f))
{
PARSE(tmp);
if (major(dev_st.st_rdev) != rdev_major || minor(dev_st.st_rdev) != rdev_minor)
continue;
zbx_strlcpy(kernel_devname, name, max_kernel_devname_len);
ret = SUCCEED;
break;
}
zbx_fclose(f);
return ret;
}
static void process_listener(zbx_socket_t *s)
{
AGENT_RESULT result;
char **value = NULL;
int ret;
if (SUCCEED == (ret = zbx_tcp_recv_to(s, CONFIG_TIMEOUT)))
{
zbx_rtrim(s->buffer, "\r\n");
zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", s->buffer);
init_result(&result);
if (SUCCEED == process(s->buffer, PROCESS_WITH_ALIAS, &result))
{
if (NULL != (value = GET_TEXT_RESULT(&result)))
{
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value);
ret = zbx_tcp_send_to(s, *value, CONFIG_TIMEOUT);
}
}
else
{
value = GET_MSG_RESULT(&result);
if (NULL != value)
{
static char *buffer = NULL;
static size_t buffer_alloc = 256;
size_t buffer_offset = 0;
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [" ZBX_NOTSUPPORTED ": %s]", *value);
if (NULL == buffer)
buffer = (char *)zbx_malloc(buffer, buffer_alloc);
zbx_strncpy_alloc(&buffer, &buffer_alloc, &buffer_offset,
ZBX_NOTSUPPORTED, ZBX_CONST_STRLEN(ZBX_NOTSUPPORTED));
buffer_offset++;
zbx_strcpy_alloc(&buffer, &buffer_alloc, &buffer_offset, *value);
ret = zbx_tcp_send_bytes_to(s, buffer, buffer_offset, CONFIG_TIMEOUT);
}
else
{
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [" ZBX_NOTSUPPORTED "]");
ret = zbx_tcp_send_to(s, ZBX_NOTSUPPORTED, CONFIG_TIMEOUT);
}
}
free_result(&result);
}
if (FAIL == ret)
zabbix_log(LOG_LEVEL_DEBUG, "Process listener error: %s", zbx_socket_strerror());
}
/******************************************************************************
* *
* Function: get_vmware_function *
* *
* Purpose: Retrieves a handler of the item key *
* *
* Parameters: key - [IN] an item key (without parameters) *
* vmfunc - [OUT] a handler of the item key; can be NULL if *
* libxml2 or libcurl is not compiled in *
* *
* Return value: SUCCEED if key is a valid VMware key, FAIL - otherwise *
* *
******************************************************************************/
static int get_vmware_function(const char *key, vmfunc_t *vmfunc)
{
zbx_vmcheck_t *check;
if (0 != strncmp(key, ZBX_VMWARE_PREFIX, ZBX_CONST_STRLEN(ZBX_VMWARE_PREFIX)))
return FAIL;
for (check = vmchecks; NULL != check->key; check++)
{
if (0 == strcmp(key + ZBX_CONST_STRLEN(ZBX_VMWARE_PREFIX), check->key))
{
*vmfunc = check->func;
return SUCCEED;
}
}
return FAIL;
}
int get_diskstat(const char *devname, zbx_uint64_t *dstat)
{
FILE *f;
char tmp[MAX_STRING_LEN], name[MAX_STRING_LEN], dev_path[MAX_STRING_LEN];
int i, ret = FAIL, dev_exists = FAIL;
zbx_uint64_t ds[ZBX_DSTAT_MAX], rdev_major, rdev_minor;
zbx_stat_t dev_st;
int found = 0;
for (i = 0; i < ZBX_DSTAT_MAX; i++)
dstat[i] = (zbx_uint64_t)__UINT64_C(0);
if (NULL != devname && '\0' != *devname && 0 != strcmp(devname, "all"))
{
*dev_path = '\0';
if (0 != strncmp(devname, ZBX_DEV_PFX, ZBX_CONST_STRLEN(ZBX_DEV_PFX)))
strscpy(dev_path, ZBX_DEV_PFX);
strscat(dev_path, devname);
if (zbx_stat(dev_path, &dev_st) == 0)
dev_exists = SUCCEED;
}
if (NULL == (f = fopen(INFO_FILE_NAME, "r")))
return FAIL;
while (NULL != fgets(tmp, sizeof(tmp), f))
{
PARSE(tmp);
if (NULL != devname && '\0' != *devname && 0 != strcmp(devname, "all"))
{
if (0 != strcmp(name, devname))
{
if (SUCCEED != dev_exists
|| major(dev_st.st_rdev) != rdev_major
|| minor(dev_st.st_rdev) != rdev_minor)
continue;
}
else
found = 1;
}
dstat[ZBX_DSTAT_R_OPER] += ds[ZBX_DSTAT_R_OPER];
dstat[ZBX_DSTAT_R_SECT] += ds[ZBX_DSTAT_R_SECT];
dstat[ZBX_DSTAT_W_OPER] += ds[ZBX_DSTAT_W_OPER];
dstat[ZBX_DSTAT_W_SECT] += ds[ZBX_DSTAT_W_SECT];
ret = SUCCEED;
if (1 == found)
break;
}
zbx_fclose(f);
return ret;
}
