intel_pmu: address PR comments
[collectd.git] / src / write_http.c
1 /**
2  * collectd - src/write_http.c
3  * Copyright (C) 2009       Paul Sadauskas
4  * Copyright (C) 2009       Doug MacEachern
5  * Copyright (C) 2007-2014  Florian octo Forster
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License as published by the
9  * Free Software Foundation; only version 2 of the License is applicable.
10  *
11  * This program is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19  *
20  * Authors:
21  *   Florian octo Forster <octo at collectd.org>
22  *   Doug MacEachern <dougm@hyperic.com>
23  *   Paul Sadauskas <psadauskas@gmail.com>
24  **/
25
26 #include "collectd.h"
27
28 #include "common.h"
29 #include "plugin.h"
30 #include "utils_format_json.h"
31 #include "utils_format_kairosdb.h"
32
33 #include <curl/curl.h>
34
35 #ifndef WRITE_HTTP_DEFAULT_BUFFER_SIZE
36 #define WRITE_HTTP_DEFAULT_BUFFER_SIZE 4096
37 #endif
38
39 /*
40  * Private variables
41  */
42 struct wh_callback_s {
43   char *name;
44
45   char *location;
46   char *user;
47   char *pass;
48   char *credentials;
49   _Bool verify_peer;
50   _Bool verify_host;
51   char *cacert;
52   char *capath;
53   char *clientkey;
54   char *clientcert;
55   char *clientkeypass;
56   long sslversion;
57   _Bool store_rates;
58   _Bool log_http_error;
59   int low_speed_limit;
60   time_t low_speed_time;
61   int timeout;
62
63 #define WH_FORMAT_COMMAND 0
64 #define WH_FORMAT_JSON 1
65 #define WH_FORMAT_KAIROSDB 2
66   int format;
67   _Bool send_metrics;
68   _Bool send_notifications;
69
70   CURL *curl;
71   struct curl_slist *headers;
72   char curl_errbuf[CURL_ERROR_SIZE];
73
74   char *send_buffer;
75   size_t send_buffer_size;
76   size_t send_buffer_free;
77   size_t send_buffer_fill;
78   cdtime_t send_buffer_init_time;
79
80   pthread_mutex_t send_lock;
81
82   int data_ttl;
83 };
84 typedef struct wh_callback_s wh_callback_t;
85
86 static char **http_attrs;
87 static size_t http_attrs_num;
88
89 static void wh_log_http_error(wh_callback_t *cb) {
90   if (!cb->log_http_error)
91     return;
92
93   long http_code = 0;
94
95   curl_easy_getinfo(cb->curl, CURLINFO_RESPONSE_CODE, &http_code);
96
97   if (http_code != 200)
98     INFO("write_http plugin: HTTP Error code: %lu", http_code);
99 }
100
101 static void wh_reset_buffer(wh_callback_t *cb) /* {{{ */
102 {
103   if ((cb == NULL) || (cb->send_buffer == NULL))
104     return;
105
106   memset(cb->send_buffer, 0, cb->send_buffer_size);
107   cb->send_buffer_free = cb->send_buffer_size;
108   cb->send_buffer_fill = 0;
109   cb->send_buffer_init_time = cdtime();
110
111   if (cb->format == WH_FORMAT_JSON || cb->format == WH_FORMAT_KAIROSDB) {
112     format_json_initialize(cb->send_buffer, &cb->send_buffer_fill,
113                            &cb->send_buffer_free);
114   }
115 } /* }}} wh_reset_buffer */
116
117 /* must hold cb->send_lock when calling */
118 static int wh_post_nolock(wh_callback_t *cb, char const *data) /* {{{ */
119 {
120   int status = 0;
121
122   curl_easy_setopt(cb->curl, CURLOPT_URL, cb->location);
123   curl_easy_setopt(cb->curl, CURLOPT_POSTFIELDS, data);
124   status = curl_easy_perform(cb->curl);
125
126   wh_log_http_error(cb);
127
128   if (status != CURLE_OK) {
129     ERROR("write_http plugin: curl_easy_perform failed with "
130           "status %i: %s",
131           status, cb->curl_errbuf);
132   }
133   return status;
134 } /* }}} wh_post_nolock */
135
136 static int wh_callback_init(wh_callback_t *cb) /* {{{ */
137 {
138   if (cb->curl != NULL)
139     return 0;
140
141   cb->curl = curl_easy_init();
142   if (cb->curl == NULL) {
143     ERROR("curl plugin: curl_easy_init failed.");
144     return -1;
145   }
146
147   if (cb->low_speed_limit > 0 && cb->low_speed_time > 0) {
148     curl_easy_setopt(cb->curl, CURLOPT_LOW_SPEED_LIMIT,
149                      (long)(cb->low_speed_limit * cb->low_speed_time));
150     curl_easy_setopt(cb->curl, CURLOPT_LOW_SPEED_TIME,
151                      (long)cb->low_speed_time);
152   }
153
154 #ifdef HAVE_CURLOPT_TIMEOUT_MS
155   if (cb->timeout > 0)
156     curl_easy_setopt(cb->curl, CURLOPT_TIMEOUT_MS, (long)cb->timeout);
157 #endif
158
159   curl_easy_setopt(cb->curl, CURLOPT_NOSIGNAL, 1L);
160   curl_easy_setopt(cb->curl, CURLOPT_USERAGENT, COLLECTD_USERAGENT);
161
162   cb->headers = curl_slist_append(cb->headers, "Accept:  */*");
163   if (cb->format == WH_FORMAT_JSON || cb->format == WH_FORMAT_KAIROSDB)
164     cb->headers =
165         curl_slist_append(cb->headers, "Content-Type: application/json");
166   else
167     cb->headers = curl_slist_append(cb->headers, "Content-Type: text/plain");
168   cb->headers = curl_slist_append(cb->headers, "Expect:");
169   curl_easy_setopt(cb->curl, CURLOPT_HTTPHEADER, cb->headers);
170
171   curl_easy_setopt(cb->curl, CURLOPT_ERRORBUFFER, cb->curl_errbuf);
172   curl_easy_setopt(cb->curl, CURLOPT_FOLLOWLOCATION, 1L);
173   curl_easy_setopt(cb->curl, CURLOPT_MAXREDIRS, 50L);
174
175   if (cb->user != NULL) {
176 #ifdef HAVE_CURLOPT_USERNAME
177     curl_easy_setopt(cb->curl, CURLOPT_USERNAME, cb->user);
178     curl_easy_setopt(cb->curl, CURLOPT_PASSWORD,
179                      (cb->pass == NULL) ? "" : cb->pass);
180 #else
181     size_t credentials_size;
182
183     credentials_size = strlen(cb->user) + 2;
184     if (cb->pass != NULL)
185       credentials_size += strlen(cb->pass);
186
187     cb->credentials = malloc(credentials_size);
188     if (cb->credentials == NULL) {
189       ERROR("curl plugin: malloc failed.");
190       return -1;
191     }
192
193     snprintf(cb->credentials, credentials_size, "%s:%s", cb->user,
194              (cb->pass == NULL) ? "" : cb->pass);
195     curl_easy_setopt(cb->curl, CURLOPT_USERPWD, cb->credentials);
196 #endif
197     curl_easy_setopt(cb->curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
198   }
199
200   curl_easy_setopt(cb->curl, CURLOPT_SSL_VERIFYPEER, (long)cb->verify_peer);
201   curl_easy_setopt(cb->curl, CURLOPT_SSL_VERIFYHOST, cb->verify_host ? 2L : 0L);
202   curl_easy_setopt(cb->curl, CURLOPT_SSLVERSION, cb->sslversion);
203   if (cb->cacert != NULL)
204     curl_easy_setopt(cb->curl, CURLOPT_CAINFO, cb->cacert);
205   if (cb->capath != NULL)
206     curl_easy_setopt(cb->curl, CURLOPT_CAPATH, cb->capath);
207
208   if (cb->clientkey != NULL && cb->clientcert != NULL) {
209     curl_easy_setopt(cb->curl, CURLOPT_SSLKEY, cb->clientkey);
210     curl_easy_setopt(cb->curl, CURLOPT_SSLCERT, cb->clientcert);
211
212     if (cb->clientkeypass != NULL)
213       curl_easy_setopt(cb->curl, CURLOPT_SSLKEYPASSWD, cb->clientkeypass);
214   }
215
216   wh_reset_buffer(cb);
217
218   return 0;
219 } /* }}} int wh_callback_init */
220
221 static int wh_flush_nolock(cdtime_t timeout, wh_callback_t *cb) /* {{{ */
222 {
223   int status;
224
225   DEBUG("write_http plugin: wh_flush_nolock: timeout = %.3f; "
226         "send_buffer_fill = %zu;",
227         CDTIME_T_TO_DOUBLE(timeout), cb->send_buffer_fill);
228
229   /* timeout == 0  => flush unconditionally */
230   if (timeout > 0) {
231     cdtime_t now;
232
233     now = cdtime();
234     if ((cb->send_buffer_init_time + timeout) > now)
235       return 0;
236   }
237
238   if (cb->format == WH_FORMAT_COMMAND) {
239     if (cb->send_buffer_fill == 0) {
240       cb->send_buffer_init_time = cdtime();
241       return 0;
242     }
243
244     status = wh_post_nolock(cb, cb->send_buffer);
245     wh_reset_buffer(cb);
246   } else if (cb->format == WH_FORMAT_JSON || cb->format == WH_FORMAT_KAIROSDB) {
247     if (cb->send_buffer_fill <= 2) {
248       cb->send_buffer_init_time = cdtime();
249       return 0;
250     }
251
252     status = format_json_finalize(cb->send_buffer, &cb->send_buffer_fill,
253                                   &cb->send_buffer_free);
254     if (status != 0) {
255       ERROR("write_http: wh_flush_nolock: "
256             "format_json_finalize failed.");
257       wh_reset_buffer(cb);
258       return status;
259     }
260
261     status = wh_post_nolock(cb, cb->send_buffer);
262     wh_reset_buffer(cb);
263   } else {
264     ERROR("write_http: wh_flush_nolock: "
265           "Unknown format: %i",
266           cb->format);
267     return -1;
268   }
269
270   return status;
271 } /* }}} wh_flush_nolock */
272
273 static int wh_flush(cdtime_t timeout, /* {{{ */
274                     const char *identifier __attribute__((unused)),
275                     user_data_t *user_data) {
276   wh_callback_t *cb;
277   int status;
278
279   if (user_data == NULL)
280     return -EINVAL;
281
282   cb = user_data->data;
283
284   pthread_mutex_lock(&cb->send_lock);
285
286   if (wh_callback_init(cb) != 0) {
287     ERROR("write_http plugin: wh_callback_init failed.");
288     pthread_mutex_unlock(&cb->send_lock);
289     return -1;
290   }
291
292   status = wh_flush_nolock(timeout, cb);
293   pthread_mutex_unlock(&cb->send_lock);
294
295   return status;
296 } /* }}} int wh_flush */
297
298 static void wh_callback_free(void *data) /* {{{ */
299 {
300   wh_callback_t *cb;
301
302   if (data == NULL)
303     return;
304
305   cb = data;
306
307   if (cb->send_buffer != NULL)
308     wh_flush_nolock(/* timeout = */ 0, cb);
309
310   if (cb->curl != NULL) {
311     curl_easy_cleanup(cb->curl);
312     cb->curl = NULL;
313   }
314
315   if (cb->headers != NULL) {
316     curl_slist_free_all(cb->headers);
317     cb->headers = NULL;
318   }
319
320   sfree(cb->name);
321   sfree(cb->location);
322   sfree(cb->user);
323   sfree(cb->pass);
324   sfree(cb->credentials);
325   sfree(cb->cacert);
326   sfree(cb->capath);
327   sfree(cb->clientkey);
328   sfree(cb->clientcert);
329   sfree(cb->clientkeypass);
330   sfree(cb->send_buffer);
331
332   sfree(cb);
333 } /* }}} void wh_callback_free */
334
335 static int wh_write_command(const data_set_t *ds,
336                             const value_list_t *vl, /* {{{ */
337                             wh_callback_t *cb) {
338   char key[10 * DATA_MAX_NAME_LEN];
339   char values[512];
340   char command[1024];
341   size_t command_len;
342
343   int status;
344
345   /* sanity checks, primarily to make static analyzers happy. */
346   if ((cb == NULL) || (cb->send_buffer == NULL))
347     return -1;
348
349   if (strcmp(ds->type, vl->type) != 0) {
350     ERROR("write_http plugin: DS type does not match "
351           "value list type");
352     return -1;
353   }
354
355   /* Copy the identifier to `key' and escape it. */
356   status = FORMAT_VL(key, sizeof(key), vl);
357   if (status != 0) {
358     ERROR("write_http plugin: error with format_name");
359     return status;
360   }
361   escape_string(key, sizeof(key));
362
363   /* Convert the values to an ASCII representation and put that into
364    * `values'. */
365   status = format_values(values, sizeof(values), ds, vl, cb->store_rates);
366   if (status != 0) {
367     ERROR("write_http plugin: error with "
368           "wh_value_list_to_string");
369     return status;
370   }
371
372   command_len = (size_t)snprintf(command, sizeof(command),
373                                  "PUTVAL %s interval=%.3f %s\r\n", key,
374                                  CDTIME_T_TO_DOUBLE(vl->interval), values);
375   if (command_len >= sizeof(command)) {
376     ERROR("write_http plugin: Command buffer too small: "
377           "Need %zu bytes.",
378           command_len + 1);
379     return -1;
380   }
381
382   pthread_mutex_lock(&cb->send_lock);
383   if (wh_callback_init(cb) != 0) {
384     ERROR("write_http plugin: wh_callback_init failed.");
385     pthread_mutex_unlock(&cb->send_lock);
386     return -1;
387   }
388
389   if (command_len >= cb->send_buffer_free) {
390     status = wh_flush_nolock(/* timeout = */ 0, cb);
391     if (status != 0) {
392       pthread_mutex_unlock(&cb->send_lock);
393       return status;
394     }
395   }
396   assert(command_len < cb->send_buffer_free);
397
398   /* Make scan-build happy. */
399   assert(cb->send_buffer != NULL);
400
401   /* `command_len + 1' because `command_len' does not include the
402    * trailing null byte. Neither does `send_buffer_fill'. */
403   memcpy(cb->send_buffer + cb->send_buffer_fill, command, command_len + 1);
404   cb->send_buffer_fill += command_len;
405   cb->send_buffer_free -= command_len;
406
407   DEBUG("write_http plugin: <%s> buffer %zu/%zu (%g%%) \"%s\"", cb->location,
408         cb->send_buffer_fill, cb->send_buffer_size,
409         100.0 * ((double)cb->send_buffer_fill) / ((double)cb->send_buffer_size),
410         command);
411
412   /* Check if we have enough space for this command. */
413   pthread_mutex_unlock(&cb->send_lock);
414
415   return 0;
416 } /* }}} int wh_write_command */
417
418 static int wh_write_json(const data_set_t *ds, const value_list_t *vl, /* {{{ */
419                          wh_callback_t *cb) {
420   int status;
421
422   pthread_mutex_lock(&cb->send_lock);
423   if (wh_callback_init(cb) != 0) {
424     ERROR("write_http plugin: wh_callback_init failed.");
425     pthread_mutex_unlock(&cb->send_lock);
426     return -1;
427   }
428
429   status =
430       format_json_value_list(cb->send_buffer, &cb->send_buffer_fill,
431                              &cb->send_buffer_free, ds, vl, cb->store_rates);
432   if (status == -ENOMEM) {
433     status = wh_flush_nolock(/* timeout = */ 0, cb);
434     if (status != 0) {
435       wh_reset_buffer(cb);
436       pthread_mutex_unlock(&cb->send_lock);
437       return status;
438     }
439
440     status =
441         format_json_value_list(cb->send_buffer, &cb->send_buffer_fill,
442                                &cb->send_buffer_free, ds, vl, cb->store_rates);
443   }
444   if (status != 0) {
445     pthread_mutex_unlock(&cb->send_lock);
446     return status;
447   }
448
449   DEBUG("write_http plugin: <%s> buffer %zu/%zu (%g%%)", cb->location,
450         cb->send_buffer_fill, cb->send_buffer_size,
451         100.0 * ((double)cb->send_buffer_fill) /
452             ((double)cb->send_buffer_size));
453
454   /* Check if we have enough space for this command. */
455   pthread_mutex_unlock(&cb->send_lock);
456
457   return 0;
458 } /* }}} int wh_write_json */
459
460 static int wh_write_kairosdb(const data_set_t *ds,
461                              const value_list_t *vl, /* {{{ */
462                              wh_callback_t *cb) {
463   int status;
464
465   pthread_mutex_lock(&cb->send_lock);
466
467   if (cb->curl == NULL) {
468     status = wh_callback_init(cb);
469     if (status != 0) {
470       ERROR("write_http plugin: wh_callback_init failed.");
471       pthread_mutex_unlock(&cb->send_lock);
472       return -1;
473     }
474   }
475
476   status = format_kairosdb_value_list(
477       cb->send_buffer, &cb->send_buffer_fill, &cb->send_buffer_free, ds, vl,
478       cb->store_rates, (char const *const *)http_attrs, http_attrs_num,
479       cb->data_ttl);
480   if (status == -ENOMEM) {
481     status = wh_flush_nolock(/* timeout = */ 0, cb);
482     if (status != 0) {
483       wh_reset_buffer(cb);
484       pthread_mutex_unlock(&cb->send_lock);
485       return status;
486     }
487
488     status = format_kairosdb_value_list(
489         cb->send_buffer, &cb->send_buffer_fill, &cb->send_buffer_free, ds, vl,
490         cb->store_rates, (char const *const *)http_attrs, http_attrs_num,
491         cb->data_ttl);
492   }
493   if (status != 0) {
494     pthread_mutex_unlock(&cb->send_lock);
495     return status;
496   }
497
498   DEBUG("write_http plugin: <%s> buffer %zu/%zu (%g%%)", cb->location,
499         cb->send_buffer_fill, cb->send_buffer_size,
500         100.0 * ((double)cb->send_buffer_fill) /
501             ((double)cb->send_buffer_size));
502
503   /* Check if we have enough space for this command. */
504   pthread_mutex_unlock(&cb->send_lock);
505
506   return 0;
507 } /* }}} int wh_write_kairosdb */
508
509 static int wh_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
510                     user_data_t *user_data) {
511   wh_callback_t *cb;
512   int status;
513
514   if (user_data == NULL)
515     return -EINVAL;
516
517   cb = user_data->data;
518   assert(cb->send_metrics);
519
520   switch (cb->format) {
521   case WH_FORMAT_JSON:
522     status = wh_write_json(ds, vl, cb);
523     break;
524   case WH_FORMAT_KAIROSDB:
525     status = wh_write_kairosdb(ds, vl, cb);
526     break;
527   default:
528     status = wh_write_command(ds, vl, cb);
529     break;
530   }
531   return status;
532 } /* }}} int wh_write */
533
534 static int wh_notify(notification_t const *n, user_data_t *ud) /* {{{ */
535 {
536   wh_callback_t *cb;
537   char alert[4096];
538   int status;
539
540   if ((ud == NULL) || (ud->data == NULL))
541     return EINVAL;
542
543   cb = ud->data;
544   assert(cb->send_notifications);
545
546   status = format_json_notification(alert, sizeof(alert), n);
547   if (status != 0) {
548     ERROR("write_http plugin: formatting notification failed");
549     return status;
550   }
551
552   pthread_mutex_lock(&cb->send_lock);
553   if (wh_callback_init(cb) != 0) {
554     ERROR("write_http plugin: wh_callback_init failed.");
555     pthread_mutex_unlock(&cb->send_lock);
556     return -1;
557   }
558
559   status = wh_post_nolock(cb, alert);
560   pthread_mutex_unlock(&cb->send_lock);
561
562   return status;
563 } /* }}} int wh_notify */
564
565 static int config_set_format(wh_callback_t *cb, /* {{{ */
566                              oconfig_item_t *ci) {
567   char *string;
568
569   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
570     WARNING("write_http plugin: The `%s' config option "
571             "needs exactly one string argument.",
572             ci->key);
573     return -1;
574   }
575
576   string = ci->values[0].value.string;
577   if (strcasecmp("Command", string) == 0)
578     cb->format = WH_FORMAT_COMMAND;
579   else if (strcasecmp("JSON", string) == 0)
580     cb->format = WH_FORMAT_JSON;
581   else if (strcasecmp("KAIROSDB", string) == 0)
582     cb->format = WH_FORMAT_KAIROSDB;
583   else {
584     ERROR("write_http plugin: Invalid format string: %s", string);
585     return -1;
586   }
587
588   return 0;
589 } /* }}} int config_set_format */
590
591 static int wh_config_append_string(const char *name,
592                                    struct curl_slist **dest, /* {{{ */
593                                    oconfig_item_t *ci) {
594   struct curl_slist *temp = NULL;
595   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
596     WARNING("write_http plugin: `%s' needs exactly one string argument.", name);
597     return -1;
598   }
599
600   temp = curl_slist_append(*dest, ci->values[0].value.string);
601   if (temp == NULL)
602     return -1;
603
604   *dest = temp;
605
606   return 0;
607 } /* }}} int wh_config_append_string */
608
609 static int wh_config_node(oconfig_item_t *ci) /* {{{ */
610 {
611   wh_callback_t *cb;
612   int buffer_size = 0;
613   char callback_name[DATA_MAX_NAME_LEN];
614   int status = 0;
615
616   cb = calloc(1, sizeof(*cb));
617   if (cb == NULL) {
618     ERROR("write_http plugin: calloc failed.");
619     return -1;
620   }
621   cb->verify_peer = 1;
622   cb->verify_host = 1;
623   cb->format = WH_FORMAT_COMMAND;
624   cb->sslversion = CURL_SSLVERSION_DEFAULT;
625   cb->low_speed_limit = 0;
626   cb->timeout = 0;
627   cb->log_http_error = 0;
628   cb->headers = NULL;
629   cb->send_metrics = 1;
630   cb->send_notifications = 0;
631   cb->data_ttl = 0;
632
633   pthread_mutex_init(&cb->send_lock, /* attr = */ NULL);
634
635   cf_util_get_string(ci, &cb->name);
636
637   /* FIXME: Remove this legacy mode in version 6. */
638   if (strcasecmp("URL", ci->key) == 0)
639     cf_util_get_string(ci, &cb->location);
640
641   for (int i = 0; i < ci->children_num; i++) {
642     oconfig_item_t *child = ci->children + i;
643
644     if (strcasecmp("URL", child->key) == 0)
645       status = cf_util_get_string(child, &cb->location);
646     else if (strcasecmp("User", child->key) == 0)
647       status = cf_util_get_string(child, &cb->user);
648     else if (strcasecmp("Password", child->key) == 0)
649       status = cf_util_get_string(child, &cb->pass);
650     else if (strcasecmp("VerifyPeer", child->key) == 0)
651       status = cf_util_get_boolean(child, &cb->verify_peer);
652     else if (strcasecmp("VerifyHost", child->key) == 0)
653       status = cf_util_get_boolean(child, &cb->verify_host);
654     else if (strcasecmp("CACert", child->key) == 0)
655       status = cf_util_get_string(child, &cb->cacert);
656     else if (strcasecmp("CAPath", child->key) == 0)
657       status = cf_util_get_string(child, &cb->capath);
658     else if (strcasecmp("ClientKey", child->key) == 0)
659       status = cf_util_get_string(child, &cb->clientkey);
660     else if (strcasecmp("ClientCert", child->key) == 0)
661       status = cf_util_get_string(child, &cb->clientcert);
662     else if (strcasecmp("ClientKeyPass", child->key) == 0)
663       status = cf_util_get_string(child, &cb->clientkeypass);
664     else if (strcasecmp("SSLVersion", child->key) == 0) {
665       char *value = NULL;
666
667       status = cf_util_get_string(child, &value);
668       if (status != 0)
669         break;
670
671       if (value == NULL || strcasecmp("default", value) == 0)
672         cb->sslversion = CURL_SSLVERSION_DEFAULT;
673       else if (strcasecmp("SSLv2", value) == 0)
674         cb->sslversion = CURL_SSLVERSION_SSLv2;
675       else if (strcasecmp("SSLv3", value) == 0)
676         cb->sslversion = CURL_SSLVERSION_SSLv3;
677       else if (strcasecmp("TLSv1", value) == 0)
678         cb->sslversion = CURL_SSLVERSION_TLSv1;
679 #if (LIBCURL_VERSION_MAJOR > 7) ||                                             \
680     (LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR >= 34)
681       else if (strcasecmp("TLSv1_0", value) == 0)
682         cb->sslversion = CURL_SSLVERSION_TLSv1_0;
683       else if (strcasecmp("TLSv1_1", value) == 0)
684         cb->sslversion = CURL_SSLVERSION_TLSv1_1;
685       else if (strcasecmp("TLSv1_2", value) == 0)
686         cb->sslversion = CURL_SSLVERSION_TLSv1_2;
687 #endif
688       else {
689         ERROR("write_http plugin: Invalid SSLVersion "
690               "option: %s.",
691               value);
692         status = EINVAL;
693       }
694
695       sfree(value);
696     } else if (strcasecmp("Format", child->key) == 0)
697       status = config_set_format(cb, child);
698     else if (strcasecmp("Metrics", child->key) == 0)
699       cf_util_get_boolean(child, &cb->send_metrics);
700     else if (strcasecmp("Notifications", child->key) == 0)
701       cf_util_get_boolean(child, &cb->send_notifications);
702     else if (strcasecmp("StoreRates", child->key) == 0)
703       status = cf_util_get_boolean(child, &cb->store_rates);
704     else if (strcasecmp("BufferSize", child->key) == 0)
705       status = cf_util_get_int(child, &buffer_size);
706     else if (strcasecmp("LowSpeedLimit", child->key) == 0)
707       status = cf_util_get_int(child, &cb->low_speed_limit);
708     else if (strcasecmp("Timeout", child->key) == 0)
709       status = cf_util_get_int(child, &cb->timeout);
710     else if (strcasecmp("LogHttpError", child->key) == 0)
711       status = cf_util_get_boolean(child, &cb->log_http_error);
712     else if (strcasecmp("Header", child->key) == 0)
713       status = wh_config_append_string("Header", &cb->headers, child);
714     else if (strcasecmp("Attribute", child->key) == 0) {
715       char *key = NULL;
716       char *val = NULL;
717
718       if (child->values_num != 2) {
719         WARNING("write_http plugin: Attribute need both a key and a value.");
720         break;
721       }
722       if (child->values[0].type != OCONFIG_TYPE_STRING ||
723           child->values[1].type != OCONFIG_TYPE_STRING) {
724         WARNING("write_http plugin: Attribute needs string arguments.");
725         break;
726       }
727       if ((key = strdup(child->values[0].value.string)) == NULL) {
728         WARNING("cannot allocate memory for attribute key.");
729         break;
730       }
731       if ((val = strdup(child->values[1].value.string)) == NULL) {
732         WARNING("cannot allocate memory for attribute value.");
733         sfree(key);
734         break;
735       }
736       strarray_add(&http_attrs, &http_attrs_num, key);
737       strarray_add(&http_attrs, &http_attrs_num, val);
738       DEBUG("write_http plugin: got attribute: %s => %s", key, val);
739       sfree(key);
740       sfree(val);
741     } else if (strcasecmp("TTL", child->key) == 0) {
742       status = cf_util_get_int(child, &cb->data_ttl);
743     } else {
744       ERROR("write_http plugin: Invalid configuration "
745             "option: %s.",
746             child->key);
747       status = EINVAL;
748     }
749
750     if (status != 0)
751       break;
752   }
753
754   if (status != 0) {
755     wh_callback_free(cb);
756     return status;
757   }
758
759   if (cb->location == NULL) {
760     ERROR("write_http plugin: no URL defined for instance '%s'", cb->name);
761     wh_callback_free(cb);
762     return -1;
763   }
764
765   if (!cb->send_metrics && !cb->send_notifications) {
766     ERROR("write_http plugin: Neither metrics nor notifications "
767           "are enabled for \"%s\".",
768           cb->name);
769     wh_callback_free(cb);
770     return -1;
771   }
772
773   if (cb->low_speed_limit > 0)
774     cb->low_speed_time = CDTIME_T_TO_TIME_T(plugin_get_interval());
775
776   /* Determine send_buffer_size. */
777   cb->send_buffer_size = WRITE_HTTP_DEFAULT_BUFFER_SIZE;
778   if (buffer_size >= 1024)
779     cb->send_buffer_size = (size_t)buffer_size;
780   else if (buffer_size != 0)
781     ERROR("write_http plugin: Ignoring invalid BufferSize setting (%d).",
782           buffer_size);
783
784   /* Allocate the buffer. */
785   cb->send_buffer = malloc(cb->send_buffer_size);
786   if (cb->send_buffer == NULL) {
787     ERROR("write_http plugin: malloc(%zu) failed.", cb->send_buffer_size);
788     wh_callback_free(cb);
789     return -1;
790   }
791   /* Nulls the buffer and sets ..._free and ..._fill. */
792   wh_reset_buffer(cb);
793
794   snprintf(callback_name, sizeof(callback_name), "write_http/%s", cb->name);
795   DEBUG("write_http: Registering write callback '%s' with URL '%s'",
796         callback_name, cb->location);
797
798   user_data_t user_data = {
799       .data = cb, .free_func = wh_callback_free,
800   };
801
802   if (cb->send_metrics) {
803     plugin_register_write(callback_name, wh_write, &user_data);
804     user_data.free_func = NULL;
805
806     plugin_register_flush(callback_name, wh_flush, &user_data);
807   }
808
809   if (cb->send_notifications) {
810     plugin_register_notification(callback_name, wh_notify, &user_data);
811     user_data.free_func = NULL;
812   }
813
814   return 0;
815 } /* }}} int wh_config_node */
816
817 static int wh_config(oconfig_item_t *ci) /* {{{ */
818 {
819   for (int i = 0; i < ci->children_num; i++) {
820     oconfig_item_t *child = ci->children + i;
821
822     if (strcasecmp("Node", child->key) == 0)
823       wh_config_node(child);
824     /* FIXME: Remove this legacy mode in version 6. */
825     else if (strcasecmp("URL", child->key) == 0) {
826       WARNING("write_http plugin: Legacy <URL> block found. "
827               "Please use <Node> instead.");
828       wh_config_node(child);
829     } else {
830       ERROR("write_http plugin: Invalid configuration "
831             "option: %s.",
832             child->key);
833     }
834   }
835
836   return 0;
837 } /* }}} int wh_config */
838
839 static int wh_init(void) /* {{{ */
840 {
841   /* Call this while collectd is still single-threaded to avoid
842    * initialization issues in libgcrypt. */
843   curl_global_init(CURL_GLOBAL_SSL);
844   return 0;
845 } /* }}} int wh_init */
846
847 void module_register(void) /* {{{ */
848 {
849   plugin_register_complex_config("write_http", wh_config);
850   plugin_register_init("write_http", wh_init);
851 } /* }}} void module_register */