/******************************************************************************
* *
* Function: lld_validate_graph_field *
* *
******************************************************************************/
static void lld_validate_graph_field(zbx_lld_graph_t *graph, char **field, char **field_orig, zbx_uint64_t flag,
size_t field_len, char **error)
{
if (0 == (graph->flags & ZBX_FLAG_LLD_GRAPH_DISCOVERED))
return;
/* only new graphs or graphs with changed data will be validated */
if (0 != graph->graphid && 0 == (graph->flags & flag))
return;
if (SUCCEED != zbx_is_utf8(*field))
{
zbx_replace_invalid_utf8(*field);
*error = zbx_strdcatf(*error, "Cannot %s graph: value \"%s\" has invalid UTF-8 sequence.\n",
(0 != graph->graphid ? "update" : "create"), *field);
}
else if (zbx_strlen_utf8(*field) > field_len)
{
*error = zbx_strdcatf(*error, "Cannot %s graph: value \"%s\" is too long.\n",
(0 != graph->graphid ? "update" : "create"), *field);
}
else
return;
if (0 != graph->graphid)
lld_field_str_rollback(field, field_orig, &graph->flags, flag);
else
graph->flags &= ~ZBX_FLAG_LLD_GRAPH_DISCOVERED;
}
/******************************************************************************
* *
* Function: lld_validate_trigger_field *
* *
******************************************************************************/
static void lld_validate_trigger_field(zbx_lld_trigger_t *trigger, char **field, char **field_orig,
zbx_uint64_t flag, size_t field_len, char **error)
{
if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED))
return;
/* only new triggers or triggers with changed data will be validated */
if (0 != trigger->triggerid && 0 == (trigger->flags & flag))
return;
if (SUCCEED != zbx_is_utf8(*field))
{
zbx_replace_invalid_utf8(*field);
*error = zbx_strdcatf(*error, "Cannot %s trigger: value \"%s\" has invalid UTF-8 sequence.\n",
(0 != trigger->triggerid ? "update" : "create"), *field);
}
else if (zbx_strlen_utf8(*field) > field_len)
{
*error = zbx_strdcatf(*error, "Cannot %s trigger: value \"%s\" is too long.\n",
(0 != trigger->triggerid ? "update" : "create"), *field);
}
else
return;
if (0 != trigger->triggerid)
lld_field_str_rollback(field, field_orig, &trigger->flags, flag);
else
trigger->flags &= ~ZBX_FLAG_LLD_TRIGGER_DISCOVERED;
}
int vmware_get_events(const char *events, zbx_uint64_t lastlogsize, AGENT_RESULT *result)
{
zbx_vector_str_t keys;
zbx_uint64_t key;
char *value, xpath[MAX_STRING_LEN];
int i;
zbx_log_t *log;
struct tm tm;
time_t t;
zbx_vector_str_create(&keys);
if (SUCCEED != zbx_xml_read_values(events, ZBX_XPATH_LN2("Event", "key"), &keys))
{
zbx_vector_str_destroy(&keys);
return SYSINFO_RET_FAIL;
}
for (i = keys.values_num - 1; i >= 0; i--)
{
if (SUCCEED != is_uint64(keys.values[i], &key))
continue;
if (key <= lastlogsize)
continue;
/* value */
zbx_snprintf(xpath, sizeof(xpath), ZBX_XPATH_LN2("Event", "key") "[.='" ZBX_FS_UI64 "']/.."
ZBX_XPATH_LN("fullFormattedMessage"), key);
if (NULL == (value = zbx_xml_read_value(events, xpath)))
continue;
zbx_replace_invalid_utf8(value);
log = add_log_result(result, value);
log->logeventid = key;
log->lastlogsize = key;
zbx_free(value);
/* timestamp */
zbx_snprintf(xpath, sizeof(xpath), ZBX_XPATH_LN2("Event", "key") "[.='" ZBX_FS_UI64 "']/.."
ZBX_XPATH_LN("createdTime"), key);
if (NULL == (value = zbx_xml_read_value(events, xpath)))
continue;
/* 2013-06-04T14:19:23.406298Z */
if (6 == sscanf(value, "%d-%d-%dT%d:%d:%d.%*s", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour,
&tm.tm_min, &tm.tm_sec))
{
int tz_offset;
#if defined(HAVE_TM_TM_GMTOFF)
struct tm *ptm;
time_t now;
now = time(NULL);
ptm = localtime(&now);
tz_offset = ptm->tm_gmtoff;
#else
tz_offset = -timezone;
#endif
tm.tm_year -= 1900;
tm.tm_mon--;
tm.tm_isdst = -1;
if (0 < (t = mktime(&tm)))
log->timestamp = (int)t + tz_offset;
}
zbx_free(value);
}
if (!ISSET_LOG(result))
set_log_result_empty(result);
zbx_vector_str_clean(&keys);
zbx_vector_str_destroy(&keys);
return SYSINFO_RET_OK;
}
int set_result_type(AGENT_RESULT *result, int value_type, int data_type, char *c)
{
int ret = FAIL;
zbx_uint64_t value_uint64;
double value_double;
assert(result);
switch (value_type)
{
case ITEM_VALUE_TYPE_UINT64:
zbx_rtrim(c, " \"");
zbx_ltrim(c, " \"+");
del_zeroes(c);
switch (data_type)
{
case ITEM_DATA_TYPE_BOOLEAN:
if (SUCCEED == is_boolean(c, &value_uint64))
{
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
break;
case ITEM_DATA_TYPE_OCTAL:
if (SUCCEED == is_uoct(c))
{
ZBX_OCT2UINT64(value_uint64, c);
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
break;
case ITEM_DATA_TYPE_DECIMAL:
if (SUCCEED == is_uint64(c, &value_uint64))
{
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
break;
case ITEM_DATA_TYPE_HEXADECIMAL:
if (SUCCEED == is_uhex(c))
{
ZBX_HEX2UINT64(value_uint64, c);
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
else if (SUCCEED == is_hex_string(c))
{
zbx_remove_whitespace(c);
ZBX_HEX2UINT64(value_uint64, c);
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
break;
default:
THIS_SHOULD_NEVER_HAPPEN;
break;
}
break;
case ITEM_VALUE_TYPE_FLOAT:
zbx_rtrim(c, " \"");
zbx_ltrim(c, " \"+");
if (SUCCEED != is_double(c))
break;
value_double = atof(c);
SET_DBL_RESULT(result, value_double);
ret = SUCCEED;
break;
case ITEM_VALUE_TYPE_STR:
zbx_replace_invalid_utf8(c);
SET_STR_RESULT(result, zbx_strdup(NULL, c));
ret = SUCCEED;
break;
case ITEM_VALUE_TYPE_TEXT:
zbx_replace_invalid_utf8(c);
SET_TEXT_RESULT(result, zbx_strdup(NULL, c));
ret = SUCCEED;
break;
case ITEM_VALUE_TYPE_LOG:
zbx_replace_invalid_utf8(c);
add_log_result(result, c);
ret = SUCCEED;
break;
}
if (SUCCEED != ret)
{
char *error = NULL;
zbx_remove_chars(c, "\r\n");
zbx_replace_invalid_utf8(c);
if (ITEM_VALUE_TYPE_UINT64 == value_type)
error = zbx_dsprintf(error,
"Received value [%s] is not suitable for value type [%s] and data type [%s]",
c, zbx_item_value_type_string(value_type),
zbx_item_data_type_string(data_type));
else
error = zbx_dsprintf(error,
"Received value [%s] is not suitable for value type [%s]",
c, zbx_item_value_type_string(value_type));
SET_MSG_RESULT(result, error);
}
return ret;
}