1 /*
2 ** Zabbix
3 ** Copyright (C) 2001-2021 Zabbix SIA
4 **
5 ** This program is free software; you can redistribute it and/or modify
6 ** it under the terms of the GNU General Public License as published by
7 ** the Free Software Foundation; either version 2 of the License, or
8 ** (at your option) any later version.
9 **
10 ** This program is distributed in the hope that it will be useful,
11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 ** GNU General Public License for more details.
14 **
15 ** You should have received a copy of the GNU General Public License
16 ** along with this program; if not, write to the Free Software
17 ** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 **/
19
20 #include "common.h"
21 #include "log.h"
22 #include "zbxserialize.h"
23 #include "zbxalgo.h"
24 #include "zbxipcservice.h"
25 #include "zbxalert.h"
26
27 #include "alerter_protocol.h"
28
zbx_am_db_mediatype_clear(zbx_am_db_mediatype_t * mediatype)29 void zbx_am_db_mediatype_clear(zbx_am_db_mediatype_t *mediatype)
30 {
31 zbx_free(mediatype->smtp_server);
32 zbx_free(mediatype->smtp_helo);
33 zbx_free(mediatype->smtp_email);
34 zbx_free(mediatype->exec_path);
35 zbx_free(mediatype->exec_params);
36 zbx_free(mediatype->gsm_modem);
37 zbx_free(mediatype->username);
38 zbx_free(mediatype->passwd);
39 zbx_free(mediatype->script);
40 zbx_free(mediatype->attempt_interval);
41 zbx_free(mediatype->timeout);
42 }
43
44 /******************************************************************************
45 * *
46 * Function: zbx_am_db_alert_free *
47 * *
48 * Purpose: frees the alert object *
49 * *
50 * Parameters: alert - [IN] the alert object *
51 * *
52 ******************************************************************************/
zbx_am_db_alert_free(zbx_am_db_alert_t * alert)53 void zbx_am_db_alert_free(zbx_am_db_alert_t *alert)
54 {
55 zbx_free(alert->sendto);
56 zbx_free(alert->subject);
57 zbx_free(alert->message);
58 zbx_free(alert->params);
59 zbx_free(alert);
60 }
61
zbx_am_media_clear(zbx_am_media_t * media)62 void zbx_am_media_clear(zbx_am_media_t *media)
63 {
64 zbx_free(media->sendto);
65 }
66
zbx_am_media_free(zbx_am_media_t * media)67 void zbx_am_media_free(zbx_am_media_t *media)
68 {
69 zbx_am_media_clear(media);
70 zbx_free(media);
71 }
72
zbx_alerter_serialize_result(unsigned char ** data,const char * value,int errcode,const char * error,const char * debug)73 zbx_uint32_t zbx_alerter_serialize_result(unsigned char **data, const char *value, int errcode, const char *error,
74 const char *debug)
75 {
76 unsigned char *ptr;
77 zbx_uint32_t data_len = 0, value_len, error_len, debug_len;
78
79 zbx_serialize_prepare_str(data_len, value);
80 zbx_serialize_prepare_value(data_len, errcode);
81 zbx_serialize_prepare_str(data_len, error);
82 zbx_serialize_prepare_str(data_len, debug);
83
84 *data = (unsigned char *)zbx_malloc(NULL, data_len);
85
86 ptr = *data;
87 ptr += zbx_serialize_str(ptr, value, value_len);
88 ptr += zbx_serialize_value(ptr, errcode);
89 ptr += zbx_serialize_str(ptr, error, error_len);
90 (void)zbx_serialize_str(ptr, debug, debug_len);
91
92 return data_len;
93 }
94
zbx_alerter_deserialize_result(const unsigned char * data,char ** value,int * errcode,char ** error,char ** debug)95 void zbx_alerter_deserialize_result(const unsigned char *data, char **value, int *errcode, char **error,
96 char **debug)
97 {
98 zbx_uint32_t len;
99
100 data += zbx_deserialize_str(data, value, len);
101 data += zbx_deserialize_value(data, errcode);
102 data += zbx_deserialize_str(data, error, len);
103 (void)zbx_deserialize_str(data, debug, len);
104 }
105
zbx_alerter_serialize_email(unsigned char ** data,zbx_uint64_t alertid,zbx_uint64_t mediatypeid,zbx_uint64_t eventid,const char * sendto,const char * subject,const char * message,const char * smtp_server,unsigned short smtp_port,const char * smtp_helo,const char * smtp_email,unsigned char smtp_security,unsigned char smtp_verify_peer,unsigned char smtp_verify_host,unsigned char smtp_authentication,const char * username,const char * password,unsigned char content_type)106 zbx_uint32_t zbx_alerter_serialize_email(unsigned char **data, zbx_uint64_t alertid, zbx_uint64_t mediatypeid,
107 zbx_uint64_t eventid, const char *sendto, const char *subject, const char *message,
108 const char *smtp_server, unsigned short smtp_port, const char *smtp_helo, const char *smtp_email,
109 unsigned char smtp_security, unsigned char smtp_verify_peer, unsigned char smtp_verify_host,
110 unsigned char smtp_authentication, const char *username, const char *password,
111 unsigned char content_type)
112 {
113 unsigned char *ptr;
114 zbx_uint32_t data_len = 0, sendto_len, subject_len, message_len, smtp_server_len, smtp_helo_len,
115 smtp_email_len, username_len, password_len;
116
117 zbx_serialize_prepare_value(data_len, alertid);
118 zbx_serialize_prepare_value(data_len, mediatypeid);
119 zbx_serialize_prepare_value(data_len, eventid);
120 zbx_serialize_prepare_str(data_len, sendto);
121 zbx_serialize_prepare_str(data_len, subject);
122 zbx_serialize_prepare_str(data_len, message);
123 zbx_serialize_prepare_str(data_len, smtp_server);
124 zbx_serialize_prepare_value(data_len, smtp_port);
125 zbx_serialize_prepare_str(data_len, smtp_helo);
126 zbx_serialize_prepare_str(data_len, smtp_email);
127 zbx_serialize_prepare_value(data_len, smtp_security);
128 zbx_serialize_prepare_value(data_len, smtp_verify_peer);
129 zbx_serialize_prepare_value(data_len, smtp_verify_host);
130 zbx_serialize_prepare_value(data_len, smtp_authentication);
131 zbx_serialize_prepare_str(data_len, username);
132 zbx_serialize_prepare_str(data_len, password);
133 zbx_serialize_prepare_value(data_len, content_type);
134
135 *data = (unsigned char *)zbx_malloc(NULL, data_len);
136
137 ptr = *data;
138 ptr += zbx_serialize_value(ptr, alertid);
139 ptr += zbx_serialize_value(ptr, mediatypeid);
140 ptr += zbx_serialize_value(ptr, eventid);
141 ptr += zbx_serialize_str(ptr, sendto, sendto_len);
142 ptr += zbx_serialize_str(ptr, subject, subject_len);
143 ptr += zbx_serialize_str(ptr, message, message_len);
144 ptr += zbx_serialize_str(ptr, smtp_server, smtp_server_len);
145 ptr += zbx_serialize_value(ptr, smtp_port);
146 ptr += zbx_serialize_str(ptr, smtp_helo, smtp_helo_len);
147 ptr += zbx_serialize_str(ptr, smtp_email, smtp_email_len);
148 ptr += zbx_serialize_value(ptr, smtp_security);
149 ptr += zbx_serialize_value(ptr, smtp_verify_peer);
150 ptr += zbx_serialize_value(ptr, smtp_verify_host);
151 ptr += zbx_serialize_value(ptr, smtp_authentication);
152 ptr += zbx_serialize_str(ptr, username, username_len);
153 ptr += zbx_serialize_str(ptr, password, password_len);
154 (void)zbx_serialize_value(ptr, content_type);
155
156 return data_len;
157 }
158
zbx_alerter_deserialize_email(const unsigned char * data,zbx_uint64_t * alertid,zbx_uint64_t * mediatypeid,zbx_uint64_t * eventid,char ** sendto,char ** subject,char ** message,char ** smtp_server,unsigned short * smtp_port,char ** smtp_helo,char ** smtp_email,unsigned char * smtp_security,unsigned char * smtp_verify_peer,unsigned char * smtp_verify_host,unsigned char * smtp_authentication,char ** username,char ** password,unsigned char * content_type)159 void zbx_alerter_deserialize_email(const unsigned char *data, zbx_uint64_t *alertid, zbx_uint64_t *mediatypeid,
160 zbx_uint64_t *eventid, char **sendto, char **subject, char **message, char **smtp_server,
161 unsigned short *smtp_port, char **smtp_helo, char **smtp_email, unsigned char *smtp_security,
162 unsigned char *smtp_verify_peer, unsigned char *smtp_verify_host, unsigned char *smtp_authentication,
163 char **username, char **password, unsigned char *content_type)
164 {
165 zbx_uint32_t len;
166
167 data += zbx_deserialize_value(data, alertid);
168 data += zbx_deserialize_value(data, mediatypeid);
169 data += zbx_deserialize_value(data, eventid);
170 data += zbx_deserialize_str(data, sendto, len);
171 data += zbx_deserialize_str(data, subject, len);
172 data += zbx_deserialize_str(data, message, len);
173 data += zbx_deserialize_str(data, smtp_server, len);
174 data += zbx_deserialize_value(data, smtp_port);
175 data += zbx_deserialize_str(data, smtp_helo, len);
176 data += zbx_deserialize_str(data, smtp_email, len);
177 data += zbx_deserialize_value(data, smtp_security);
178 data += zbx_deserialize_value(data, smtp_verify_peer);
179 data += zbx_deserialize_value(data, smtp_verify_host);
180 data += zbx_deserialize_value(data, smtp_authentication);
181 data += zbx_deserialize_str(data, username, len);
182 data += zbx_deserialize_str(data, password, len);
183 (void)zbx_deserialize_value(data, content_type);
184 }
185
zbx_alerter_serialize_sms(unsigned char ** data,zbx_uint64_t alertid,const char * sendto,const char * message,const char * gsm_modem)186 zbx_uint32_t zbx_alerter_serialize_sms(unsigned char **data, zbx_uint64_t alertid, const char *sendto,
187 const char *message, const char *gsm_modem)
188 {
189 unsigned char *ptr;
190 zbx_uint32_t data_len = 0, sendto_len, gsm_modem_len, message_len;
191
192 zbx_serialize_prepare_value(data_len, alertid);
193 zbx_serialize_prepare_str(data_len, sendto);
194 zbx_serialize_prepare_str(data_len, message);
195 zbx_serialize_prepare_str(data_len, gsm_modem);
196
197 *data = (unsigned char *)zbx_malloc(NULL, data_len);
198
199 ptr = *data;
200 ptr += zbx_serialize_value(ptr, alertid);
201 ptr += zbx_serialize_str(ptr, sendto, sendto_len);
202 ptr += zbx_serialize_str(ptr, message, message_len);
203 (void)zbx_serialize_str(ptr, gsm_modem, gsm_modem_len);
204
205 return data_len;
206 }
207
zbx_alerter_deserialize_sms(const unsigned char * data,zbx_uint64_t * alertid,char ** sendto,char ** message,char ** gsm_modem)208 void zbx_alerter_deserialize_sms(const unsigned char *data, zbx_uint64_t *alertid, char **sendto, char **message,
209 char **gsm_modem)
210 {
211 zbx_uint32_t len;
212
213 data += zbx_deserialize_value(data, alertid);
214 data += zbx_deserialize_str(data, sendto, len);
215 data += zbx_deserialize_str(data, message, len);
216 (void)zbx_deserialize_str(data, gsm_modem, len);
217 }
218
zbx_alerter_serialize_exec(unsigned char ** data,zbx_uint64_t alertid,const char * command)219 zbx_uint32_t zbx_alerter_serialize_exec(unsigned char **data, zbx_uint64_t alertid, const char *command)
220 {
221 unsigned char *ptr;
222 zbx_uint32_t data_len = 0, command_len;
223
224 zbx_serialize_prepare_value(data_len, alertid);
225 zbx_serialize_prepare_str(data_len, command);
226
227 *data = (unsigned char *)zbx_malloc(NULL, data_len);
228
229 ptr = *data;
230 ptr += zbx_serialize_value(ptr, alertid);
231 (void)zbx_serialize_str(ptr, command, command_len);
232
233 return data_len;
234 }
235
zbx_alerter_deserialize_exec(const unsigned char * data,zbx_uint64_t * alertid,char ** command)236 void zbx_alerter_deserialize_exec(const unsigned char *data, zbx_uint64_t *alertid, char **command)
237 {
238 zbx_uint32_t len;
239
240 data += zbx_deserialize_value(data, alertid);
241 (void)zbx_deserialize_str(data, command, len);
242 }
243
alerter_serialize_mediatype(unsigned char ** data,zbx_uint32_t * data_alloc,zbx_uint32_t * data_offset,zbx_uint64_t mediatypeid,unsigned char type,const char * smtp_server,const char * smtp_helo,const char * smtp_email,const char * exec_path,const char * gsm_modem,const char * username,const char * passwd,unsigned short smtp_port,unsigned char smtp_security,unsigned char smtp_verify_peer,unsigned char smtp_verify_host,unsigned char smtp_authentication,const char * exec_params,int maxsessions,int maxattempts,const char * attempt_interval,unsigned char content_type,const char * script,const char * timeout)244 static void alerter_serialize_mediatype(unsigned char **data, zbx_uint32_t *data_alloc, zbx_uint32_t *data_offset,
245 zbx_uint64_t mediatypeid, unsigned char type, const char *smtp_server, const char *smtp_helo,
246 const char *smtp_email, const char *exec_path, const char *gsm_modem, const char *username,
247 const char *passwd, unsigned short smtp_port, unsigned char smtp_security,
248 unsigned char smtp_verify_peer, unsigned char smtp_verify_host, unsigned char smtp_authentication,
249 const char *exec_params, int maxsessions, int maxattempts, const char *attempt_interval,
250 unsigned char content_type, const char *script, const char *timeout)
251 {
252 zbx_uint32_t data_len = 0, smtp_server_len, smtp_helo_len, smtp_email_len, exec_path_len, gsm_modem_len,
253 username_len, passwd_len, exec_params_len, script_len, attempt_interval_len, timeout_len;
254 unsigned char *ptr;
255
256 zbx_serialize_prepare_value(data_len, mediatypeid);
257 zbx_serialize_prepare_value(data_len, type);
258 zbx_serialize_prepare_str_len(data_len, smtp_server, smtp_server_len);
259 zbx_serialize_prepare_str_len(data_len, smtp_helo, smtp_helo_len);
260 zbx_serialize_prepare_str_len(data_len, smtp_email, smtp_email_len);
261 zbx_serialize_prepare_str_len(data_len, exec_path, exec_path_len);
262 zbx_serialize_prepare_str_len(data_len, gsm_modem, gsm_modem_len);
263 zbx_serialize_prepare_str_len(data_len, username, username_len);
264 zbx_serialize_prepare_str_len(data_len, passwd, passwd_len);
265 zbx_serialize_prepare_value(data_len, smtp_port);
266 zbx_serialize_prepare_value(data_len, smtp_security);
267 zbx_serialize_prepare_value(data_len, smtp_verify_peer);
268 zbx_serialize_prepare_value(data_len, smtp_verify_host);
269 zbx_serialize_prepare_value(data_len, smtp_authentication);
270 zbx_serialize_prepare_str_len(data_len, exec_params, exec_params_len);
271 zbx_serialize_prepare_value(data_len, maxsessions);
272 zbx_serialize_prepare_value(data_len, maxattempts);
273 zbx_serialize_prepare_str_len(data_len, attempt_interval, attempt_interval_len);
274 zbx_serialize_prepare_value(data_len, content_type);
275 zbx_serialize_prepare_str_len(data_len, script, script_len);
276 zbx_serialize_prepare_str_len(data_len, timeout, timeout_len);
277
278 while (data_len > *data_alloc - *data_offset)
279 {
280 *data_alloc *= 2;
281 *data = (unsigned char *)zbx_realloc(*data, *data_alloc);
282 }
283
284 ptr = *data + *data_offset;
285 ptr += zbx_serialize_value(ptr, mediatypeid);
286 ptr += zbx_serialize_value(ptr, type);
287 ptr += zbx_serialize_str(ptr, smtp_server, smtp_server_len);
288 ptr += zbx_serialize_str(ptr, smtp_helo, smtp_helo_len);
289 ptr += zbx_serialize_str(ptr, smtp_email, smtp_email_len);
290 ptr += zbx_serialize_str(ptr, exec_path, exec_path_len);
291 ptr += zbx_serialize_str(ptr, gsm_modem, gsm_modem_len);
292 ptr += zbx_serialize_str(ptr, username, username_len);
293 ptr += zbx_serialize_str(ptr, passwd, passwd_len);
294 ptr += zbx_serialize_value(ptr, smtp_port);
295 ptr += zbx_serialize_value(ptr, smtp_security);
296 ptr += zbx_serialize_value(ptr, smtp_verify_peer);
297 ptr += zbx_serialize_value(ptr, smtp_verify_host);
298 ptr += zbx_serialize_value(ptr, smtp_authentication);
299 ptr += zbx_serialize_str(ptr, exec_params, exec_params_len);
300 ptr += zbx_serialize_value(ptr, maxsessions);
301 ptr += zbx_serialize_value(ptr, maxattempts);
302 ptr += zbx_serialize_str(ptr, attempt_interval, attempt_interval_len);
303 ptr += zbx_serialize_value(ptr, content_type);
304 ptr += zbx_serialize_str(ptr, script, script_len);
305 (void)zbx_serialize_str(ptr, timeout, timeout_len);
306
307 *data_offset += data_len;
308 }
309
alerter_deserialize_mediatype(const unsigned char * data,zbx_uint64_t * mediatypeid,unsigned char * type,char ** smtp_server,char ** smtp_helo,char ** smtp_email,char ** exec_path,char ** gsm_modem,char ** username,char ** passwd,unsigned short * smtp_port,unsigned char * smtp_security,unsigned char * smtp_verify_peer,unsigned char * smtp_verify_host,unsigned char * smtp_authentication,char ** exec_params,int * maxsessions,int * maxattempts,char ** attempt_interval,unsigned char * content_type,char ** script,char ** timeout)310 static zbx_uint32_t alerter_deserialize_mediatype(const unsigned char *data, zbx_uint64_t *mediatypeid,
311 unsigned char *type, char **smtp_server, char **smtp_helo, char **smtp_email, char **exec_path,
312 char **gsm_modem, char **username, char **passwd, unsigned short *smtp_port,
313 unsigned char *smtp_security, unsigned char *smtp_verify_peer, unsigned char *smtp_verify_host,
314 unsigned char *smtp_authentication, char **exec_params, int *maxsessions, int *maxattempts,
315 char **attempt_interval, unsigned char *content_type, char **script, char **timeout)
316 {
317 zbx_uint32_t len;
318 const unsigned char *start = data;
319
320 data += zbx_deserialize_value(data, mediatypeid);
321 data += zbx_deserialize_value(data, type);
322 data += zbx_deserialize_str(data, smtp_server, len);
323 data += zbx_deserialize_str(data, smtp_helo, len);
324 data += zbx_deserialize_str(data, smtp_email, len);
325 data += zbx_deserialize_str(data, exec_path, len);
326 data += zbx_deserialize_str(data, gsm_modem, len);
327 data += zbx_deserialize_str(data, username, len);
328 data += zbx_deserialize_str(data, passwd, len);
329 data += zbx_deserialize_value(data, smtp_port);
330 data += zbx_deserialize_value(data, smtp_security);
331 data += zbx_deserialize_value(data, smtp_verify_peer);
332 data += zbx_deserialize_value(data, smtp_verify_host);
333 data += zbx_deserialize_value(data, smtp_authentication);
334 data += zbx_deserialize_str(data, exec_params, len);
335 data += zbx_deserialize_value(data, maxsessions);
336 data += zbx_deserialize_value(data, maxattempts);
337 data += zbx_deserialize_str(data, attempt_interval, len);
338 data += zbx_deserialize_value(data, content_type);
339 data += zbx_deserialize_str(data, script, len);
340 data += zbx_deserialize_str(data, timeout, len);
341
342 return data - start;
343 }
344
zbx_alerter_serialize_alert_send(unsigned char ** data,zbx_uint64_t mediatypeid,unsigned char type,const char * smtp_server,const char * smtp_helo,const char * smtp_email,const char * exec_path,const char * gsm_modem,const char * username,const char * passwd,unsigned short smtp_port,unsigned char smtp_security,unsigned char smtp_verify_peer,unsigned char smtp_verify_host,unsigned char smtp_authentication,const char * exec_params,int maxsessions,int maxattempts,const char * attempt_interval,unsigned char content_type,const char * script,const char * timeout,const char * sendto,const char * subject,const char * message,const char * params)345 zbx_uint32_t zbx_alerter_serialize_alert_send(unsigned char **data, zbx_uint64_t mediatypeid, unsigned char type,
346 const char *smtp_server, const char *smtp_helo, const char *smtp_email, const char *exec_path,
347 const char *gsm_modem, const char *username, const char *passwd, unsigned short smtp_port,
348 unsigned char smtp_security, unsigned char smtp_verify_peer, unsigned char smtp_verify_host,
349 unsigned char smtp_authentication, const char *exec_params, int maxsessions, int maxattempts,
350 const char *attempt_interval, unsigned char content_type, const char *script, const char *timeout,
351 const char *sendto, const char *subject, const char *message, const char *params)
352 {
353 unsigned char *ptr;
354 zbx_uint32_t data_len = 0, data_alloc = 1024, data_offset = 0, sendto_len, subject_len, message_len,
355 params_len;
356
357 *data = zbx_malloc(0, data_alloc);
358 alerter_serialize_mediatype(data, &data_alloc, &data_offset, mediatypeid, type, smtp_server, smtp_helo,
359 smtp_email, exec_path, gsm_modem, username, passwd, smtp_port, smtp_security, smtp_verify_peer,
360 smtp_verify_host, smtp_authentication, exec_params, maxsessions, maxattempts, attempt_interval,
361 content_type, script, timeout);
362
363 zbx_serialize_prepare_str(data_len, sendto);
364 zbx_serialize_prepare_str(data_len, subject);
365 zbx_serialize_prepare_str(data_len, message);
366 zbx_serialize_prepare_str(data_len, params);
367
368 if (data_alloc - data_offset < data_len)
369 {
370 data_alloc = data_offset + data_len;
371 *data = (unsigned char *)zbx_realloc(*data, data_alloc);
372 }
373
374 ptr = *data + data_offset;
375 ptr += zbx_serialize_str(ptr, sendto, sendto_len);
376 ptr += zbx_serialize_str(ptr, subject, subject_len);
377 ptr += zbx_serialize_str(ptr, message, message_len);
378 (void)zbx_serialize_str(ptr, params, params_len);
379
380 return data_len + data_offset;
381 }
382
zbx_alerter_deserialize_alert_send(const unsigned char * data,zbx_uint64_t * mediatypeid,unsigned char * type,char ** smtp_server,char ** smtp_helo,char ** smtp_email,char ** exec_path,char ** gsm_modem,char ** username,char ** passwd,unsigned short * smtp_port,unsigned char * smtp_security,unsigned char * smtp_verify_peer,unsigned char * smtp_verify_host,unsigned char * smtp_authentication,char ** exec_params,int * maxsessions,int * maxattempts,char ** attempt_interval,unsigned char * content_type,char ** script,char ** timeout,char ** sendto,char ** subject,char ** message,char ** params)383 void zbx_alerter_deserialize_alert_send(const unsigned char *data, zbx_uint64_t *mediatypeid,
384 unsigned char *type, char **smtp_server, char **smtp_helo, char **smtp_email, char **exec_path,
385 char **gsm_modem, char **username, char **passwd, unsigned short *smtp_port,
386 unsigned char *smtp_security, unsigned char *smtp_verify_peer, unsigned char *smtp_verify_host,
387 unsigned char *smtp_authentication, char **exec_params, int *maxsessions, int *maxattempts,
388 char **attempt_interval, unsigned char *content_type, char **script, char **timeout,
389 char **sendto, char **subject, char **message, char **params)
390 {
391 zbx_uint32_t len;
392
393 data += alerter_deserialize_mediatype(data, mediatypeid, type, smtp_server, smtp_helo,
394 smtp_email, exec_path, gsm_modem, username, passwd, smtp_port, smtp_security, smtp_verify_peer,
395 smtp_verify_host, smtp_authentication, exec_params, maxsessions, maxattempts, attempt_interval,
396 content_type, script, timeout);
397
398 data += zbx_deserialize_str(data, sendto, len);
399 data += zbx_deserialize_str(data, subject, len);
400 data += zbx_deserialize_str(data, message, len);
401 (void)zbx_deserialize_str(data, params, len);
402 }
403
zbx_alerter_serialize_webhook(unsigned char ** data,const char * script_bin,int script_sz,int timeout,const char * params,unsigned char debug)404 zbx_uint32_t zbx_alerter_serialize_webhook(unsigned char **data, const char *script_bin, int script_sz,
405 int timeout, const char *params, unsigned char debug)
406 {
407 unsigned char *ptr;
408 zbx_uint32_t data_len = 0, params_len;
409
410 data_len += script_sz + sizeof(zbx_uint32_t);
411 zbx_serialize_prepare_value(data_len, script_sz);
412 zbx_serialize_prepare_value(data_len, timeout);
413 zbx_serialize_prepare_str(data_len, params);
414 zbx_serialize_prepare_value(data_len, debug);
415
416 *data = (unsigned char *)zbx_malloc(NULL, data_len);
417
418 ptr = *data;
419 ptr += zbx_serialize_str(ptr, script_bin, script_sz);
420 ptr += zbx_serialize_value(ptr, script_sz);
421 ptr += zbx_serialize_value(ptr, timeout);
422 ptr += zbx_serialize_str(ptr, params, params_len);
423 (void)zbx_serialize_value(ptr, debug);
424
425 return data_len;
426 }
427
zbx_alerter_deserialize_webhook(const unsigned char * data,char ** script_bin,int * script_sz,int * timeout,char ** params,unsigned char * debug)428 void zbx_alerter_deserialize_webhook(const unsigned char *data, char **script_bin, int *script_sz, int *timeout,
429 char **params, unsigned char *debug)
430 {
431 zbx_uint32_t len;
432
433 data += zbx_deserialize_str(data, script_bin, len);
434 data += zbx_deserialize_value(data, script_sz);
435 data += zbx_deserialize_value(data, timeout);
436 data += zbx_deserialize_str(data, params, len);
437 (void)zbx_deserialize_value(data, debug);
438 }
439
zbx_alerter_serialize_mediatypes(unsigned char ** data,zbx_am_db_mediatype_t ** mediatypes,int mediatypes_num)440 zbx_uint32_t zbx_alerter_serialize_mediatypes(unsigned char **data, zbx_am_db_mediatype_t **mediatypes,
441 int mediatypes_num)
442 {
443 unsigned char *ptr;
444 int i;
445 zbx_uint32_t data_alloc = 1024, data_offset = 0;
446
447 ptr = *data = (unsigned char *)zbx_malloc(NULL, data_alloc);
448 zbx_serialize_prepare_value(data_offset, mediatypes_num);
449 (void)zbx_serialize_value(ptr, mediatypes_num);
450
451 for (i = 0; i < mediatypes_num; i++)
452 {
453 zbx_am_db_mediatype_t *mt = mediatypes[i];
454
455 alerter_serialize_mediatype(data, &data_alloc, &data_offset, mt->mediatypeid, mt->type, mt->smtp_server,
456 mt->smtp_helo, mt->smtp_email, mt->exec_path, mt->gsm_modem, mt->username, mt->passwd,
457 mt->smtp_port, mt->smtp_security, mt->smtp_verify_peer, mt->smtp_verify_host,
458 mt->smtp_authentication, mt->exec_params, mt->maxsessions, mt->maxattempts,
459 mt->attempt_interval, mt->content_type, mt->script, mt->timeout);
460 }
461
462 return data_offset;
463 }
464
zbx_alerter_deserialize_mediatypes(const unsigned char * data,zbx_am_db_mediatype_t *** mediatypes,int * mediatypes_num)465 void zbx_alerter_deserialize_mediatypes(const unsigned char *data, zbx_am_db_mediatype_t ***mediatypes,
466 int *mediatypes_num)
467 {
468 int i;
469
470 data += zbx_deserialize_value(data, mediatypes_num);
471 *mediatypes = (zbx_am_db_mediatype_t **)zbx_malloc(NULL, *mediatypes_num * sizeof(zbx_am_db_mediatype_t *));
472 for (i = 0; i < *mediatypes_num; i++)
473 {
474 zbx_am_db_mediatype_t *mt;
475 mt = (zbx_am_db_mediatype_t *)zbx_malloc(NULL, sizeof(zbx_am_db_mediatype_t));
476
477 data += alerter_deserialize_mediatype(data, &mt->mediatypeid, &mt->type, &mt->smtp_server,
478 &mt->smtp_helo, &mt->smtp_email, &mt->exec_path, &mt->gsm_modem, &mt->username,
479 &mt->passwd, &mt->smtp_port, &mt->smtp_security, &mt->smtp_verify_peer,
480 &mt->smtp_verify_host, &mt->smtp_authentication, &mt->exec_params, &mt->maxsessions,
481 &mt->maxattempts, &mt->attempt_interval, &mt->content_type, &mt->script, &mt->timeout);
482
483 (*mediatypes)[i] = mt;
484 }
485 }
486
zbx_alerter_serialize_alerts(unsigned char ** data,zbx_am_db_alert_t ** alerts,int alerts_num)487 zbx_uint32_t zbx_alerter_serialize_alerts(unsigned char **data, zbx_am_db_alert_t **alerts, int alerts_num)
488 {
489 unsigned char *ptr;
490 int i;
491 zbx_uint32_t data_alloc = 1024, data_offset = 0;
492
493 ptr = *data = (unsigned char *)zbx_malloc(NULL, data_alloc);
494 zbx_serialize_prepare_value(data_offset, alerts_num);
495 (void)zbx_serialize_value(ptr, alerts_num);
496
497 for (i = 0; i < alerts_num; i++)
498 {
499 zbx_uint32_t data_len = 0, sendto_len, subject_len, message_len, params_len;
500 zbx_am_db_alert_t *alert = alerts[i];
501
502 zbx_serialize_prepare_value(data_len, alert->alertid);
503 zbx_serialize_prepare_value(data_len, alert->mediatypeid);
504 zbx_serialize_prepare_value(data_len, alert->eventid);
505 zbx_serialize_prepare_value(data_len, alert->p_eventid);
506 zbx_serialize_prepare_value(data_len, alert->source);
507 zbx_serialize_prepare_value(data_len, alert->object);
508 zbx_serialize_prepare_value(data_len, alert->objectid);
509 zbx_serialize_prepare_str_len(data_len, alert->sendto, sendto_len);
510 zbx_serialize_prepare_str_len(data_len, alert->subject, subject_len);
511 zbx_serialize_prepare_str_len(data_len, alert->message, message_len);
512 zbx_serialize_prepare_str_len(data_len, alert->params, params_len);
513 zbx_serialize_prepare_value(data_len, alert->status);
514 zbx_serialize_prepare_value(data_len, alert->retries);
515
516 while (data_len > data_alloc - data_offset)
517 {
518 data_alloc *= 2;
519 *data = (unsigned char *)zbx_realloc(*data, data_alloc);
520 }
521 ptr = *data + data_offset;
522 ptr += zbx_serialize_value(ptr, alert->alertid);
523 ptr += zbx_serialize_value(ptr, alert->mediatypeid);
524 ptr += zbx_serialize_value(ptr, alert->eventid);
525 ptr += zbx_serialize_value(ptr, alert->p_eventid);
526 ptr += zbx_serialize_value(ptr, alert->source);
527 ptr += zbx_serialize_value(ptr, alert->object);
528 ptr += zbx_serialize_value(ptr, alert->objectid);
529 ptr += zbx_serialize_str(ptr, alert->sendto, sendto_len);
530 ptr += zbx_serialize_str(ptr, alert->subject, subject_len);
531 ptr += zbx_serialize_str(ptr, alert->message, message_len);
532 ptr += zbx_serialize_str(ptr, alert->params, params_len);
533 ptr += zbx_serialize_value(ptr, alert->status);
534 (void)zbx_serialize_value(ptr, alert->retries);
535
536 data_offset += data_len;
537 }
538
539 return data_offset;
540 }
541
zbx_alerter_deserialize_alerts(const unsigned char * data,zbx_am_db_alert_t *** alerts,int * alerts_num)542 void zbx_alerter_deserialize_alerts(const unsigned char *data, zbx_am_db_alert_t ***alerts, int *alerts_num)
543 {
544 zbx_uint32_t len;
545 int i;
546
547 data += zbx_deserialize_value(data, alerts_num);
548 *alerts = (zbx_am_db_alert_t **)zbx_malloc(NULL, *alerts_num * sizeof(zbx_am_db_alert_t *));
549 for (i = 0; i < *alerts_num; i++)
550 {
551 zbx_am_db_alert_t *alert;
552 alert = (zbx_am_db_alert_t *)zbx_malloc(NULL, sizeof(zbx_am_db_alert_t));
553
554 data += zbx_deserialize_value(data, &alert->alertid);
555 data += zbx_deserialize_value(data, &alert->mediatypeid);
556 data += zbx_deserialize_value(data, &alert->eventid);
557 data += zbx_deserialize_value(data, &alert->p_eventid);
558 data += zbx_deserialize_value(data, &alert->source);
559 data += zbx_deserialize_value(data, &alert->object);
560 data += zbx_deserialize_value(data, &alert->objectid);
561 data += zbx_deserialize_str(data, &alert->sendto, len);
562 data += zbx_deserialize_str(data, &alert->subject, len);
563 data += zbx_deserialize_str(data, &alert->message, len);
564 data += zbx_deserialize_str(data, &alert->params, len);
565 data += zbx_deserialize_value(data, &alert->status);
566 data += zbx_deserialize_value(data, &alert->retries);
567
568 (*alerts)[i] = alert;
569 }
570 }
571
zbx_alerter_serialize_medias(unsigned char ** data,zbx_am_media_t ** medias,int medias_num)572 zbx_uint32_t zbx_alerter_serialize_medias(unsigned char **data, zbx_am_media_t **medias, int medias_num)
573 {
574 unsigned char *ptr;
575 int i;
576 zbx_uint32_t data_alloc = 1024, data_offset = 0;
577
578 ptr = *data = (unsigned char *)zbx_malloc(NULL, data_alloc);
579 zbx_serialize_prepare_value(data_offset, medias_num);
580 (void)zbx_serialize_value(ptr, medias_num);
581
582 for (i = 0; i < medias_num; i++)
583 {
584 zbx_uint32_t data_len = 0, sendto_len;
585 zbx_am_media_t *media = medias[i];
586
587 zbx_serialize_prepare_value(data_len, media->mediaid);
588 zbx_serialize_prepare_value(data_len, media->mediatypeid);
589 zbx_serialize_prepare_str_len(data_len, media->sendto, sendto_len);
590
591 while (data_len > data_alloc - data_offset)
592 {
593 data_alloc *= 2;
594 *data = (unsigned char *)zbx_realloc(*data, data_alloc);
595 }
596 ptr = *data + data_offset;
597 ptr += zbx_serialize_value(ptr, media->mediaid);
598 ptr += zbx_serialize_value(ptr, media->mediatypeid);
599 (void)zbx_serialize_str(ptr, media->sendto, sendto_len);
600
601 data_offset += data_len;
602 }
603
604 return data_offset;
605 }
606
zbx_alerter_deserialize_medias(const unsigned char * data,zbx_am_media_t *** medias,int * medias_num)607 void zbx_alerter_deserialize_medias(const unsigned char *data, zbx_am_media_t ***medias, int *medias_num)
608 {
609 zbx_uint32_t len;
610 int i;
611
612 data += zbx_deserialize_value(data, medias_num);
613 *medias = (zbx_am_media_t **)zbx_malloc(NULL, *medias_num * sizeof(zbx_am_media_t *));
614 for (i = 0; i < *medias_num; i++)
615 {
616 zbx_am_media_t *media;
617 media = (zbx_am_media_t *)zbx_malloc(NULL, sizeof(zbx_am_media_t));
618
619 data += zbx_deserialize_value(data, &media->mediaid);
620 data += zbx_deserialize_value(data, &media->mediatypeid);
621 data += zbx_deserialize_str(data, &media->sendto, len);
622
623 (*medias)[i] = media;
624 }
625 }
626
zbx_alerter_serialize_results(unsigned char ** data,zbx_am_result_t ** results,int results_num)627 zbx_uint32_t zbx_alerter_serialize_results(unsigned char **data, zbx_am_result_t **results, int results_num)
628 {
629 unsigned char *ptr;
630 int i;
631 zbx_uint32_t data_alloc = 1024, data_offset = 0;
632
633 ptr = *data = (unsigned char *)zbx_malloc(NULL, data_alloc);
634 zbx_serialize_prepare_value(data_offset, results_num);
635 (void)zbx_serialize_value(ptr, results_num);
636
637 for (i = 0; i < results_num; i++)
638 {
639 zbx_uint32_t data_len = 0, value_len, error_len;
640 zbx_am_result_t *result = results[i];
641
642 zbx_serialize_prepare_value(data_len, result->alertid);
643 zbx_serialize_prepare_value(data_len, result->eventid);
644 zbx_serialize_prepare_value(data_len, result->mediatypeid);
645 zbx_serialize_prepare_value(data_len, result->source);
646 zbx_serialize_prepare_value(data_len, result->status);
647 zbx_serialize_prepare_value(data_len, result->retries);
648 zbx_serialize_prepare_str_len(data_len, result->value, value_len);
649 zbx_serialize_prepare_str_len(data_len, result->error, error_len);
650
651 while (data_len > data_alloc - data_offset)
652 {
653 data_alloc *= 2;
654 *data = (unsigned char *)zbx_realloc(*data, data_alloc);
655 }
656 ptr = *data + data_offset;
657 ptr += zbx_serialize_value(ptr, result->alertid);
658 ptr += zbx_serialize_value(ptr, result->eventid);
659 ptr += zbx_serialize_value(ptr, result->mediatypeid);
660 ptr += zbx_serialize_value(ptr, result->source);
661 ptr += zbx_serialize_value(ptr, result->status);
662 ptr += zbx_serialize_value(ptr, result->retries);
663 ptr += zbx_serialize_str(ptr, result->value, value_len);
664 (void)zbx_serialize_str(ptr, result->error, error_len);
665
666 data_offset += data_len;
667 }
668
669 return data_offset;
670 }
671
zbx_alerter_deserialize_results(const unsigned char * data,zbx_am_result_t *** results,int * results_num)672 void zbx_alerter_deserialize_results(const unsigned char *data, zbx_am_result_t ***results, int *results_num)
673 {
674 zbx_uint32_t len;
675 int i;
676
677 data += zbx_deserialize_value(data, results_num);
678 *results = (zbx_am_result_t **)zbx_malloc(NULL, *results_num * sizeof(zbx_am_result_t *));
679 for (i = 0; i < *results_num; i++)
680 {
681 zbx_am_result_t *result;
682 result = (zbx_am_result_t *)zbx_malloc(NULL, sizeof(zbx_am_result_t));
683
684 data += zbx_deserialize_value(data, &result->alertid);
685 data += zbx_deserialize_value(data, &result->eventid);
686 data += zbx_deserialize_value(data, &result->mediatypeid);
687 data += zbx_deserialize_value(data, &result->source);
688 data += zbx_deserialize_value(data, &result->status);
689 data += zbx_deserialize_value(data, &result->retries);
690 data += zbx_deserialize_str(data, &result->value, len);
691 data += zbx_deserialize_str(data, &result->error, len);
692
693 (*results)[i] = result;
694 }
695 }
696
zbx_alerter_serialize_ids(unsigned char ** data,zbx_uint64_t * ids,int ids_num)697 zbx_uint32_t zbx_alerter_serialize_ids(unsigned char **data, zbx_uint64_t *ids, int ids_num)
698 {
699 unsigned char *ptr;
700 int i;
701 zbx_uint32_t data_alloc = 128, data_offset = 0;
702
703 ptr = *data = (unsigned char *)zbx_malloc(NULL, data_alloc);
704 zbx_serialize_prepare_value(data_offset, ids_num);
705 (void)zbx_serialize_value(ptr, ids_num);
706
707 for (i = 0; i < ids_num; i++)
708 {
709 zbx_uint32_t data_len = 0;
710
711 zbx_serialize_prepare_value(data_len, ids[i]);
712
713 while (data_len > data_alloc - data_offset)
714 {
715 data_alloc *= 2;
716 *data = (unsigned char *)zbx_realloc(*data, data_alloc);
717 }
718 ptr = *data + data_offset;
719 (void)zbx_serialize_value(ptr, ids[i]);
720 data_offset += data_len;
721 }
722
723 return data_offset;
724 }
725
zbx_alerter_deserialize_ids(const unsigned char * data,zbx_uint64_t ** ids,int * ids_num)726 void zbx_alerter_deserialize_ids(const unsigned char *data, zbx_uint64_t **ids, int *ids_num)
727 {
728 int i;
729
730 data += zbx_deserialize_value(data, ids_num);
731 *ids = (zbx_uint64_t *)zbx_malloc(NULL, *ids_num * sizeof(zbx_uint64_t));
732 for (i = 0; i < *ids_num; i++)
733 data += zbx_deserialize_value(data, &(*ids)[i]);
734 }
735
736 /******************************************************************************
737 * *
738 * Function: zbx_alerter_serialize_diag_stats *
739 * *
740 ******************************************************************************/
zbx_alerter_serialize_diag_stats(unsigned char ** data,zbx_uint64_t alerts_num)741 zbx_uint32_t zbx_alerter_serialize_diag_stats(unsigned char **data, zbx_uint64_t alerts_num)
742 {
743 zbx_uint32_t data_len = 0;
744
745 zbx_serialize_prepare_value(data_len, alerts_num);
746 *data = (unsigned char *)zbx_malloc(NULL, data_len);
747 (void)zbx_serialize_value(*data, alerts_num);
748
749 return data_len;
750 }
751
752 /******************************************************************************
753 * *
754 * Function: zbx_alerter_deserialize_diag_stats *
755 * *
756 ******************************************************************************/
zbx_alerter_deserialize_diag_stats(const unsigned char * data,zbx_uint64_t * alerts_num)757 static void zbx_alerter_deserialize_diag_stats(const unsigned char *data, zbx_uint64_t *alerts_num)
758 {
759 (void)zbx_deserialize_value(data, alerts_num);
760 }
761
762 /******************************************************************************
763 * *
764 * Function: zbx_alerter_serialize_top_request *
765 * *
766 ******************************************************************************/
zbx_alerter_serialize_top_request(unsigned char ** data,int limit)767 static zbx_uint32_t zbx_alerter_serialize_top_request(unsigned char **data, int limit)
768 {
769 zbx_uint32_t len;
770
771 *data = (unsigned char *)zbx_malloc(NULL, sizeof(limit));
772 len = zbx_serialize_value(*data, limit);
773
774 return len;
775 }
776
777 /******************************************************************************
778 * *
779 * Function: zbx_alerter_deserialize_top_request *
780 * *
781 ******************************************************************************/
zbx_alerter_deserialize_top_request(const unsigned char * data,int * limit)782 void zbx_alerter_deserialize_top_request(const unsigned char *data, int *limit)
783 {
784 (void)zbx_deserialize_value(data, limit);
785 }
786
787 /******************************************************************************
788 * *
789 * Function: zbx_alerter_serialize_top_mediatypes_result *
790 * *
791 ******************************************************************************/
zbx_alerter_serialize_top_mediatypes_result(unsigned char ** data,zbx_am_mediatype_t ** mediatypes,int mediatypes_num)792 zbx_uint32_t zbx_alerter_serialize_top_mediatypes_result(unsigned char **data, zbx_am_mediatype_t **mediatypes,
793 int mediatypes_num)
794 {
795 unsigned char *ptr;
796 zbx_uint32_t data_len = 0, mediatype_len = 0;
797 int i;
798
799 if (0 != mediatypes_num)
800 {
801 zbx_serialize_prepare_value(mediatype_len, mediatypes[0]->mediatypeid);
802 zbx_serialize_prepare_value(mediatype_len, mediatypes[0]->refcount);
803 }
804
805 zbx_serialize_prepare_value(data_len, mediatypes_num);
806 data_len += mediatype_len * mediatypes_num;
807 *data = (unsigned char *)zbx_malloc(NULL, data_len);
808
809 ptr = *data;
810 ptr += zbx_serialize_value(ptr, mediatypes_num);
811
812 for (i = 0; i < mediatypes_num; i++)
813 {
814 ptr += zbx_serialize_value(ptr, mediatypes[0]->mediatypeid);
815 ptr += zbx_serialize_value(ptr, mediatypes[0]->refcount);
816 }
817
818 return data_len;
819 }
820
821 /******************************************************************************
822 * *
823 * Function: zbx_alerter_deserialize_top_mediatypes_result *
824 * *
825 ******************************************************************************/
zbx_alerter_deserialize_top_mediatypes_result(const unsigned char * data,zbx_vector_uint64_pair_t * mediatypes)826 static void zbx_alerter_deserialize_top_mediatypes_result(const unsigned char *data,
827 zbx_vector_uint64_pair_t *mediatypes)
828 {
829 int i, mediatypes_num;
830
831 data += zbx_deserialize_value(data, &mediatypes_num);
832
833 if (0 != mediatypes_num)
834 {
835 zbx_vector_uint64_pair_reserve(mediatypes, mediatypes_num);
836
837 for (i = 0; i < mediatypes_num; i++)
838 {
839 zbx_uint64_pair_t pair;
840 int value;
841
842 data += zbx_deserialize_value(data, &pair.first);
843 data += zbx_deserialize_value(data, &value);
844 pair.second = value;
845 zbx_vector_uint64_pair_append_ptr(mediatypes, &pair);
846 }
847 }
848 }
849
850 /******************************************************************************
851 * *
852 * Function: zbx_alerter_serialize_top_sources_result *
853 * *
854 ******************************************************************************/
zbx_alerter_serialize_top_sources_result(unsigned char ** data,zbx_am_source_stats_t ** sources,int sources_num)855 zbx_uint32_t zbx_alerter_serialize_top_sources_result(unsigned char **data, zbx_am_source_stats_t **sources,
856 int sources_num)
857 {
858 unsigned char *ptr;
859 zbx_uint32_t data_len = 0, source_len = 0;
860 int i;
861
862 if (0 != sources_num)
863 {
864 zbx_serialize_prepare_value(source_len, sources[0]->source);
865 zbx_serialize_prepare_value(source_len, sources[0]->object);
866 zbx_serialize_prepare_value(source_len, sources[0]->objectid);
867 zbx_serialize_prepare_value(source_len, sources[0]->alerts_num);
868 }
869
870 zbx_serialize_prepare_value(data_len, sources_num);
871 data_len += source_len * sources_num;
872 *data = (unsigned char *)zbx_malloc(NULL, data_len);
873
874 ptr = *data;
875 ptr += zbx_serialize_value(ptr, sources_num);
876
877 for (i = 0; i < sources_num; i++)
878 {
879 ptr += zbx_serialize_value(ptr, sources[i]->source);
880 ptr += zbx_serialize_value(ptr, sources[i]->object);
881 ptr += zbx_serialize_value(ptr, sources[i]->objectid);
882 ptr += zbx_serialize_value(ptr, sources[i]->alerts_num);
883 }
884
885 return data_len;
886 }
887
888 /******************************************************************************
889 * *
890 * Function: zbx_alerter_deserialize_top_sources_result *
891 * *
892 ******************************************************************************/
zbx_alerter_deserialize_top_sources_result(const unsigned char * data,zbx_vector_ptr_t * sources)893 static void zbx_alerter_deserialize_top_sources_result(const unsigned char *data, zbx_vector_ptr_t *sources)
894 {
895 int i, sources_num;
896
897 data += zbx_deserialize_value(data, &sources_num);
898
899 if (0 != sources_num)
900 {
901 zbx_vector_ptr_reserve(sources, sources_num);
902
903 for (i = 0; i < sources_num; i++)
904 {
905 zbx_am_source_stats_t *source;;
906
907 source = (zbx_am_source_stats_t *)zbx_malloc(NULL, sizeof(zbx_am_source_stats_t));
908 data += zbx_deserialize_value(data, &source->source);
909 data += zbx_deserialize_value(data, &source->object);
910 data += zbx_deserialize_value(data, &source->objectid);
911 data += zbx_deserialize_value(data, &source->alerts_num);
912 zbx_vector_ptr_append(sources, source);
913 }
914 }
915 }
916
917 /******************************************************************************
918 * *
919 * Function: zbx_alerter_get_diag_stats *
920 * *
921 * Purpose: get alerter manager diagnostic statistics *
922 * *
923 ******************************************************************************/
zbx_alerter_get_diag_stats(zbx_uint64_t * alerts_num,char ** error)924 int zbx_alerter_get_diag_stats(zbx_uint64_t *alerts_num, char **error)
925 {
926 unsigned char *result;
927
928 if (SUCCEED != zbx_ipc_async_exchange(ZBX_IPC_SERVICE_ALERTER, ZBX_IPC_ALERTER_DIAG_STATS, SEC_PER_MIN, NULL, 0,
929 &result, error))
930 {
931 return FAIL;
932 }
933
934 zbx_alerter_deserialize_diag_stats(result, alerts_num);
935 zbx_free(result);
936
937 return SUCCEED;
938 }
939
940 /******************************************************************************
941 * *
942 * Function: zbx_alerter_get_top_mediatypes *
943 * *
944 * Purpose: get the top N mediatypes by the number of queued alerts *
945 * *
946 * Parameters limit - [IN] the number of top records to retrieve *
947 * mediatypes - [OUT] a vector of top mediatypeid,alerts_num pairs *
948 * error - [OUT] the error message *
949 * *
950 * Return value: SUCCEED - the top n mediatypes were returned successfully *
951 * FAIL - otherwise *
952 * *
953 ******************************************************************************/
zbx_alerter_get_top_mediatypes(int limit,zbx_vector_uint64_pair_t * mediatypes,char ** error)954 int zbx_alerter_get_top_mediatypes(int limit, zbx_vector_uint64_pair_t *mediatypes, char **error)
955 {
956 int ret;
957 unsigned char *data, *result;
958 zbx_uint32_t data_len;
959
960 data_len = zbx_alerter_serialize_top_request(&data, limit);
961
962 if (SUCCEED != (ret = zbx_ipc_async_exchange(ZBX_IPC_SERVICE_ALERTER, ZBX_IPC_ALERTER_DIAG_TOP_MEDIATYPES,
963 SEC_PER_MIN, data, data_len, &result, error)))
964 {
965 goto out;
966 }
967
968 zbx_alerter_deserialize_top_mediatypes_result(result, mediatypes);
969 zbx_free(result);
970 out:
971 zbx_free(data);
972
973 return ret;
974 }
975
976 /******************************************************************************
977 * *
978 * Function: zbx_alerter_get_top_sources *
979 * *
980 * Purpose: get the top N sources by the number of queued alerts *
981 * *
982 * Parameters limit - [IN] the number of top records to retrieve *
983 * sources - [OUT] a vector of top zbx_alerter_source_stats_t *
984 * structure *
985 * error - [OUT] the error message *
986 * *
987 * Return value: SUCCEED - the top n sources were returned successfully *
988 * FAIL - otherwise *
989 * *
990 ******************************************************************************/
zbx_alerter_get_top_sources(int limit,zbx_vector_ptr_t * sources,char ** error)991 int zbx_alerter_get_top_sources(int limit, zbx_vector_ptr_t *sources, char **error)
992 {
993 int ret;
994 unsigned char *data, *result;
995 zbx_uint32_t data_len;
996
997 data_len = zbx_alerter_serialize_top_request(&data, limit);
998
999 if (SUCCEED != (ret = zbx_ipc_async_exchange(ZBX_IPC_SERVICE_ALERTER, ZBX_IPC_ALERTER_DIAG_TOP_SOURCES,
1000 SEC_PER_MIN, data, data_len, &result, error)))
1001 {
1002 goto out;
1003 }
1004
1005 zbx_alerter_deserialize_top_sources_result(result, sources);
1006 zbx_free(result);
1007 out:
1008 zbx_free(data);
1009
1010 return ret;
1011 }
1012