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;
}
/******************************************************************************
* *
* Function: zbx_validate_config *
* *
* Purpose: validate configuration parameters *
* *
* Author: Vladimir Levijev *
* *
******************************************************************************/
static void zbx_validate_config(void)
{
if (NULL == CONFIG_HOSTNAME)
{
zabbix_log(LOG_LEVEL_CRIT, "hostname is not defined");
exit(EXIT_FAILURE);
}
if (NULL != CONFIG_HOST_METADATA && HOST_METADATA_LEN < zbx_strlen_utf8(CONFIG_HOST_METADATA))
{
zabbix_log(LOG_LEVEL_CRIT, "the value of \"HostMetadata\" configuration parameter cannot be longer than"
" %d characters", HOST_METADATA_LEN);
exit(EXIT_FAILURE);
}
if (FAIL == zbx_check_hostname(CONFIG_HOSTNAME))
{
zabbix_log(LOG_LEVEL_CRIT, "invalid host name: [%s]", CONFIG_HOSTNAME);
exit(EXIT_FAILURE);
}
/* make sure active or passive check is enabled */
if (0 == CONFIG_ACTIVE_FORKS && 0 == CONFIG_PASSIVE_FORKS)
{
zabbix_log(LOG_LEVEL_CRIT, "either active or passive checks must be enabled");
exit(EXIT_FAILURE);
}
}
/******************************************************************************
* *
* Function: zbx_validate_config *
* *
* Purpose: validate configuration parameters *
* *
* Author: Alexei Vladishev, Rudolfs Kreicbergs *
* *
******************************************************************************/
static void zbx_validate_config()
{
if ((NULL == CONFIG_JAVA_GATEWAY || '\0' == *CONFIG_JAVA_GATEWAY) && 0 < CONFIG_JAVAPOLLER_FORKS)
{
zabbix_log(LOG_LEVEL_CRIT, "JavaGateway not in config file or empty");
exit(1);
}
if (ZBX_PROXYMODE_ACTIVE == CONFIG_PROXYMODE && NULL == CONFIG_SERVER)
{
zabbix_log(LOG_LEVEL_CRIT, "missing active proxy mandatory parameter [Server] in config file [%s]", CONFIG_FILE);
exit(FAIL);
}
if (NULL == CONFIG_HOSTNAME)
{
zabbix_log(LOG_LEVEL_CRIT, "hostname is not defined");
exit(FAIL);
}
if (FAIL == zbx_check_hostname(CONFIG_HOSTNAME))
{
zabbix_log(LOG_LEVEL_CRIT, "invalid host name: [%s]", CONFIG_HOSTNAME);
exit(FAIL);
}
}
/******************************************************************************
* *
* Function: zbx_validate_config *
* *
* Purpose: validate configuration parameters *
* *
* Author: Alexei Vladishev, Rudolfs Kreicbergs *
* *
******************************************************************************/
static void zbx_validate_config(void)
{
char *ch_error;
if (NULL == CONFIG_HOSTNAME)
{
zabbix_log(LOG_LEVEL_CRIT, "\"Hostname\" configuration parameter is not defined");
exit(EXIT_FAILURE);
}
if (FAIL == zbx_check_hostname(CONFIG_HOSTNAME, &ch_error))
{
zabbix_log(LOG_LEVEL_CRIT, "invalid \"Hostname\" configuration parameter '%s': %s", CONFIG_HOSTNAME,
ch_error);
zbx_free(ch_error);
exit(EXIT_FAILURE);
}
if (0 == CONFIG_UNREACHABLE_POLLER_FORKS && 0 != CONFIG_POLLER_FORKS + CONFIG_IPMIPOLLER_FORKS +
CONFIG_JAVAPOLLER_FORKS)
{
zabbix_log(LOG_LEVEL_CRIT, "\"StartPollersUnreachable\" configuration parameter must not be 0"
" if regular, IPMI or Java pollers are started");
exit(EXIT_FAILURE);
}
if ((NULL == CONFIG_JAVA_GATEWAY || '\0' == *CONFIG_JAVA_GATEWAY) && 0 < CONFIG_JAVAPOLLER_FORKS)
{
zabbix_log(LOG_LEVEL_CRIT, "\"JavaGateway\" configuration parameter is not specified or empty");
exit(EXIT_FAILURE);
}
if (ZBX_PROXYMODE_ACTIVE == CONFIG_PROXYMODE && NULL == CONFIG_SERVER)
{
zabbix_log(LOG_LEVEL_CRIT, "\"Server\" configuration parameter is not defined."
" This parameter is mandatory for active proxies.");
exit(EXIT_FAILURE);
}
if (NULL != CONFIG_SOURCE_IP && ('\0' == *CONFIG_SOURCE_IP || SUCCEED != is_ip(CONFIG_SOURCE_IP)))
{
zabbix_log(LOG_LEVEL_CRIT, "invalid \"SourceIP\" configuration parameter: '%s'", CONFIG_SOURCE_IP);
exit(EXIT_FAILURE);
}
#if !defined(HAVE_LIBXML2) || !defined(HAVE_LIBCURL)
if (0 != CONFIG_VMWARE_FORKS)
{
zabbix_log(LOG_LEVEL_CRIT, "cannot start vmware collector because Zabbix proxy is built without VMware"
" support");
exit(EXIT_FAILURE);
}
#endif
}
static int web_set_ip(AGENT_RESULT *result, struct web *opt, const char *params, int param_id)
{
char ip_tmp[WEB_MAX_DNS_STRLEN] = {0};
/* RFC1035 */
if (get_param(params, param_id, ip_tmp, WEB_MAX_DNS_STRLEN))
goto failed;
zbx_remove_whitespace(ip_tmp);
if (strlen(ip_tmp)) {
if (!is_ip4(ip_tmp)) {
opt->is_ipv6 = (zbx_uint64_t) 0;
opt->ip = zbx_strdup(NULL, ip_tmp);
return SUCCEED;
}
#if defined(HAVE_IPV6)
else if (!is_ip6(ip_tmp)) {
opt->is_ipv6 = (zbx_uint64_t) 1;
opt->ip = zbx_strdup(NULL, ip_tmp);
return SUCCEED;
}
#endif /*HAVE_IPV6*/
else if (!(zbx_check_hostname(ip_tmp))) {
opt->is_ip_hostname = (zbx_uint64_t) 1;
opt->host = zbx_strdup(NULL, ip_tmp);
return SUCCEED;
} else {
goto failed;
}
} else {
if (opt->item->interface.useip) {
opt->ip = zbx_strdup(NULL, opt->item->interface.ip_orig);
return SUCCEED;
} else {
opt->host = zbx_strdup(NULL, opt->item->interface.dns_orig);
return web_resolv_dns(opt, opt->item->interface.dns_orig);
}
}
failed:
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Invalid IP / DNS parameter", NULL));
return FAIL;
}
/******************************************************************************
* *
* Function: zbx_validate_config *
* *
* Purpose: validate configuration parameters *
* *
* Author: Vladimir Levijev *
* *
******************************************************************************/
static void zbx_validate_config()
{
if (NULL == CONFIG_HOSTNAME)
{
zabbix_log(LOG_LEVEL_CRIT, "hostname is not defined");
exit(FAIL);
}
if (FAIL == zbx_check_hostname(CONFIG_HOSTNAME))
{
zabbix_log(LOG_LEVEL_CRIT, "invalid host name: [%s]", CONFIG_HOSTNAME);
exit(FAIL);
}
/* make sure active or passive check is enabled */
if (0 == CONFIG_ACTIVE_FORKS && 0 == CONFIG_PASSIVE_FORKS)
{
zabbix_log(LOG_LEVEL_CRIT, "either active or passive checks must be enabled");
exit(FAIL);
}
}
/******************************************************************************
* *
* Function: get_hostid_by_host *
* *
* Purpose: check for host name and return hostid *
* *
* Parameters: host - [IN] require size 'HOST_HOST_LEN_MAX' *
* *
* Return value: SUCCEED - host is found *
* FAIL - an error occurred or host not found *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int get_hostid_by_host(const char *host, const char *ip, unsigned short port, zbx_uint64_t *hostid, char *error)
{
const char *__function_name = "get_hostid_by_host";
char *host_esc, dns[INTERFACE_DNS_LEN_MAX];
DB_RESULT result;
DB_ROW row;
int res = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() host:'%s'", __function_name, host);
if (FAIL == zbx_check_hostname(host))
{
zbx_snprintf(error, MAX_STRING_LEN, "invalid host name [%s]", host);
goto out;
}
host_esc = DBdyn_escape_string(host);
result = DBselect(
"select hostid,status"
" from hosts"
" where host='%s'"
" and status in (%d,%d)"
" and proxy_hostid is null"
DB_NODE,
host_esc,
HOST_STATUS_MONITORED,
HOST_STATUS_NOT_MONITORED,
DBnode_local("hostid"));
if (NULL != (row = DBfetch(result)))
{
if (HOST_STATUS_MONITORED == atoi(row[1]))
{
ZBX_STR2UINT64(*hostid, row[0]);
res = SUCCEED;
}
else
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not monitored", host);
}
else
{
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not found", host);
/* remove ::ffff: prefix from IPv4-mapped IPv6 addresses */
if (0 == strncmp("::ffff:", ip, 7) && SUCCEED == is_ip4(ip + 7))
ip += 7;
alarm(CONFIG_TIMEOUT);
zbx_gethost_by_ip(ip, dns, sizeof(dns));
alarm(0);
DBbegin();
if (0 != (daemon_type & ZBX_DAEMON_TYPE_SERVER))
{
DBregister_host(0, host, ip, dns, port, (int)time(NULL));
}
else if (0 != (daemon_type & ZBX_DAEMON_TYPE_PROXY))
{
DBproxy_register_host(host, ip, dns, port);
}
DBcommit();
}
DBfree_result(result);
zbx_free(host_esc);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(res));
return res;
}
/******************************************************************************
* *
* Function: get_hostid_by_host *
* *
* Purpose: check for host name and return hostid *
* *
* Parameters: host - [IN] require size 'HOST_HOST_LEN_MAX' *
* *
* Return value: SUCCEED - host is found *
* FAIL - an error occurred or host not found *
* *
* Author: Alexander Vladishev *
* *
* Comments: NB! adds host to the database if it does not exist *
* *
******************************************************************************/
static int get_hostid_by_host(const zbx_socket_t *sock, const char *host, const char *ip, unsigned short port,
const char *host_metadata, zbx_uint64_t *hostid, char *error)
{
const char *__function_name = "get_hostid_by_host";
char *host_esc, dns[INTERFACE_DNS_LEN_MAX], *ch_error;
DB_RESULT result;
DB_ROW row;
int ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() host:'%s'", __function_name, host);
if (FAIL == zbx_check_hostname(host, &ch_error))
{
zbx_snprintf(error, MAX_STRING_LEN, "invalid host name [%s]: %s", host, ch_error);
zbx_free(ch_error);
goto out;
}
host_esc = DBdyn_escape_string(host);
result =
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
DBselect(
"select hostid,status,tls_accept,tls_issuer,tls_subject,tls_psk_identity"
" from hosts"
" where host='%s'"
" and status in (%d,%d)"
" and flags<>%d"
" and proxy_hostid is null",
host_esc, HOST_STATUS_MONITORED, HOST_STATUS_NOT_MONITORED, ZBX_FLAG_DISCOVERY_PROTOTYPE);
#else
DBselect(
"select hostid,status,tls_accept"
" from hosts"
" where host='%s'"
" and status in (%d,%d)"
" and flags<>%d"
" and proxy_hostid is null",
host_esc, HOST_STATUS_MONITORED, HOST_STATUS_NOT_MONITORED, ZBX_FLAG_DISCOVERY_PROTOTYPE);
#endif
if (NULL != (row = DBfetch(result)))
{
if (HOST_STATUS_MONITORED == atoi(row[1]))
{
unsigned int tls_accept;
tls_accept = (unsigned int)atoi(row[2]);
if (0 == (tls_accept & sock->connection_type))
{
zbx_snprintf(error, MAX_STRING_LEN, "connection of type \"%s\" is not allowed for host"
" \"%s\"", zbx_tls_connection_type_name(sock->connection_type), host);
goto done;
}
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
if (ZBX_TCP_SEC_TLS_CERT == sock->connection_type)
{
zbx_tls_conn_attr_t attr;
if (SUCCEED != zbx_tls_get_attr_cert(sock, &attr))
{
THIS_SHOULD_NEVER_HAPPEN;
zbx_snprintf(error, MAX_STRING_LEN, "cannot get connection attributes for host"
" \"%s\"", host);
goto done;
}
/* simplified match, not compliant with RFC 4517, 4518 */
if ('\0' != *row[3] && 0 != strcmp(row[3], attr.issuer))
{
zbx_snprintf(error, MAX_STRING_LEN, "certificate issuer does not match for"
" host \"%s\"", host);
goto done;
}
/* simplified match, not compliant with RFC 4517, 4518 */
if ('\0' != *row[4] && 0 != strcmp(row[4], attr.subject))
{
zbx_snprintf(error, MAX_STRING_LEN, "certificate subject does not match for"
" host \"%s\"", host);
goto done;
}
}
else if (ZBX_TCP_SEC_TLS_PSK == sock->connection_type)
{
zbx_tls_conn_attr_t attr;
if (SUCCEED != zbx_tls_get_attr_psk(sock, &attr))
{
THIS_SHOULD_NEVER_HAPPEN;
zbx_snprintf(error, MAX_STRING_LEN, "cannot get connection attributes for host"
" \"%s\"", host);
goto done;
}
if (strlen(row[5]) != attr.psk_identity_len ||
0 != memcmp(row[5], attr.psk_identity, attr.psk_identity_len))
{
zbx_snprintf(error, MAX_STRING_LEN, "false PSK identity for host \"%s\"", host);
goto done;
}
}
#endif
ZBX_STR2UINT64(*hostid, row[0]);
ret = SUCCEED;
}
else
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not monitored", host);
}
else
{
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not found", host);
/* remove ::ffff: prefix from IPv4-mapped IPv6 addresses */
if (0 == strncmp("::ffff:", ip, 7) && SUCCEED == is_ip4(ip + 7))
ip += 7;
zbx_alarm_on(CONFIG_TIMEOUT);
zbx_gethost_by_ip(ip, dns, sizeof(dns));
zbx_alarm_off();
DBbegin();
if (0 != (program_type & ZBX_PROGRAM_TYPE_SERVER))
DBregister_host(0, host, ip, dns, port, host_metadata, (int)time(NULL));
else if (0 != (program_type & ZBX_PROGRAM_TYPE_PROXY))
DBproxy_register_host(host, ip, dns, port, host_metadata);
DBcommit();
}
done:
DBfree_result(result);
zbx_free(host_esc);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: get_hostid_by_host *
* *
* Purpose: check for host name and return hostid *
* *
* Parameters: host - [IN] require size 'HOST_HOST_LEN_MAX' *
* *
* Return value: SUCCEED - host is found *
* FAIL - an error occurred or host not found *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int get_hostid_by_host(const char *host, zbx_uint64_t *hostid, char *error)
{
char *host_esc;
DB_RESULT result;
DB_ROW row;
int res = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In get_hostid_by_host() host:'%s'", host);
if (FAIL == zbx_check_hostname(host))
{
zbx_snprintf(error, MAX_STRING_LEN, "invalid host name [%s]", host);
return res;
}
host_esc = DBdyn_escape_string(host);
result = DBselect(
"select hostid,status"
" from hosts"
" where host='%s'"
" and status in (%d,%d)"
" and proxy_hostid=0"
DB_NODE,
host_esc,
HOST_STATUS_MONITORED,
HOST_STATUS_NOT_MONITORED,
DBnode_local("hostid"));
if (NULL != (row = DBfetch(result)))
{
if (HOST_STATUS_MONITORED == atoi(row[1]))
{
ZBX_STR2UINT64(*hostid, row[0]);
res = SUCCEED;
}
else
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not monitored", host);
}
else
{
zbx_snprintf(error, MAX_STRING_LEN, "host [%s] not found", host);
DBbegin();
if (0 != (daemon_type & ZBX_DAEMON_TYPE_SERVER))
{
DBregister_host(0, host, (int)time(NULL));
}
else if (0 != (daemon_type & ZBX_DAEMON_TYPE_PROXY))
{
DBproxy_register_host(host);
}
DBcommit();
}
DBfree_result(result);
zbx_free(host_esc);
return res;
}
