int comms_parse_response(char *xml, char *host, size_t host_len, char *key, size_t key_len,
char *data, size_t data_len, char *lastlogsize, size_t lastlogsize_len,
char *timestamp, size_t timestamp_len, char *source, size_t source_len,
char *severity, size_t severity_len)
{
int i, ret = SUCCEED;
char *data_b64 = NULL;
assert(NULL != host && 0 != host_len);
assert(NULL != key && 0 != key_len);
assert(NULL != data && 0 != data_len);
assert(NULL != lastlogsize && 0 != lastlogsize_len);
assert(NULL != timestamp && 0 != timestamp_len);
assert(NULL != source && 0 != source_len);
assert(NULL != severity && 0 != severity_len);
if (SUCCEED == xml_get_data_dyn(xml, "host", &data_b64))
{
str_base64_decode(data_b64, host, host_len - 1, &i);
host[i] = '\0';
xml_free_data_dyn(&data_b64);
}
else
{
*host = '\0';
ret = FAIL;
}
if (SUCCEED == xml_get_data_dyn(xml, "key", &data_b64))
{
str_base64_decode(data_b64, key, key_len - 1, &i);
key[i] = '\0';
xml_free_data_dyn(&data_b64);
}
else
{
*key = '\0';
ret = FAIL;
}
if (SUCCEED == xml_get_data_dyn(xml, "data", &data_b64))
{
str_base64_decode(data_b64, data, data_len - 1, &i);
data[i] = '\0';
xml_free_data_dyn(&data_b64);
}
else
{
*data = '\0';
ret = FAIL;
}
if (SUCCEED == xml_get_data_dyn(xml, "lastlogsize", &data_b64))
{
str_base64_decode(data_b64, lastlogsize, lastlogsize_len - 1, &i);
lastlogsize[i] = '\0';
xml_free_data_dyn(&data_b64);
}
else
*lastlogsize = '\0';
if (SUCCEED == xml_get_data_dyn(xml, "timestamp", &data_b64))
{
str_base64_decode(data_b64, timestamp, timestamp_len - 1, &i);
timestamp[i] = '\0';
xml_free_data_dyn(&data_b64);
}
else
*timestamp = '\0';
if (SUCCEED == xml_get_data_dyn(xml, "source", &data_b64))
{
str_base64_decode(data_b64, source, source_len - 1, &i);
source[i] = '\0';
xml_free_data_dyn(&data_b64);
}
else
*source = '\0';
if (SUCCEED == xml_get_data_dyn(xml, "severity", &data_b64))
{
str_base64_decode(data_b64, severity, severity_len - 1, &i);
severity[i] = '\0';
xml_free_data_dyn(&data_b64);
}
else
*severity = '\0';
return ret;
}
int comms_parse_response(char *xml,char *host,char *key, char *data, char* error, char *lastlogsize, char *timestamp,
char *source, char *severity, int maxlen)
{
int ret = SUCCEED;
int i;
char host_b64[MAX_STRING_LEN];
char key_b64[MAX_STRING_LEN];
char data_b64[MAX_STRING_LEN];
char error_b64[MAX_STRING_LEN];
char lastlogsize_b64[MAX_STRING_LEN];
char timestamp_b64[MAX_STRING_LEN];
char source_b64[ZBX_MAX_B64_LEN];
char severity_b64[MAX_STRING_LEN];
assert(key);
assert(host);
assert(data);
assert(error);
assert(lastlogsize);
assert(timestamp);
assert(source);
assert(severity);
memset(host_b64,0,sizeof(host_b64));
memset(key_b64,0,sizeof(key_b64));
memset(data_b64,0,sizeof(data_b64));
memset(error_b64,0,sizeof(data_b64));
memset(lastlogsize_b64,0,sizeof(lastlogsize_b64));
memset(timestamp_b64,0,sizeof(timestamp_b64));
memset(source_b64,0,sizeof(source_b64));
memset(severity_b64,0,sizeof(severity_b64));
xml_get_data(xml, "host", host_b64, sizeof(host_b64)-1);
xml_get_data(xml, "key", key_b64, sizeof(key_b64)-1);
xml_get_data(xml, "data", data_b64, sizeof(data_b64)-1);
xml_get_data(xml, "error", error_b64, sizeof(error_b64)-1);
xml_get_data(xml, "lastlogsize", lastlogsize_b64, sizeof(lastlogsize_b64)-1);
xml_get_data(xml, "timestamp", timestamp_b64, sizeof(timestamp_b64)-1);
xml_get_data(xml, "source", source_b64, sizeof(source_b64)-1);
xml_get_data(xml, "severity", severity_b64, sizeof(severity_b64)-1);
memset(key,0,maxlen);
memset(host,0,maxlen);
memset(data,0,maxlen);
memset(error,0,maxlen);
memset(lastlogsize,0,maxlen);
memset(timestamp,0,maxlen);
memset(source,0,maxlen);
memset(severity,0,maxlen);
str_base64_decode(host_b64, host, &i);
str_base64_decode(key_b64, key, &i);
str_base64_decode(data_b64, data, &i);
str_base64_decode(error_b64, error, &i);
str_base64_decode(lastlogsize_b64, lastlogsize, &i);
str_base64_decode(timestamp_b64, timestamp, &i);
str_base64_decode(source_b64, source, &i);
str_base64_decode(severity_b64, severity, &i);
return ret;
}
/*
performs iterative parse of multi-response buffer
Sample usage code:
void* token = NULL;
while (comms_parse_response (..., &token) == SUCCEED)
process_data;
*/
int comms_parse_multi_response (char *xml,char *host,char *key, char *data, char *lastlogsize, char *timestamp,
char *source, char *severity, int maxlen, void** token)
{
char* ptr = (char*)*token;
int res = SUCCEED;
int i;
zabbix_log (LOG_LEVEL_DEBUG, "comms_parse_multi_response: started");
/* if token is NULL, skip <reqs> tag and obtain hostname and key value */
if (!ptr)
{
char host_b64[MAX_STRING_LEN];
char key_b64[MAX_STRING_LEN];
if (strncmp (xml, "<reqs>", 6))
return FAIL;
ptr = xml+6;
memset(host_b64, 0, sizeof(host_b64));
memset(key_b64,0,sizeof(key_b64));
xml_get_data(ptr, "host", host_b64, sizeof(host_b64)-1);
xml_get_data(ptr, "key", key_b64, sizeof(key_b64)-1);
memset(host, 0, maxlen);
memset(key,0,maxlen);
str_base64_decode(host_b64, host, &i);
str_base64_decode(key_b64, key, &i);
zabbix_log (LOG_LEVEL_DEBUG, "Host64 = %s, Host=%s", host_b64, host);
zabbix_log (LOG_LEVEL_DEBUG, "Key64 = %s, Key=%s", key_b64, key);
ptr = strstr (ptr, "<values>");
if (ptr)
ptr += 8;
else
return FAIL;
}
if (strncmp (ptr, "<value>", 7) == 0)
{
/* parse one value */
char data_b64[MAX_STRING_LEN];
memset(data_b64,0,sizeof(data_b64));
xml_get_data(ptr, "data", data_b64, sizeof(data_b64)-1);
xml_get_data(ptr, "timestamp", timestamp, maxlen-1);
memset(data,0,maxlen);
str_base64_decode(data_b64, data, &i);
zabbix_log (LOG_LEVEL_DEBUG, "Data64 = %s, Data=%s", data_b64, data);
ptr = strstr (ptr, "</value>");
if (!ptr)
{
zabbix_log (LOG_LEVEL_DEBUG, "Not found </value> tag");
res = FAIL;
}
else
ptr += 8;
}
else
{
zabbix_log (LOG_LEVEL_DEBUG, "Not found <value> tag");
res = FAIL;
}
*token = ptr;
if (res == SUCCEED)
zabbix_log (LOG_LEVEL_DEBUG, "parsed ok. Data: host=%s, key=%s, val=%s, timestamp=%s", host, key, data, timestamp);
else
zabbix_log (LOG_LEVEL_DEBUG, "parse error");
zabbix_log (LOG_LEVEL_DEBUG, "comms_parse_multi_response: started");
return res;
}
int comms_parse_response(char *xml, char *host, int host_len, char *key, int key_len, char *data, int data_len,
char *lastlogsize, int lastlogsize_len, char *timestamp, int timestamp_len,
char *source, int source_len, char *severity, int severity_len)
{
int i, ret = SUCCEED;
char *data_b64 = NULL;
assert(key);
assert(host);
assert(data);
assert(lastlogsize);
assert(timestamp);
assert(source);
assert(severity);
if (SUCCEED == xml_get_data_dyn(xml, "host", &data_b64))
{
str_base64_decode(data_b64, host, host_len - 1, &i);
host[i] = '\0';
xml_free_data_dyn(&data_b64);
}
if (SUCCEED == xml_get_data_dyn(xml, "key", &data_b64))
{
str_base64_decode(data_b64, key, key_len - 1, &i);
key[i] = '\0';
xml_free_data_dyn(&data_b64);
}
if (SUCCEED == xml_get_data_dyn(xml, "data", &data_b64))
{
str_base64_decode(data_b64, data, data_len - 1, &i);
data[i] = '\0';
xml_free_data_dyn(&data_b64);
}
if (SUCCEED == xml_get_data_dyn(xml, "lastlogsize", &data_b64))
{
str_base64_decode(data_b64, lastlogsize, lastlogsize_len - 1, &i);
lastlogsize[i] = '\0';
xml_free_data_dyn(&data_b64);
}
if (SUCCEED == xml_get_data_dyn(xml, "timestamp", &data_b64))
{
str_base64_decode(data_b64, timestamp, timestamp_len - 1, &i);
timestamp[i] = '\0';
xml_free_data_dyn(&data_b64);
}
if (SUCCEED == xml_get_data_dyn(xml, "source", &data_b64))
{
str_base64_decode(data_b64, source, source_len - 1, &i);
source[i] = '\0';
xml_free_data_dyn(&data_b64);
}
if (SUCCEED == xml_get_data_dyn(xml, "severity", &data_b64))
{
str_base64_decode(data_b64, severity, severity_len - 1, &i);
severity[i] = '\0';
xml_free_data_dyn(&data_b64);
}
return ret;
}
