static int web_curl_set_url(struct web *opt)
{
const char *__function_name = "web_curl_set_url";
char *url = NULL;
char *curl_err_str = NULL;
int curl_err;
size_t alloc;
size_t offset;
if (opt->is_https)
url = zbx_strdup(url, "https://");
else
url = zbx_strdup(url, "http://");
offset = strlen(url);
alloc = sizeof(char) * offset + 1;
if (opt->is_ip_hostname) {
zbx_strncpy_alloc(&url, &alloc, &offset, opt->host, strlen(opt->host));
} else {
if (opt->is_ipv6) {
zbx_strncpy_alloc(&url, &alloc, &offset, "[", 1);
zbx_strncpy_alloc(&url, &alloc, &offset, opt->ip, strlen(opt->ip));
zbx_strncpy_alloc(&url, &alloc, &offset, "]", 1);
} else {
zbx_strncpy_alloc(&url, &alloc, &offset, opt->ip, strlen(opt->ip));
}
}
zbx_strncpy_alloc(&url, &alloc, &offset, ":", 1);
zbx_strncpy_alloc(&url, &alloc, &offset, opt->port, strlen(opt->port));
if (*opt->uri != '/')
zbx_strncpy_alloc(&url, &alloc, &offset, "/", 1);
zbx_strncpy_alloc(&url, &alloc, &offset, opt->uri, strlen(opt->uri));
if ((curl_err = curl_easy_setopt(opt->curl->handler, CURLOPT_URL, url))) {
curl_err_str = zbx_strdup(curl_err_str, curl_easy_strerror(curl_err));
zabbix_log(LOG_LEVEL_ERR, "%s(): Could not set cURL option [%d]: %s for key %s",
__function_name, CURLOPT_URL, curl_err_str, opt->item->key);
zbx_free(curl_err_str);
zbx_free(url);
return FAIL;
}
zbx_free(url);
return SUCCEED;
}
static int web_curl_set_header(struct web *opt)
{
const char *__function_name = "web_curl_set_header";
char *host = NULL;
char *curl_err_str = NULL;
int curl_err;
int i;
size_t offset;
size_t alloc;
if (opt->host) {
host = zbx_strdup(host, "Host: ");
offset = strlen(host);
alloc = sizeof(char) * offset + 1;
zbx_strncpy_alloc(&host, &alloc, &offset, opt->host, strlen(opt->host));
if (!(opt->curl->header_lst = curl_slist_append(opt->curl->header_lst, host))) {
zabbix_log(LOG_LEVEL_ERR, "%s(): Could not append to curl header list for key %s",
__function_name, opt->item->key);
goto failed;
}
}
for (i = 0; i < opt->header_count; i++) {
if (!(opt->curl->header_lst = curl_slist_append(opt->curl->header_lst, opt->header[i]))) {
zabbix_log(LOG_LEVEL_ERR, "%s(): Could not append to curl header list for key %s",
__function_name, opt->item->key);
goto failed;
}
}
if (opt->curl->header_lst) {
if ((curl_err = curl_easy_setopt(opt->curl->handler, CURLOPT_HTTPHEADER, opt->curl->header_lst))) {
curl_err_str = zbx_strdup(curl_err_str, curl_easy_strerror(curl_err));
zabbix_log(LOG_LEVEL_ERR, "%s(): Could not set cURL option [%d]: %s for key %s",
__function_name, CURLOPT_HTTPHEADER, curl_err_str, opt->item->key);
goto failed;
}
}
zbx_free(host);
return SUCCEED;
failed:
zbx_free(host);
zbx_free(curl_err_str);
return FAIL;
}
int SYSTEM_SWAP_SIZE(AGENT_REQUEST *request, AGENT_RESULT *result)
{
#ifdef HAVE_LIBPERFSTAT
perfstat_memory_total_t mem;
char *swapdev, *mode;
if (2 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
return SYSINFO_RET_FAIL;
}
swapdev = get_rparam(request, 0);
mode = get_rparam(request, 1);
if (NULL != swapdev && '\0' != *swapdev && 0 != strcmp(swapdev, "all"))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter."));
return SYSINFO_RET_FAIL;
}
if (1 != perfstat_memory_total(NULL, &mem, sizeof(perfstat_memory_total_t), 1))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno)));
return SYSINFO_RET_FAIL;
}
if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "free"))
SET_UI64_RESULT(result, mem.pgsp_free << ZBX_PERFSTAT_PAGE_SHIFT);
else if (0 == strcmp(mode, "total"))
SET_UI64_RESULT(result, mem.pgsp_total << ZBX_PERFSTAT_PAGE_SHIFT);
else if (0 == strcmp(mode, "used"))
SET_UI64_RESULT(result, (mem.pgsp_total - mem.pgsp_free) << ZBX_PERFSTAT_PAGE_SHIFT);
else if (0 == strcmp(mode, "pfree"))
SET_DBL_RESULT(result, mem.pgsp_total ? 100.0 * (mem.pgsp_free / (double)mem.pgsp_total) : 0.0);
else if (0 == strcmp(mode, "pused"))
SET_DBL_RESULT(result, mem.pgsp_total ? 100.0 - 100.0 * (mem.pgsp_free / (double)mem.pgsp_total) : 0.0);
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid second parameter."));
return SYSINFO_RET_FAIL;
}
return SYSINFO_RET_OK;
#else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Agent was compiled without support for Perfstat API."));
return SYSINFO_RET_FAIL;
#endif
}
/******************************************************************************
* *
* Function: set_defaults *
* *
* Purpose: set configuration defaults *
* *
* Author: Vladimir Levijev, Rudolfs Kreicbergs *
* *
******************************************************************************/
static void set_defaults(void)
{
AGENT_RESULT result;
char **value = NULL;
if (NULL == CONFIG_HOSTNAME)
{
if (NULL == CONFIG_HOSTNAME_ITEM)
CONFIG_HOSTNAME_ITEM = zbx_strdup(CONFIG_HOSTNAME_ITEM, "system.hostname");
init_result(&result);
if (SUCCEED == process(CONFIG_HOSTNAME_ITEM, PROCESS_LOCAL_COMMAND, &result) &&
NULL != (value = GET_STR_RESULT(&result)))
{
assert(*value);
if (MAX_ZBX_HOSTNAME_LEN < strlen(*value))
{
(*value)[MAX_ZBX_HOSTNAME_LEN] = '\0';
zabbix_log(LOG_LEVEL_WARNING, "hostname truncated to [%s])", *value);
}
CONFIG_HOSTNAME = zbx_strdup(CONFIG_HOSTNAME, *value);
}
else
zabbix_log(LOG_LEVEL_WARNING, "failed to get system hostname from [%s])", CONFIG_HOSTNAME_ITEM);
free_result(&result);
}
else if (NULL != CONFIG_HOSTNAME_ITEM)
zabbix_log(LOG_LEVEL_WARNING, "both Hostname and HostnameItem defined, using [%s]", CONFIG_HOSTNAME);
if (NULL != CONFIG_HOST_METADATA && NULL != CONFIG_HOST_METADATA_ITEM)
{
zabbix_log(LOG_LEVEL_WARNING, "both HostMetadata and HostMetadataItem defined, using [%s]",
CONFIG_HOST_METADATA);
}
#ifndef _WINDOWS
if (NULL == CONFIG_LOAD_MODULE_PATH)
CONFIG_LOAD_MODULE_PATH = zbx_strdup(CONFIG_LOAD_MODULE_PATH, LIBDIR "/modules");
#endif
#ifdef USE_PID_FILE
if (NULL == CONFIG_PID_FILE)
CONFIG_PID_FILE = "/tmp/zabbix_agentd.pid";
#endif
}
static char *zbx_get_snmp_type_error(u_char type)
{
switch (type)
{
case SNMP_NOSUCHOBJECT:
return zbx_strdup(NULL, "No Such Object available on this agent at this OID");
case SNMP_NOSUCHINSTANCE:
return zbx_strdup(NULL, "No Such Instance currently exists at this OID");
case SNMP_ENDOFMIBVIEW:
return zbx_strdup(NULL, "No more variables left in this MIB View"
" (it is past the end of the MIB tree)");
default:
return zbx_dsprintf(NULL, "Value has unknown type 0x%02X", type);
}
}
int VM_MEMORY_SIZE(AGENT_REQUEST *request, AGENT_RESULT *result)
{
char *mode;
int ret = SYSINFO_RET_FAIL;
if (1 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
return SYSINFO_RET_FAIL;
}
if (0 == pagesize)
{
if (KERN_SUCCESS != host_page_size(mach_host_self(), &pagesize))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain host page size."));
return SYSINFO_RET_FAIL;
}
}
mode = get_rparam(request, 0);
if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "total"))
ret = VM_MEMORY_TOTAL(result);
else if (0 == strcmp(mode, "active"))
ret = VM_MEMORY_ACTIVE(result);
else if (0 == strcmp(mode, "inactive"))
ret = VM_MEMORY_INACTIVE(result);
else if (0 == strcmp(mode, "wired"))
ret = VM_MEMORY_WIRED(result);
else if (0 == strcmp(mode, "free"))
ret = VM_MEMORY_FREE(result);
else if (0 == strcmp(mode, "used"))
ret = VM_MEMORY_USED(result);
else if (0 == strcmp(mode, "pused"))
ret = VM_MEMORY_PUSED(result);
else if (0 == strcmp(mode, "available"))
ret = VM_MEMORY_AVAILABLE(result);
else if (0 == strcmp(mode, "pavailable"))
ret = VM_MEMORY_PAVAILABLE(result);
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter."));
return SYSINFO_RET_FAIL;
}
return ret;
}
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;
}
static int web_set_login(AGENT_RESULT *result, struct web *opt, const char *params, int param_id)
{
char login_tmp[MAX_STRING_LEN] = {0};
char *passwd_ptr = NULL;
size_t user_lenght;
if (get_param(params, param_id, login_tmp, MAX_STRING_LEN))
goto failed;
zbx_remove_whitespace(login_tmp);
if (!(passwd_ptr = strchr(login_tmp, ':')))
goto failed;
if (!(user_lenght = strlen(login_tmp) - strlen(passwd_ptr)))
goto failed;
opt->username = strndup(login_tmp, user_lenght);
opt->passwd = zbx_strdup(opt->passwd, ++passwd_ptr);
return SUCCEED;
failed:
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Invalid LOGIN parameter", NULL));
return FAIL;
}
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;
}
int SYSTEM_HW_CHASSIS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
char tmp[8], buf[MAX_STRING_LEN];
int ret = SYSINFO_RET_FAIL;
if (1 < num_param(param))
return ret;
if (0 != get_param(param, 1, tmp, sizeof(tmp)))
*tmp = '\0';
if ('\0' == *tmp || 0 == strcmp(tmp, "full")) /* show full info by default */
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_TYPE | DMI_GET_VENDOR | DMI_GET_MODEL | DMI_GET_SERIAL);
else if (0 == strcmp(tmp, "type"))
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_TYPE);
else if (0 == strcmp(tmp, "vendor"))
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_VENDOR);
else if (0 == strcmp(tmp, "model"))
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_MODEL);
else if (0 == strcmp(tmp, "serial"))
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_SERIAL);
if (SYSINFO_RET_OK == ret)
SET_STR_RESULT(result, zbx_strdup(NULL, buf + 1)); /* buf has a leading space */
return ret;
}
/******************************************************************************
* *
* Function: DCadd_nextcheck *
* *
* Purpose: add item nextcheck to the array *
* *
******************************************************************************/
void DCadd_nextcheck(zbx_uint64_t itemid, const zbx_timespec_t *ts, const char *error_msg)
{
const char *__function_name = "DCadd_nextcheck";
int i;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (NULL == error_msg)
return;
i = get_nearestindex(nextchecks, sizeof(ZBX_DC_NEXTCHECK), nextcheck_num, itemid);
if (i < nextcheck_num && nextchecks[i].itemid == itemid) /* an item found */
return;
if (nextcheck_alloc == nextcheck_num)
{
nextcheck_alloc += 64;
nextchecks = zbx_realloc(nextchecks, sizeof(ZBX_DC_NEXTCHECK) * nextcheck_alloc);
}
/* insert a new item */
memmove(&nextchecks[i + 1], &nextchecks[i], sizeof(ZBX_DC_NEXTCHECK) * (nextcheck_num - i));
nextchecks[i].itemid = itemid;
nextchecks[i].ts = *ts;
nextchecks[i].error_msg = zbx_strdup(NULL, error_msg);
nextcheck_num++;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
int SYSTEM_HW_CHASSIS(AGENT_REQUEST *request, AGENT_RESULT *result)
{
char *mode, buf[MAX_STRING_LEN];
int ret = SYSINFO_RET_FAIL;
if (1 < request->nparam)
return ret;
mode = get_rparam(request, 0);
if (NULL == mode || '\0' == *mode || 0 == strcmp(mode, "full")) /* show full info by default */
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_TYPE | DMI_GET_VENDOR | DMI_GET_MODEL | DMI_GET_SERIAL);
else if (0 == strcmp(mode, "type"))
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_TYPE);
else if (0 == strcmp(mode, "vendor"))
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_VENDOR);
else if (0 == strcmp(mode, "model"))
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_MODEL);
else if (0 == strcmp(mode, "serial"))
ret = get_dmi_info(buf, sizeof(buf), DMI_GET_SERIAL);
if (SYSINFO_RET_OK == ret)
SET_STR_RESULT(result, zbx_strdup(NULL, buf + 1)); /* buf has a leading space */
return ret;
}
static void read_ipmi_control(zbx_ipmi_host_t *h, zbx_ipmi_control_t *c)
{
const char *__function_name = "read_ipmi_control";
int ret;
struct timeval tv;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() control:'%s@[%s]:%d'", __function_name, c->c_name, h->ip, h->port);
if (0 == ipmi_control_is_readable(c->control))
{
h->err = zbx_strdup(h->err, "control is not readable");
h->ret = NOTSUPPORTED;
goto out;
}
h->ret = SUCCEED;
h->done = 0;
if (0 != (ret = ipmi_control_get_val(c->control, got_control_reading, h)))
{
h->err = zbx_dsprintf(h->err, "Cannot read control %s. ipmi_control_get_val() return error: 0x%x",
c->c_name, ret);
h->ret = NOTSUPPORTED;
goto out;
}
tv.tv_sec = 10;
tv.tv_usec = 0;
while (0 == h->done)
os_hnd->perform_one_op(os_hnd, &tv);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(h->ret));
}
/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
static void parse_commandline(int argc, char **argv)
{
char ch;
/* parse the command-line */
CONFIG_FILE = NULL;
while ((char) EOF != (ch = (char) zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) {
switch (ch) {
case 'c':
CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg);
break;
case 'h':
help_jobarg();
exit(FAIL);
break;
case 'V':
version_jobarg();
exit(FAIL);
break;
default:
usage();
exit(FAIL);
break;
}
}
if (NULL == CONFIG_FILE) {
CONFIG_FILE = DEFAULT_CONFIG_FILE;
}
}
int SYSTEM_BOOTTIME(AGENT_REQUEST *request, AGENT_RESULT *result)
{
#ifdef HAVE_FUNCTION_SYSCTL_KERN_BOOTTIME
size_t len;
int mib[2];
struct timeval boottime;
mib[0] = CTL_KERN;
mib[1] = KERN_BOOTTIME;
len = sizeof(struct timeval);
if (-1 == sysctl(mib, 2, &boottime, &len, NULL, 0))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno)));
return SYSINFO_RET_FAIL;
}
SET_UI64_RESULT(result, boottime.tv_sec);
return SYSINFO_RET_OK;
#else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Agent was compiled without support for \"kern.boottime\" system"
" parameter."));
return SYSINFO_RET_FAIL;
#endif
}
static int web_curl_set_common(struct web *opt)
{
const char *__function_name = "web_curl_set_common";
char *curl_err_str = NULL;
int curl_err;
int curl_opt;
if (!(opt->curl->handler = curl_easy_init())) {
zabbix_log(LOG_LEVEL_ERR,"%s(): Could not init cURL for key %s", __function_name, opt->item->key);
goto failed;
}
if ((curl_err = curl_easy_setopt(opt->curl->handler, curl_opt = CURLOPT_COOKIEFILE, "")) ||
(curl_err = curl_easy_setopt(opt->curl->handler, curl_opt = CURLOPT_SSL_VERIFYPEER, 0L)) ||
(curl_err = curl_easy_setopt(opt->curl->handler, curl_opt = CURLOPT_SSL_VERIFYHOST, 0L)) ||
(curl_err = curl_easy_setopt(opt->curl->handler, curl_opt = CURLOPT_USERAGENT,WEB_CURL_USERAGENT)) ||
(curl_err = curl_easy_setopt(opt->curl->handler, curl_opt = CURLOPT_TIMEOUT, (long) opt->timeout))) {
curl_err_str = zbx_strdup(curl_err_str,curl_easy_strerror(curl_err));
zabbix_log(LOG_LEVEL_ERR, "%s(): Could not set cURL option [%d]: %s for key %s",
__function_name, curl_opt, curl_err_str, opt->item->key);
goto failed;
}
return SUCCEED;
failed:
zbx_free(curl_err_str);
return FAIL;
}
void add_regexp_ex(zbx_vector_ptr_t *regexps, const char *name, const char *expression, int expression_type,
char exp_delimiter, int case_sensitive)
{
zbx_expression_t *regexp;
regexp = zbx_malloc(NULL, sizeof(zbx_expression_t));
regexp->name = zbx_strdup(NULL, name);
regexp->expression = zbx_strdup(NULL, expression);
regexp->expression_type = expression_type;
regexp->exp_delimiter = exp_delimiter;
regexp->case_sensitive = case_sensitive;
zbx_vector_ptr_append(regexps, regexp);
}
int KERNEL_MAXPROC(AGENT_REQUEST *request, AGENT_RESULT *result)
{
#ifdef HAVE_FUNCTION_SYSCTL_KERN_MAXPROC
int mib[2];
size_t len;
int maxproc;
mib[0] = CTL_KERN;
mib[1] = KERN_MAXPROC;
len = sizeof(maxproc);
if (0 != sysctl(mib, 2, &maxproc, &len, NULL, 0))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno)));
return SYSINFO_RET_FAIL;
}
SET_UI64_RESULT(result, maxproc);
return SYSINFO_RET_OK;
#else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Agent was compiled without support for \"kern.maxproc\" system"
" parameter."));
#endif
}
/******************************************************************************
* *
* Function: proc_get_process_name *
* *
* Purpose: returns process name *
* *
* Parameters: pid - [IN] the process identifier *
* procname - [OUT] the process name *
* *
* Return value: SUCCEED *
* FAIL *
* *
* Comments: The process name is allocated by this function and must be freed *
* by the caller. *
* *
******************************************************************************/
static int proc_get_process_name(pid_t pid, char **procname)
{
int n, fd;
char tmp[MAX_STRING_LEN], *pend, *pstart;
zbx_snprintf(tmp, sizeof(tmp), "/proc/%d/stat", (int)pid);
if (-1 == (fd = open(tmp, O_RDONLY)))
return FAIL;
n = read(fd, tmp, sizeof(tmp));
close(fd);
if (-1 == n)
return FAIL;
for (pend = tmp + n - 1; ')' != *pend && pend > tmp; pend--)
;
*pend = '\0';
if (NULL == (pstart = strchr(tmp, '(')))
return FAIL;
*procname = zbx_strdup(NULL, pstart + 1);
return SUCCEED;
}
/******************************************************************************
* *
* Function: replace_key_param *
* *
* Comments: auxiliary function for DBpatch_2010195() *
* *
******************************************************************************/
static char *replace_key_param(const char *data, int key_type, int level, int num, int quoted, void *cb_data)
{
char *param, *new_param;
if (1 != level || 4 != num) /* the fourth parameter on first level should be updated */
return NULL;
param = zbx_strdup(NULL, data);
unquote_key_param(param);
if ('\0' == *param)
{
zbx_free(param);
return NULL;
}
new_param = zbx_dsprintf(NULL, "^%s$", param);
zbx_free(param);
quote_key_param(&new_param, quoted);
return new_param;
}
static int VM_MEMORY_CACHED(AGENT_RESULT *result)
{
FILE *f;
zbx_uint64_t value;
int res;
if (NULL == (f = fopen("/proc/meminfo", "r")))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot open /proc/meminfo: %s", zbx_strerror(errno)));
return SYSINFO_RET_FAIL;
}
if (FAIL == (res = byte_value_from_proc_file(f, "Cached:", NULL, &value)))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain the value of Cached from /proc/meminfo."));
goto close;
}
if (NOTSUPPORTED == res)
value = 0;
close:
zbx_fclose(f);
SET_UI64_RESULT(result, value);
return SYSINFO_RET_OK;
}
static int web_set_host(AGENT_RESULT *result, struct web *opt, const char *params, int param_id)
{
char host_tmp[WEB_MAX_DNS_STRLEN] = {0};
if (get_param(params, param_id, host_tmp, WEB_MAX_DNS_STRLEN))
goto failed;
zbx_remove_whitespace(host_tmp);
if (strlen(host_tmp)) {
if (!strncmp(host_tmp, "none", strlen(host_tmp))) {
if (opt->host)
zbx_free(opt->host);
} else {
/* RFC2616 14.23 non compliant. We dont accept port number in Host field */
if (zbx_check_hostname(host_tmp))
goto failed;
/* if hostname is previously set in IP / DNS then replace it with user param */
if (opt->host)
zbx_free(opt->host);
opt->host = zbx_strdup(NULL, host_tmp);
}
}
return SUCCEED;
failed:
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Invalid HOST parameter", NULL));
return FAIL;
}
static int DBget_script_by_scriptid(zbx_uint64_t scriptid, zbx_script_t *script, zbx_uint64_t *groupid)
{
const char *__function_name = "DBget_script_by_scriptid";
DB_RESULT result;
DB_ROW row;
int ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
result = DBselect(
"select type,execute_on,command,groupid"
" from scripts"
" where scriptid=" ZBX_FS_UI64,
scriptid);
if (NULL != (row = DBfetch(result)))
{
script->type = (unsigned char)atoi(row[0]);
script->execute_on = (unsigned char)atoi(row[1]);
script->command = zbx_strdup(script->command, row[2]);
ZBX_DBROW2UINT64(*groupid, row[3]);
ret = SUCCEED;
}
DBfree_result(result);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
int SYSTEM_UPTIME(AGENT_REQUEST *request, AGENT_RESULT *result)
{
#ifdef HAVE_FUNCTION_SYSCTL_KERN_BOOTTIME
int mib[2], now;
size_t len;
struct timeval uptime;
mib[0] = CTL_KERN;
mib[1] = KERN_BOOTTIME;
len = sizeof(struct timeval);
if (0 != sysctl(mib, 2, &uptime, &len, NULL, 0))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s", zbx_strerror(errno)));
return SYSINFO_RET_FAIL;
}
now = time(NULL);
SET_UI64_RESULT(result, now - uptime.tv_sec);
return SYSINFO_RET_OK;
#else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Agent was compiled without support for uptime information."));
return SYSINFO_RET_FAIL;
#endif
}
/* callback function invoked from OpenIPMI */
static void got_control_setting(ipmi_control_t *control, int err, void *cb_data)
{
const char *__function_name = "got_control_setting";
zbx_ipmi_host_t *h = cb_data;
zbx_ipmi_control_t *c;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (0 != err)
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() fail: %s", __function_name, zbx_strerror(err));
h->err = zbx_dsprintf(h->err, "error 0x%x while set control", err);
h->ret = NETWORK_ERROR;
h->done = 1;
return;
}
c = get_ipmi_control(h, control);
if (NULL == c)
{
THIS_SHOULD_NEVER_HAPPEN;
h->err = zbx_strdup(h->err, "fatal error");
h->ret = NOTSUPPORTED;
h->done = 1;
return;
}
zabbix_log(LOG_LEVEL_DEBUG, "set value completed for control %s@[%s]:%d", c->c_name, h->ip, h->port);
h->done = 1;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(h->ret));
}
int SYSTEM_SW_OS(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
char type[8], line[MAX_STRING_LEN];
int ret = SYSINFO_RET_FAIL;
FILE *f = NULL;
if (1 < num_param(param))
return ret;
if (0 != get_param(param, 1, type, sizeof(type)))
*type = '\0';
if ('\0' == *type || 0 == strcmp(type, "full"))
f = fopen(SW_OS_FULL, "r");
else if (0 == strcmp(type, "short"))
f = fopen(SW_OS_SHORT, "r");
else if (0 == strcmp(type, "name"))
f = fopen(SW_OS_NAME, "r");
if (NULL == f)
return ret;
if (NULL != fgets(line, sizeof(line), f))
{
ret = SYSINFO_RET_OK;
zbx_rtrim(line, ZBX_WHITESPACE);
SET_STR_RESULT(result, zbx_strdup(NULL, line));
}
zbx_fclose(f);
return ret;
}
int SYSTEM_CPU_INTR(AGENT_REQUEST *request, AGENT_RESULT *result)
{
int ret = SYSINFO_RET_FAIL;
char line[MAX_STRING_LEN];
zbx_uint64_t value = 0;
FILE *f;
if (NULL == (f = fopen("/proc/stat", "r")))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot open /proc/stat: %s", zbx_strerror(errno)));
return SYSINFO_RET_FAIL;
}
while (NULL != fgets(line, sizeof(line), f))
{
if (0 != strncmp(line, "intr", 4))
continue;
if (1 != sscanf(line, "%*s " ZBX_FS_UI64, &value))
continue;
SET_UI64_RESULT(result, value);
ret = SYSINFO_RET_OK;
break;
}
zbx_fclose(f);
if (SYSINFO_RET_FAIL == ret)
SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot find a line with \"intr\" in /proc/stat."));
return ret;
}
/******************************************************************************
* *
* Function: parse_item_key *
* *
* Purpose: parse item command (key) and fill AGENT_REQUEST structure *
* *
* Parameters: itemkey - complete item key *
* *
* Return value: request - structure filled with data from item key *
* *
******************************************************************************/
int parse_item_key(const char *itemkey, AGENT_REQUEST *request)
{
int i, ret = FAIL;
char *key = NULL, *params = NULL;
switch (parse_command_dyn(itemkey, &key, ¶ms))
{
case ZBX_COMMAND_WITH_PARAMS:
if (0 == (request->nparam = num_param(params)))
goto out; /* key is badly formatted */
request->params = zbx_malloc(request->params, request->nparam * sizeof(char *));
for (i = 0; i < request->nparam; i++)
request->params[i] = get_param_dyn(params, i + 1);
break;
case ZBX_COMMAND_ERROR:
goto out; /* key is badly formatted */
}
request->key = zbx_strdup(NULL, key);
ret = SUCCEED;
out:
zbx_free(params);
zbx_free(key);
return ret;
}
static int get_result_columns(ZBX_ODBC_DBH *dbh, char **buffer)
{
int ret = SUCCEED, i, j;
char str[MAX_STRING_LEN];
SQLRETURN rc;
SQLSMALLINT len;
for (i = 0; i < dbh->col_num; i++)
{
rc = SQLColAttribute(dbh->hstmt, i + 1, SQL_DESC_LABEL, str, sizeof(str), &len, NULL);
if (SQL_SUCCESS != rc || sizeof(str) <= len || '\0' == *str)
{
for (j = 0; j < i; j++)
zbx_free(buffer[j]);
ret = FAIL;
break;
}
buffer[i] = zbx_strdup(NULL, str);
}
return ret;
}
static int web_key_check_img(struct web *opt)
{
const char *__function_name = "web_key_check_img";
char *content_type = NULL;
char *curl_err_str = NULL;
int curl_err;
if (opt->required_response == WEB_CHECK_IMG_DEF_RESP) {
if ((curl_err = curl_easy_getinfo(opt->curl->handler, CURLINFO_CONTENT_TYPE, &content_type))) {
curl_err_str = zbx_strdup(curl_err_str, curl_easy_strerror(curl_err));
zabbix_log(LOG_LEVEL_ERR, "%s(): Error during curl_easy_getinfo: %s for key %s",
__function_name, curl_err_str, opt->item->key);
opt->result = (zbx_uint64_t) WEB_ERR_CURL;
goto failed;
}
if (!zbx_strcasestr(content_type, WEB_CHECK_IMG_MATCH_CTYPE)) {
zabbix_log(LOG_LEVEL_WARNING, "%s(): Required content type %s not found for key %s",
__function_name, WEB_CHECK_IMG_MATCH_CTYPE, opt->item->key);
opt->result = (zbx_uint64_t) WEB_ERR_CONTENT_TYPE;
goto failed;
}
}
return SUCCEED;
failed:
zbx_free(curl_err_str);
return FAIL;
}
