utils_ovs: fix resource leaks
[collectd.git] / src / apache.c
1 /**
2  * collectd - src/apache.c
3  * Copyright (C) 2006-2010  Florian octo Forster
4  * Copyright (C) 2007       Florent EppO Monbillard
5  * Copyright (C) 2009       Amit Gupta
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  *   Florent EppO Monbillard <eppo at darox.net>
23  *   - connections/lighttpd extension
24  *   Amit Gupta <amit.gupta221 at gmail.com>
25  **/
26
27 #include "collectd.h"
28
29 #include "common.h"
30 #include "plugin.h"
31
32 #include <curl/curl.h>
33
34 enum server_enum { APACHE = 0, LIGHTTPD };
35
36 struct apache_s {
37   int server_type;
38   char *name;
39   char *host;
40   char *url;
41   char *user;
42   char *pass;
43   _Bool verify_peer;
44   _Bool verify_host;
45   char *cacert;
46   char *ssl_ciphers;
47   char *server; /* user specific server type */
48   char *apache_buffer;
49   char apache_curl_error[CURL_ERROR_SIZE];
50   size_t apache_buffer_size;
51   size_t apache_buffer_fill;
52   int timeout;
53   CURL *curl;
54 }; /* apache_s */
55
56 typedef struct apache_s apache_t;
57
58 /* TODO: Remove this prototype */
59 static int apache_read_host(user_data_t *user_data);
60
61 static void apache_free(void *arg) {
62   apache_t *st = arg;
63
64   if (st == NULL)
65     return;
66
67   sfree(st->name);
68   sfree(st->host);
69   sfree(st->url);
70   sfree(st->user);
71   sfree(st->pass);
72   sfree(st->cacert);
73   sfree(st->ssl_ciphers);
74   sfree(st->server);
75   sfree(st->apache_buffer);
76   if (st->curl) {
77     curl_easy_cleanup(st->curl);
78     st->curl = NULL;
79   }
80   sfree(st);
81 } /* apache_free */
82
83 static size_t apache_curl_callback(void *buf, size_t size, size_t nmemb,
84                                    void *user_data) {
85   size_t len = size * nmemb;
86   apache_t *st;
87
88   st = user_data;
89   if (st == NULL) {
90     ERROR("apache plugin: apache_curl_callback: "
91           "user_data pointer is NULL.");
92     return 0;
93   }
94
95   if (len == 0)
96     return len;
97
98   if ((st->apache_buffer_fill + len) >= st->apache_buffer_size) {
99     char *temp;
100
101     temp = realloc(st->apache_buffer, st->apache_buffer_fill + len + 1);
102     if (temp == NULL) {
103       ERROR("apache plugin: realloc failed.");
104       return 0;
105     }
106     st->apache_buffer = temp;
107     st->apache_buffer_size = st->apache_buffer_fill + len + 1;
108   }
109
110   memcpy(st->apache_buffer + st->apache_buffer_fill, (char *)buf, len);
111   st->apache_buffer_fill += len;
112   st->apache_buffer[st->apache_buffer_fill] = 0;
113
114   return len;
115 } /* int apache_curl_callback */
116
117 static size_t apache_header_callback(void *buf, size_t size, size_t nmemb,
118                                      void *user_data) {
119   size_t len = size * nmemb;
120   apache_t *st;
121
122   st = user_data;
123   if (st == NULL) {
124     ERROR("apache plugin: apache_header_callback: "
125           "user_data pointer is NULL.");
126     return 0;
127   }
128
129   if (len == 0)
130     return len;
131
132   /* look for the Server header */
133   if (strncasecmp(buf, "Server: ", strlen("Server: ")) != 0)
134     return len;
135
136   if (strstr(buf, "Apache") != NULL)
137     st->server_type = APACHE;
138   else if (strstr(buf, "lighttpd") != NULL)
139     st->server_type = LIGHTTPD;
140   else if (strstr(buf, "IBM_HTTP_Server") != NULL)
141     st->server_type = APACHE;
142   else {
143     const char *hdr = buf;
144
145     hdr += strlen("Server: ");
146     NOTICE("apache plugin: Unknown server software: %s", hdr);
147   }
148
149   return len;
150 } /* apache_header_callback */
151
152 /* Configuration handling functiions
153  * <Plugin apache>
154  *   <Instance "instance_name">
155  *     URL ...
156  *   </Instance>
157  *   URL ...
158  * </Plugin>
159  */
160 static int config_add(oconfig_item_t *ci) {
161   apache_t *st;
162   int status;
163
164   st = calloc(1, sizeof(*st));
165   if (st == NULL) {
166     ERROR("apache plugin: calloc failed.");
167     return -1;
168   }
169
170   st->timeout = -1;
171
172   status = cf_util_get_string(ci, &st->name);
173   if (status != 0) {
174     sfree(st);
175     return status;
176   }
177   assert(st->name != NULL);
178
179   for (int i = 0; i < ci->children_num; i++) {
180     oconfig_item_t *child = ci->children + i;
181
182     if (strcasecmp("URL", child->key) == 0)
183       status = cf_util_get_string(child, &st->url);
184     else if (strcasecmp("Host", child->key) == 0)
185       status = cf_util_get_string(child, &st->host);
186     else if (strcasecmp("User", child->key) == 0)
187       status = cf_util_get_string(child, &st->user);
188     else if (strcasecmp("Password", child->key) == 0)
189       status = cf_util_get_string(child, &st->pass);
190     else if (strcasecmp("VerifyPeer", child->key) == 0)
191       status = cf_util_get_boolean(child, &st->verify_peer);
192     else if (strcasecmp("VerifyHost", child->key) == 0)
193       status = cf_util_get_boolean(child, &st->verify_host);
194     else if (strcasecmp("CACert", child->key) == 0)
195       status = cf_util_get_string(child, &st->cacert);
196     else if (strcasecmp("SSLCiphers", child->key) == 0)
197       status = cf_util_get_string(child, &st->ssl_ciphers);
198     else if (strcasecmp("Server", child->key) == 0)
199       status = cf_util_get_string(child, &st->server);
200     else if (strcasecmp("Timeout", child->key) == 0)
201       status = cf_util_get_int(child, &st->timeout);
202     else {
203       WARNING("apache plugin: Option `%s' not allowed here.", child->key);
204       status = -1;
205     }
206
207     if (status != 0)
208       break;
209   }
210
211   /* Check if struct is complete.. */
212   if ((status == 0) && (st->url == NULL)) {
213     ERROR("apache plugin: Instance `%s': "
214           "No URL has been configured.",
215           st->name);
216     status = -1;
217   }
218
219   if (status != 0) {
220     apache_free(st);
221     return -1;
222   }
223
224   char callback_name[3 * DATA_MAX_NAME_LEN];
225
226   snprintf(callback_name, sizeof(callback_name), "apache/%s/%s",
227            (st->host != NULL) ? st->host : hostname_g,
228            (st->name != NULL) ? st->name : "default");
229
230   return plugin_register_complex_read(
231       /* group = */ NULL,
232       /* name      = */ callback_name,
233       /* callback  = */ apache_read_host,
234       /* interval  = */ 0,
235       &(user_data_t){
236           .data = st, .free_func = apache_free,
237       });
238 } /* int config_add */
239
240 static int config(oconfig_item_t *ci) {
241   int status = 0;
242
243   for (int i = 0; i < ci->children_num; i++) {
244     oconfig_item_t *child = ci->children + i;
245
246     if (strcasecmp("Instance", child->key) == 0)
247       config_add(child);
248     else
249       WARNING("apache plugin: The configuration option "
250               "\"%s\" is not allowed here. Did you "
251               "forget to add an <Instance /> block "
252               "around the configuration?",
253               child->key);
254   } /* for (ci->children) */
255
256   return status;
257 } /* int config */
258
259 /* initialize curl for each host */
260 static int init_host(apache_t *st) /* {{{ */
261 {
262   assert(st->url != NULL);
263   /* (Assured by `config_add') */
264
265   if (st->curl != NULL) {
266     curl_easy_cleanup(st->curl);
267     st->curl = NULL;
268   }
269
270   if ((st->curl = curl_easy_init()) == NULL) {
271     ERROR("apache plugin: init_host: `curl_easy_init' failed.");
272     return -1;
273   }
274
275   curl_easy_setopt(st->curl, CURLOPT_NOSIGNAL, 1L);
276   curl_easy_setopt(st->curl, CURLOPT_WRITEFUNCTION, apache_curl_callback);
277   curl_easy_setopt(st->curl, CURLOPT_WRITEDATA, st);
278
279   /* not set as yet if the user specified string doesn't match apache or
280    * lighttpd, then ignore it. Headers will be parsed to find out the
281    * server type */
282   st->server_type = -1;
283
284   if (st->server != NULL) {
285     if (strcasecmp(st->server, "apache") == 0)
286       st->server_type = APACHE;
287     else if (strcasecmp(st->server, "lighttpd") == 0)
288       st->server_type = LIGHTTPD;
289     else if (strcasecmp(st->server, "ibm_http_server") == 0)
290       st->server_type = APACHE;
291     else
292       WARNING("apache plugin: Unknown `Server' setting: %s", st->server);
293   }
294
295   /* if not found register a header callback to determine the server_type */
296   if (st->server_type == -1) {
297     curl_easy_setopt(st->curl, CURLOPT_HEADERFUNCTION, apache_header_callback);
298     curl_easy_setopt(st->curl, CURLOPT_WRITEHEADER, st);
299   }
300
301   curl_easy_setopt(st->curl, CURLOPT_USERAGENT, COLLECTD_USERAGENT);
302   curl_easy_setopt(st->curl, CURLOPT_ERRORBUFFER, st->apache_curl_error);
303
304   if (st->user != NULL) {
305 #ifdef HAVE_CURLOPT_USERNAME
306     curl_easy_setopt(st->curl, CURLOPT_USERNAME, st->user);
307     curl_easy_setopt(st->curl, CURLOPT_PASSWORD,
308                      (st->pass == NULL) ? "" : st->pass);
309 #else
310     static char credentials[1024];
311     int status;
312
313     status = snprintf(credentials, sizeof(credentials), "%s:%s", st->user,
314                       (st->pass == NULL) ? "" : st->pass);
315     if ((status < 0) || ((size_t)status >= sizeof(credentials))) {
316       ERROR("apache plugin: init_host: Returning an error "
317             "because the credentials have been "
318             "truncated.");
319       curl_easy_cleanup(st->curl);
320       st->curl = NULL;
321       return -1;
322     }
323
324     curl_easy_setopt(st->curl, CURLOPT_USERPWD, credentials);
325 #endif
326   }
327
328   curl_easy_setopt(st->curl, CURLOPT_FOLLOWLOCATION, 1L);
329   curl_easy_setopt(st->curl, CURLOPT_MAXREDIRS, 50L);
330
331   curl_easy_setopt(st->curl, CURLOPT_SSL_VERIFYPEER, (long)st->verify_peer);
332   curl_easy_setopt(st->curl, CURLOPT_SSL_VERIFYHOST, st->verify_host ? 2L : 0L);
333   if (st->cacert != NULL)
334     curl_easy_setopt(st->curl, CURLOPT_CAINFO, st->cacert);
335   if (st->ssl_ciphers != NULL)
336     curl_easy_setopt(st->curl, CURLOPT_SSL_CIPHER_LIST, st->ssl_ciphers);
337
338 #ifdef HAVE_CURLOPT_TIMEOUT_MS
339   if (st->timeout >= 0)
340     curl_easy_setopt(st->curl, CURLOPT_TIMEOUT_MS, (long)st->timeout);
341   else
342     curl_easy_setopt(st->curl, CURLOPT_TIMEOUT_MS,
343                      (long)CDTIME_T_TO_MS(plugin_get_interval()));
344 #endif
345
346   return 0;
347 } /* }}} int init_host */
348
349 static void submit_value(const char *type, const char *type_instance,
350                          value_t value, apache_t *st) {
351   value_list_t vl = VALUE_LIST_INIT;
352
353   vl.values = &value;
354   vl.values_len = 1;
355
356   if (st->host != NULL)
357     sstrncpy(vl.host, st->host, sizeof(vl.host));
358
359   sstrncpy(vl.plugin, "apache", sizeof(vl.plugin));
360   if (st->name != NULL)
361     sstrncpy(vl.plugin_instance, st->name, sizeof(vl.plugin_instance));
362
363   sstrncpy(vl.type, type, sizeof(vl.type));
364   if (type_instance != NULL)
365     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
366
367   plugin_dispatch_values(&vl);
368 } /* void submit_value */
369
370 static void submit_derive(const char *type, const char *type_instance,
371                           derive_t d, apache_t *st) {
372   submit_value(type, type_instance, (value_t){.derive = d}, st);
373 } /* void submit_derive */
374
375 static void submit_gauge(const char *type, const char *type_instance, gauge_t g,
376                          apache_t *st) {
377   submit_value(type, type_instance, (value_t){.gauge = g}, st);
378 } /* void submit_gauge */
379
380 static void submit_scoreboard(char *buf, apache_t *st) {
381   /*
382    * Scoreboard Key:
383    * "_" Waiting for Connection, "S" Starting up,
384    * "R" Reading Request for apache and read-POST for lighttpd,
385    * "W" Sending Reply, "K" Keepalive (read), "D" DNS Lookup,
386    * "C" Closing connection, "L" Logging, "G" Gracefully finishing,
387    * "I" Idle cleanup of worker, "." Open slot with no current process
388    * Lighttpd specific legends -
389    * "E" hard error, "." connect, "h" handle-request,
390    * "q" request-start, "Q" request-end, "s" response-start
391    * "S" response-end, "r" read
392    */
393   long long open = 0LL;
394   long long waiting = 0LL;
395   long long starting = 0LL;
396   long long reading = 0LL;
397   long long sending = 0LL;
398   long long keepalive = 0LL;
399   long long dnslookup = 0LL;
400   long long closing = 0LL;
401   long long logging = 0LL;
402   long long finishing = 0LL;
403   long long idle_cleanup = 0LL;
404
405   /* lighttpd specific */
406   long long hard_error = 0LL;
407   long long lighttpd_read = 0LL;
408   long long handle_request = 0LL;
409   long long request_start = 0LL;
410   long long request_end = 0LL;
411   long long response_start = 0LL;
412   long long response_end = 0LL;
413
414   for (int i = 0; buf[i] != '\0'; i++) {
415     if (buf[i] == '.')
416       open++;
417     else if (buf[i] == '_')
418       waiting++;
419     else if (buf[i] == 'S')
420       starting++;
421     else if (buf[i] == 'R')
422       reading++;
423     else if (buf[i] == 'W')
424       sending++;
425     else if (buf[i] == 'K')
426       keepalive++;
427     else if (buf[i] == 'D')
428       dnslookup++;
429     else if (buf[i] == 'C')
430       closing++;
431     else if (buf[i] == 'L')
432       logging++;
433     else if (buf[i] == 'G')
434       finishing++;
435     else if (buf[i] == 'I')
436       idle_cleanup++;
437     else if (buf[i] == 'r')
438       lighttpd_read++;
439     else if (buf[i] == 'h')
440       handle_request++;
441     else if (buf[i] == 'E')
442       hard_error++;
443     else if (buf[i] == 'q')
444       request_start++;
445     else if (buf[i] == 'Q')
446       request_end++;
447     else if (buf[i] == 's')
448       response_start++;
449     else if (buf[i] == 'S')
450       response_end++;
451   }
452
453   if (st->server_type == APACHE) {
454     submit_gauge("apache_scoreboard", "open", open, st);
455     submit_gauge("apache_scoreboard", "waiting", waiting, st);
456     submit_gauge("apache_scoreboard", "starting", starting, st);
457     submit_gauge("apache_scoreboard", "reading", reading, st);
458     submit_gauge("apache_scoreboard", "sending", sending, st);
459     submit_gauge("apache_scoreboard", "keepalive", keepalive, st);
460     submit_gauge("apache_scoreboard", "dnslookup", dnslookup, st);
461     submit_gauge("apache_scoreboard", "closing", closing, st);
462     submit_gauge("apache_scoreboard", "logging", logging, st);
463     submit_gauge("apache_scoreboard", "finishing", finishing, st);
464     submit_gauge("apache_scoreboard", "idle_cleanup", idle_cleanup, st);
465   } else {
466     submit_gauge("apache_scoreboard", "connect", open, st);
467     submit_gauge("apache_scoreboard", "close", closing, st);
468     submit_gauge("apache_scoreboard", "hard_error", hard_error, st);
469     submit_gauge("apache_scoreboard", "read", lighttpd_read, st);
470     submit_gauge("apache_scoreboard", "read_post", reading, st);
471     submit_gauge("apache_scoreboard", "write", sending, st);
472     submit_gauge("apache_scoreboard", "handle_request", handle_request, st);
473     submit_gauge("apache_scoreboard", "request_start", request_start, st);
474     submit_gauge("apache_scoreboard", "request_end", request_end, st);
475     submit_gauge("apache_scoreboard", "response_start", response_start, st);
476     submit_gauge("apache_scoreboard", "response_end", response_end, st);
477   }
478 }
479
480 static int apache_read_host(user_data_t *user_data) /* {{{ */
481 {
482   char *ptr;
483   char *saveptr;
484   char *line;
485
486   char *fields[4];
487   int fields_num;
488
489   apache_t *st;
490
491   st = user_data->data;
492
493   int status;
494
495   char *content_type;
496   static const char *text_plain = "text/plain";
497
498   assert(st->url != NULL);
499   /* (Assured by `config_add') */
500
501   if (st->curl == NULL) {
502     status = init_host(st);
503     if (status != 0)
504       return -1;
505   }
506   assert(st->curl != NULL);
507
508   st->apache_buffer_fill = 0;
509
510   curl_easy_setopt(st->curl, CURLOPT_URL, st->url);
511
512   if (curl_easy_perform(st->curl) != CURLE_OK) {
513     ERROR("apache: curl_easy_perform failed: %s", st->apache_curl_error);
514     return -1;
515   }
516
517   /* fallback - server_type to apache if not set at this time */
518   if (st->server_type == -1) {
519     WARNING("apache plugin: Unable to determine server software "
520             "automatically. Will assume Apache.");
521     st->server_type = APACHE;
522   }
523
524   status = curl_easy_getinfo(st->curl, CURLINFO_CONTENT_TYPE, &content_type);
525   if ((status == CURLE_OK) && (content_type != NULL) &&
526       (strncasecmp(content_type, text_plain, strlen(text_plain)) != 0)) {
527     WARNING("apache plugin: `Content-Type' response header is not `%s' "
528             "(received: `%s'). Expecting unparseable data. Please check `URL' "
529             "parameter (missing `?auto' suffix ?)",
530             text_plain, content_type);
531   }
532
533   ptr = st->apache_buffer;
534   saveptr = NULL;
535   while ((line = strtok_r(ptr, "\n\r", &saveptr)) != NULL) {
536     ptr = NULL;
537     fields_num = strsplit(line, fields, STATIC_ARRAY_SIZE(fields));
538
539     if (fields_num == 3) {
540       if ((strcmp(fields[0], "Total") == 0) &&
541           (strcmp(fields[1], "Accesses:") == 0))
542         submit_derive("apache_requests", "", atoll(fields[2]), st);
543       else if ((strcmp(fields[0], "Total") == 0) &&
544                (strcmp(fields[1], "kBytes:") == 0))
545         submit_derive("apache_bytes", "", 1024LL * atoll(fields[2]), st);
546     } else if (fields_num == 2) {
547       if (strcmp(fields[0], "Scoreboard:") == 0)
548         submit_scoreboard(fields[1], st);
549       else if ((strcmp(fields[0], "BusyServers:") == 0) /* Apache 1.* */
550                || (strcmp(fields[0], "BusyWorkers:") == 0) /* Apache 2.* */)
551         submit_gauge("apache_connections", NULL, atol(fields[1]), st);
552       else if ((strcmp(fields[0], "IdleServers:") == 0) /* Apache 1.x */
553                || (strcmp(fields[0], "IdleWorkers:") == 0) /* Apache 2.x */)
554         submit_gauge("apache_idle_workers", NULL, atol(fields[1]), st);
555     }
556   }
557
558   st->apache_buffer_fill = 0;
559
560   return 0;
561 } /* }}} int apache_read_host */
562
563 static int apache_init(void) /* {{{ */
564 {
565   /* Call this while collectd is still single-threaded to avoid
566    * initialization issues in libgcrypt. */
567   curl_global_init(CURL_GLOBAL_SSL);
568   return 0;
569 } /* }}} int apache_init */
570
571 void module_register(void) {
572   plugin_register_complex_config("apache", config);
573   plugin_register_init("apache", apache_init);
574 } /* void module_register */