← Back to branch summary

~kampka/ubuntu/quantal/zabbix/upstart-support

« back to all changes in this revision

Viewing changes to src/libs/zbxcommon/comms.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Ablassmeier
  • Date: 2009-06-28 19:11:29 UTC
  • mfrom: (19.1.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090628191129-5esmmf2h3tbff1fv
http://bugs.debian.org/528426
http://bugs.debian.org/534096
http://bugs.debian.org/520197
http://bugs.debian.org/527559
http://bugs.debian.org/527600
http://bugs.debian.org/528571
http://bugs.debian.org/529157
http://bugs.debian.org/529502
http://bugs.debian.org/532344
* New upstream release
* Merge upstream config file to template (Closes: #528426)
* Move logrotate from Depends to Suggests (Closes: #534096)
* Server should not crash anymore if postgresql transaction fails
  (Closes: #520197)
* Update fr.po (Closes: #527559)
* Update es.po (Closes: #527600)
* Update sv.po (Closes: #528571)
* Update it.po (Closes: #529157)
* Update cs.po (Closes: #529502)
* Update de.po (Closes: #532344)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libs/zbxcommon/comms.c
26
26
char ZABBIX_EVENT_SOURCE[64] = {APPLICATION_NAME};
27
27
#endif /* _WINDOWS */
28
28
 
29
 
/******************************************************************************
30
 
 *                                                                            *
31
 
 * Function: comms_create_request                                             *
32
 
 *                                                                            *
33
 
 * Purpose: dinamical xml request generation                                  *
34
 
 *                                                                            *
35
 
 * Return value: XML request                                                  *
36
 
 *                                                                            *
37
 
 * Author: Eugene Grigorjev                                                   *
38
 
 *                                                                            *
39
 
 * Comments:  required free allocated string with function 'zbx_free'         *
40
 
 *                                                                            *
41
 
 ******************************************************************************/
42
 
char*   comms_create_request(
43
 
        const char              *host,
44
 
        const char              *key,
45
 
        const char              *data,
46
 
        long                    *lastlogsize,
47
 
        unsigned long   *timestamp,
48
 
        const char              *source,
49
 
        unsigned short  *severity
50
 
        )
51
 
{
52
 
#define ADD_XML_DATA(tag_name, var) \
53
 
        data_b64[0] = '\0'; \
54
 
        str_base64_encode(var, data_b64, (int)strlen(var)); \
55
 
        request = zbx_strdcatf(request, "<" tag_name ">%s</" tag_name ">",      data_b64)
56
 
 
57
 
        char data_b64[ZBX_MAX_B64_LEN];
58
 
        char *tmp_str = NULL;
59
 
        char *request = NULL;
60
 
        
61
 
        assert(host);
62
 
        assert(key);
63
 
        assert(data);
64
 
 
65
 
        /* zabbix_log(LOG_LEVEL_DEBUG, "comms_create_request host [%s] key [%s] data [%s]",host,key,data); */
66
 
 
67
 
        memset(data_b64,0,sizeof(data_b64));
68
 
 
69
 
        request = zbx_dsprintf(NULL,"%s", "<req>");
70
 
        
71
 
        ADD_XML_DATA("host",    host);
72
 
        ADD_XML_DATA("key",             key);
73
 
        ADD_XML_DATA("data",    data);
74
 
 
75
 
        if(lastlogsize)
76
 
        {
77
 
                tmp_str = zbx_dsprintf(NULL, "%li", *lastlogsize);
78
 
                ADD_XML_DATA("lastlogsize",     tmp_str);
79
 
                zbx_free(tmp_str);
80
 
        }
81
 
 
82
 
        if(timestamp)
83
 
        {
84
 
                assert(source);
85
 
                assert(severity);
86
 
                
87
 
                tmp_str = zbx_dsprintf(NULL, "%lu", *timestamp);
88
 
                ADD_XML_DATA("timestamp",       tmp_str);
89
 
                zbx_free(tmp_str);
90
 
 
91
 
                ADD_XML_DATA("source",          source);
92
 
 
93
 
                tmp_str = zbx_dsprintf(NULL, "%u", *severity);
94
 
                ADD_XML_DATA("severity",        tmp_str);
95
 
                zbx_free(tmp_str);
96
 
        }
97
 
 
98
 
        return zbx_strdcat(request, "</req>");
99
 
}
100
 
 
101
 
int     comms_parse_response(char *xml,char *host,char *key, char *data, char *lastlogsize, char *timestamp,
102
 
               char *source, char *severity, int maxlen)
103
 
{
104
 
        int ret = SUCCEED;
105
 
        int i;
106
 
 
107
 
        char host_b64[MAX_STRING_LEN];
108
 
        char key_b64[MAX_STRING_LEN];
109
 
        char data_b64[MAX_STRING_LEN];
110
 
        char lastlogsize_b64[MAX_STRING_LEN];
111
 
        char timestamp_b64[MAX_STRING_LEN];
112
 
        char source_b64[ZBX_MAX_B64_LEN];
113
 
        char severity_b64[MAX_STRING_LEN];
 
29
int     comms_parse_response(char *xml, char *host, int host_len, char *key, int key_len, char *data, int data_len,
 
30
                char *lastlogsize, int lastlogsize_len, char *timestamp, int timestamp_len,
 
31
                char *source, int source_len, char *severity, int severity_len)
 
32
{
 
33
        int     i, ret = SUCCEED;
 
34
        char    *data_b64 = NULL;
114
35
 
115
36
        assert(key);
116
37
        assert(host);
120
41
        assert(source);
121
42
        assert(severity);
122
43
 
123
 
        memset(host_b64,0,sizeof(host_b64));
124
 
        memset(key_b64,0,sizeof(key_b64));
125
 
        memset(data_b64,0,sizeof(data_b64));
126
 
        memset(lastlogsize_b64,0,sizeof(lastlogsize_b64));
127
 
        memset(timestamp_b64,0,sizeof(timestamp_b64));
128
 
        memset(source_b64,0,sizeof(source_b64));
129
 
        memset(severity_b64,0,sizeof(severity_b64));
130
 
 
131
 
        xml_get_data(xml, "host", host_b64, sizeof(host_b64)-1);
132
 
        xml_get_data(xml, "key", key_b64, sizeof(key_b64)-1);
133
 
        xml_get_data(xml, "data", data_b64, sizeof(data_b64)-1);
134
 
        xml_get_data(xml, "lastlogsize", lastlogsize_b64, sizeof(lastlogsize_b64)-1);
135
 
        xml_get_data(xml, "timestamp", timestamp_b64, sizeof(timestamp_b64)-1);
136
 
        xml_get_data(xml, "source", source_b64, sizeof(source_b64)-1);
137
 
        xml_get_data(xml, "severity", severity_b64, sizeof(severity_b64)-1);
138
 
 
139
 
        memset(key,0,maxlen);
140
 
        memset(host,0,maxlen);
141
 
        memset(data,0,maxlen);
142
 
        memset(lastlogsize,0,maxlen);
143
 
        memset(timestamp,0,maxlen);
144
 
        memset(source,0,maxlen);
145
 
        memset(severity,0,maxlen);
146
 
 
147
 
        str_base64_decode(host_b64, host, &i);
148
 
        str_base64_decode(key_b64, key, &i);
149
 
        str_base64_decode(data_b64, data, &i);
150
 
        str_base64_decode(lastlogsize_b64, lastlogsize, &i);
151
 
        str_base64_decode(timestamp_b64, timestamp, &i);
152
 
        str_base64_decode(source_b64, source, &i);
153
 
        str_base64_decode(severity_b64, severity, &i);
 
44
        if (SUCCEED == xml_get_data_dyn(xml, "host", &data_b64))
 
45
        {
 
46
                str_base64_decode(data_b64, host, host_len - 1, &i);
 
47
                host[i] = '\0';
 
48
                xml_free_data_dyn(&data_b64);
 
49
        }
 
50
 
 
51
        if (SUCCEED == xml_get_data_dyn(xml, "key", &data_b64))
 
52
        {
 
53
                str_base64_decode(data_b64, key, key_len - 1, &i);
 
54
                key[i] = '\0';
 
55
                xml_free_data_dyn(&data_b64);
 
56
        }
 
57
 
 
58
        if (SUCCEED == xml_get_data_dyn(xml, "data", &data_b64))
 
59
        {
 
60
                str_base64_decode(data_b64, data, data_len - 1, &i);
 
61
                data[i] = '\0';
 
62
                xml_free_data_dyn(&data_b64);
 
63
        }
 
64
 
 
65
        if (SUCCEED == xml_get_data_dyn(xml, "lastlogsize", &data_b64))
 
66
        {
 
67
                str_base64_decode(data_b64, lastlogsize, lastlogsize_len - 1, &i);
 
68
                lastlogsize[i] = '\0';
 
69
                xml_free_data_dyn(&data_b64);
 
70
        }
 
71
 
 
72
        if (SUCCEED == xml_get_data_dyn(xml, "timestamp", &data_b64))
 
73
        {
 
74
                str_base64_decode(data_b64, timestamp, timestamp_len - 1, &i);
 
75
                timestamp[i] = '\0';
 
76
                xml_free_data_dyn(&data_b64);
 
77
        }
 
78
 
 
79
        if (SUCCEED == xml_get_data_dyn(xml, "source", &data_b64))
 
80
        {
 
81
                str_base64_decode(data_b64, source, source_len - 1, &i);
 
82
                source[i] = '\0';
 
83
                xml_free_data_dyn(&data_b64);
 
84
        }
 
85
 
 
86
        if (SUCCEED == xml_get_data_dyn(xml, "severity", &data_b64))
 
87
        {
 
88
                str_base64_decode(data_b64, severity, severity_len - 1, &i);
 
89
                severity[i] = '\0';
 
90
                xml_free_data_dyn(&data_b64);
 
91
        }
154
92
 
155
93
        return ret;
156
94
}