Merge pull request #2796 from elfiesmelfie/feat_ipmi_SEL_ignore_list
[collectd.git] / src / openldap.c
1 /**
2  * collectd - src/openldap.c
3  * Copyright (C) 2011       Kimo Rosenbaum
4  * Copyright (C) 2014-2015  Marc Fournier
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the "Software"),
8  * to deal in the Software without restriction, including without limitation
9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10  * and/or sell copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22  * DEALINGS IN THE SOFTWARE.
23  *
24  * Authors:
25  *   Kimo Rosenbaum <kimor79 at yahoo.com>
26  *   Marc Fournier <marc.fournier at camptocamp.com>
27  **/
28
29 #include "collectd.h"
30
31 #include "common.h"
32 #include "plugin.h"
33
34 #if defined(__APPLE__)
35 #pragma clang diagnostic push
36 #pragma clang diagnostic warning "-Wdeprecated-declarations"
37 #endif
38
39 #include <lber.h>
40 #include <ldap.h>
41
42 struct cldap_s /* {{{ */
43 {
44   char *name;
45
46   char *binddn;
47   char *password;
48   char *cacert;
49   char *host;
50   bool starttls;
51   int timeout;
52   char *url;
53   bool verifyhost;
54   int version;
55
56   LDAP *ld;
57 };
58 typedef struct cldap_s cldap_t; /* }}} */
59
60 static void cldap_free(void *arg) /* {{{ */
61 {
62   cldap_t *st = arg;
63
64   if (st == NULL)
65     return;
66
67   sfree(st->binddn);
68   sfree(st->password);
69   sfree(st->cacert);
70   sfree(st->host);
71   sfree(st->name);
72   sfree(st->url);
73   if (st->ld)
74     ldap_unbind_ext_s(st->ld, NULL, NULL);
75
76   sfree(st);
77 } /* }}} void cldap_free */
78
79 /* initialize ldap for each host */
80 static int cldap_init_host(cldap_t *st) /* {{{ */
81 {
82   int rc;
83
84   if (st->ld) {
85     DEBUG("openldap plugin: Already connected to %s", st->url);
86     return 0;
87   }
88
89   rc = ldap_initialize(&st->ld, st->url);
90   if (rc != LDAP_SUCCESS) {
91     ERROR("openldap plugin: ldap_initialize failed: %s", ldap_err2string(rc));
92     if (st->ld != NULL)
93       ldap_unbind_ext_s(st->ld, NULL, NULL);
94     st->ld = NULL;
95     return (-1);
96   }
97
98   ldap_set_option(st->ld, LDAP_OPT_PROTOCOL_VERSION, &st->version);
99
100   ldap_set_option(st->ld, LDAP_OPT_TIMEOUT,
101                   &(const struct timeval){st->timeout, 0});
102
103   ldap_set_option(st->ld, LDAP_OPT_RESTART, LDAP_OPT_ON);
104
105   if (st->cacert != NULL)
106     ldap_set_option(st->ld, LDAP_OPT_X_TLS_CACERTFILE, st->cacert);
107
108   if (st->verifyhost == false) {
109     int never = LDAP_OPT_X_TLS_NEVER;
110     ldap_set_option(st->ld, LDAP_OPT_X_TLS_REQUIRE_CERT, &never);
111   }
112
113   if (st->starttls) {
114     rc = ldap_start_tls_s(st->ld, NULL, NULL);
115     if (rc != LDAP_SUCCESS) {
116       ERROR("openldap plugin: Failed to start tls on %s: %s", st->url,
117             ldap_err2string(rc));
118       ldap_unbind_ext_s(st->ld, NULL, NULL);
119       st->ld = NULL;
120       return (-1);
121     }
122   }
123
124   struct berval cred;
125   if (st->password != NULL) {
126     cred.bv_val = st->password;
127     cred.bv_len = strlen(st->password);
128   } else {
129     cred.bv_val = "";
130     cred.bv_len = 0;
131   }
132
133   rc = ldap_sasl_bind_s(st->ld, st->binddn, LDAP_SASL_SIMPLE, &cred, NULL, NULL,
134                         NULL);
135   if (rc != LDAP_SUCCESS) {
136     ERROR("openldap plugin: Failed to bind to %s: %s", st->url,
137           ldap_err2string(rc));
138     ldap_unbind_ext_s(st->ld, NULL, NULL);
139     st->ld = NULL;
140     return (-1);
141   } else {
142     DEBUG("openldap plugin: Successfully connected to %s", st->url);
143     return 0;
144   }
145 } /* }}} static cldap_init_host */
146
147 static void cldap_submit_value(const char *type,
148                                const char *type_instance, /* {{{ */
149                                value_t value, cldap_t *st) {
150   value_list_t vl = VALUE_LIST_INIT;
151
152   vl.values = &value;
153   vl.values_len = 1;
154
155   if ((st->host != NULL) && (strcmp("localhost", st->host) != 0))
156     sstrncpy(vl.host, st->host, sizeof(vl.host));
157
158   sstrncpy(vl.plugin, "openldap", sizeof(vl.plugin));
159   if (st->name != NULL)
160     sstrncpy(vl.plugin_instance, st->name, sizeof(vl.plugin_instance));
161
162   sstrncpy(vl.type, type, sizeof(vl.type));
163   if (type_instance != NULL)
164     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
165
166   plugin_dispatch_values(&vl);
167 } /* }}} void cldap_submit_value */
168
169 static void cldap_submit_derive(const char *type,
170                                 const char *type_instance, /* {{{ */
171                                 derive_t d, cldap_t *st) {
172   cldap_submit_value(type, type_instance, (value_t){.derive = d}, st);
173 } /* }}} void cldap_submit_derive */
174
175 static void cldap_submit_gauge(const char *type,
176                                const char *type_instance, /* {{{ */
177                                gauge_t g, cldap_t *st) {
178   cldap_submit_value(type, type_instance, (value_t){.gauge = g}, st);
179 } /* }}} void cldap_submit_gauge */
180
181 static int cldap_read_host(user_data_t *ud) /* {{{ */
182 {
183   cldap_t *st;
184   LDAPMessage *result;
185   char *dn;
186   int rc;
187   int status;
188
189   char *attrs[9] = {
190       "monitorCounter", "monitorOpCompleted", "monitorOpInitiated",
191       "monitoredInfo",  "olmBDBEntryCache",   "olmBDBDNCache",
192       "olmBDBIDLCache", "namingContexts",     NULL};
193
194   if ((ud == NULL) || (ud->data == NULL)) {
195     ERROR("openldap plugin: cldap_read_host: Invalid user data.");
196     return -1;
197   }
198
199   st = (cldap_t *)ud->data;
200
201   status = cldap_init_host(st);
202   if (status != 0)
203     return -1;
204
205   rc = ldap_search_ext_s(st->ld, "cn=Monitor", LDAP_SCOPE_SUBTREE,
206                          "(|(!(cn=* *))(cn=Database*))", attrs, 0, NULL, NULL,
207                          NULL, 0, &result);
208
209   if (rc != LDAP_SUCCESS) {
210     ERROR("openldap plugin: Failed to execute search: %s", ldap_err2string(rc));
211     ldap_msgfree(result);
212     ldap_unbind_ext_s(st->ld, NULL, NULL);
213     st->ld = NULL;
214     return (-1);
215   }
216
217   for (LDAPMessage *e = ldap_first_entry(st->ld, result); e != NULL;
218        e = ldap_next_entry(st->ld, e)) {
219     if ((dn = ldap_get_dn(st->ld, e)) != NULL) {
220       unsigned long long counter = 0;
221       unsigned long long opc = 0;
222       unsigned long long opi = 0;
223       unsigned long long info = 0;
224
225       struct berval counter_data;
226       struct berval opc_data;
227       struct berval opi_data;
228       struct berval info_data;
229       struct berval olmbdb_data;
230       struct berval nc_data;
231
232       struct berval **counter_list;
233       struct berval **opc_list;
234       struct berval **opi_list;
235       struct berval **info_list;
236       struct berval **olmbdb_list;
237       struct berval **nc_list;
238
239       if ((counter_list = ldap_get_values_len(st->ld, e, "monitorCounter")) !=
240           NULL) {
241         counter_data = *counter_list[0];
242         counter = atoll(counter_data.bv_val);
243       }
244
245       if ((opc_list = ldap_get_values_len(st->ld, e, "monitorOpCompleted")) !=
246           NULL) {
247         opc_data = *opc_list[0];
248         opc = atoll(opc_data.bv_val);
249       }
250
251       if ((opi_list = ldap_get_values_len(st->ld, e, "monitorOpInitiated")) !=
252           NULL) {
253         opi_data = *opi_list[0];
254         opi = atoll(opi_data.bv_val);
255       }
256
257       if ((info_list = ldap_get_values_len(st->ld, e, "monitoredInfo")) !=
258           NULL) {
259         info_data = *info_list[0];
260         info = atoll(info_data.bv_val);
261       }
262
263       if (strcmp(dn, "cn=Total,cn=Connections,cn=Monitor") == 0) {
264         cldap_submit_derive("total_connections", NULL, counter, st);
265       } else if (strcmp(dn, "cn=Current,cn=Connections,cn=Monitor") == 0) {
266         cldap_submit_gauge("current_connections", NULL, counter, st);
267       } else if (strcmp(dn, "cn=Operations,cn=Monitor") == 0) {
268         cldap_submit_derive("operations", "completed", opc, st);
269         cldap_submit_derive("operations", "initiated", opi, st);
270       } else if (strcmp(dn, "cn=Bind,cn=Operations,cn=Monitor") == 0) {
271         cldap_submit_derive("operations", "bind-completed", opc, st);
272         cldap_submit_derive("operations", "bind-initiated", opi, st);
273       } else if (strcmp(dn, "cn=UnBind,cn=Operations,cn=Monitor") == 0) {
274         cldap_submit_derive("operations", "unbind-completed", opc, st);
275         cldap_submit_derive("operations", "unbind-initiated", opi, st);
276       } else if (strcmp(dn, "cn=Search,cn=Operations,cn=Monitor") == 0) {
277         cldap_submit_derive("operations", "search-completed", opc, st);
278         cldap_submit_derive("operations", "search-initiated", opi, st);
279       } else if (strcmp(dn, "cn=Compare,cn=Operations,cn=Monitor") == 0) {
280         cldap_submit_derive("operations", "compare-completed", opc, st);
281         cldap_submit_derive("operations", "compare-initiated", opi, st);
282       } else if (strcmp(dn, "cn=Modify,cn=Operations,cn=Monitor") == 0) {
283         cldap_submit_derive("operations", "modify-completed", opc, st);
284         cldap_submit_derive("operations", "modify-initiated", opi, st);
285       } else if (strcmp(dn, "cn=Modrdn,cn=Operations,cn=Monitor") == 0) {
286         cldap_submit_derive("operations", "modrdn-completed", opc, st);
287         cldap_submit_derive("operations", "modrdn-initiated", opi, st);
288       } else if (strcmp(dn, "cn=Add,cn=Operations,cn=Monitor") == 0) {
289         cldap_submit_derive("operations", "add-completed", opc, st);
290         cldap_submit_derive("operations", "add-initiated", opi, st);
291       } else if (strcmp(dn, "cn=Delete,cn=Operations,cn=Monitor") == 0) {
292         cldap_submit_derive("operations", "delete-completed", opc, st);
293         cldap_submit_derive("operations", "delete-initiated", opi, st);
294       } else if (strcmp(dn, "cn=Abandon,cn=Operations,cn=Monitor") == 0) {
295         cldap_submit_derive("operations", "abandon-completed", opc, st);
296         cldap_submit_derive("operations", "abandon-initiated", opi, st);
297       } else if (strcmp(dn, "cn=Extended,cn=Operations,cn=Monitor") == 0) {
298         cldap_submit_derive("operations", "extended-completed", opc, st);
299         cldap_submit_derive("operations", "extended-initiated", opi, st);
300       } else if ((strncmp(dn, "cn=Database", 11) == 0) &&
301                  ((nc_list = ldap_get_values_len(st->ld, e,
302                                                  "namingContexts")) != NULL)) {
303         nc_data = *nc_list[0];
304         char typeinst[DATA_MAX_NAME_LEN];
305
306         if ((olmbdb_list =
307                  ldap_get_values_len(st->ld, e, "olmBDBEntryCache")) != NULL) {
308           olmbdb_data = *olmbdb_list[0];
309           snprintf(typeinst, sizeof(typeinst), "bdbentrycache-%s",
310                    nc_data.bv_val);
311           cldap_submit_gauge("cache_size", typeinst, atoll(olmbdb_data.bv_val),
312                              st);
313           ldap_value_free_len(olmbdb_list);
314         }
315
316         if ((olmbdb_list = ldap_get_values_len(st->ld, e, "olmBDBDNCache")) !=
317             NULL) {
318           olmbdb_data = *olmbdb_list[0];
319           snprintf(typeinst, sizeof(typeinst), "bdbdncache-%s", nc_data.bv_val);
320           cldap_submit_gauge("cache_size", typeinst, atoll(olmbdb_data.bv_val),
321                              st);
322           ldap_value_free_len(olmbdb_list);
323         }
324
325         if ((olmbdb_list = ldap_get_values_len(st->ld, e, "olmBDBIDLCache")) !=
326             NULL) {
327           olmbdb_data = *olmbdb_list[0];
328           snprintf(typeinst, sizeof(typeinst), "bdbidlcache-%s",
329                    nc_data.bv_val);
330           cldap_submit_gauge("cache_size", typeinst, atoll(olmbdb_data.bv_val),
331                              st);
332           ldap_value_free_len(olmbdb_list);
333         }
334
335         ldap_value_free_len(nc_list);
336       } else if (strcmp(dn, "cn=Bytes,cn=Statistics,cn=Monitor") == 0) {
337         cldap_submit_derive("derive", "statistics-bytes", counter, st);
338       } else if (strcmp(dn, "cn=PDU,cn=Statistics,cn=Monitor") == 0) {
339         cldap_submit_derive("derive", "statistics-pdu", counter, st);
340       } else if (strcmp(dn, "cn=Entries,cn=Statistics,cn=Monitor") == 0) {
341         cldap_submit_derive("derive", "statistics-entries", counter, st);
342       } else if (strcmp(dn, "cn=Referrals,cn=Statistics,cn=Monitor") == 0) {
343         cldap_submit_derive("derive", "statistics-referrals", counter, st);
344       } else if (strcmp(dn, "cn=Open,cn=Threads,cn=Monitor") == 0) {
345         cldap_submit_gauge("threads", "threads-open", info, st);
346       } else if (strcmp(dn, "cn=Starting,cn=Threads,cn=Monitor") == 0) {
347         cldap_submit_gauge("threads", "threads-starting", info, st);
348       } else if (strcmp(dn, "cn=Active,cn=Threads,cn=Monitor") == 0) {
349         cldap_submit_gauge("threads", "threads-active", info, st);
350       } else if (strcmp(dn, "cn=Pending,cn=Threads,cn=Monitor") == 0) {
351         cldap_submit_gauge("threads", "threads-pending", info, st);
352       } else if (strcmp(dn, "cn=Backload,cn=Threads,cn=Monitor") == 0) {
353         cldap_submit_gauge("threads", "threads-backload", info, st);
354       } else if (strcmp(dn, "cn=Read,cn=Waiters,cn=Monitor") == 0) {
355         cldap_submit_derive("derive", "waiters-read", counter, st);
356       } else if (strcmp(dn, "cn=Write,cn=Waiters,cn=Monitor") == 0) {
357         cldap_submit_derive("derive", "waiters-write", counter, st);
358       }
359
360       ldap_value_free_len(counter_list);
361       ldap_value_free_len(opc_list);
362       ldap_value_free_len(opi_list);
363       ldap_value_free_len(info_list);
364     }
365
366     ldap_memfree(dn);
367   }
368
369   ldap_msgfree(result);
370   return 0;
371 } /* }}} int cldap_read_host */
372
373 /* Configuration handling functions {{{
374  *
375  * <Plugin ldap>
376  *   <Instance "plugin_instance1">
377  *     URL "ldap://localhost"
378  *     ...
379  *   </Instance>
380  * </Plugin>
381  */
382
383 static int cldap_config_add(oconfig_item_t *ci) /* {{{ */
384 {
385   cldap_t *st;
386   int status;
387
388   st = calloc(1, sizeof(*st));
389   if (st == NULL) {
390     ERROR("openldap plugin: calloc failed.");
391     return -1;
392   }
393
394   status = cf_util_get_string(ci, &st->name);
395   if (status != 0) {
396     sfree(st);
397     return status;
398   }
399
400   st->starttls = false;
401   st->timeout = (long)CDTIME_T_TO_TIME_T(plugin_get_interval());
402   st->verifyhost = true;
403   st->version = LDAP_VERSION3;
404
405   for (int i = 0; i < ci->children_num; i++) {
406     oconfig_item_t *child = ci->children + i;
407
408     if (strcasecmp("BindDN", child->key) == 0)
409       status = cf_util_get_string(child, &st->binddn);
410     else if (strcasecmp("Password", child->key) == 0)
411       status = cf_util_get_string(child, &st->password);
412     else if (strcasecmp("CACert", child->key) == 0)
413       status = cf_util_get_string(child, &st->cacert);
414     else if (strcasecmp("StartTLS", child->key) == 0)
415       status = cf_util_get_boolean(child, &st->starttls);
416     else if (strcasecmp("Timeout", child->key) == 0)
417       status = cf_util_get_int(child, &st->timeout);
418     else if (strcasecmp("URL", child->key) == 0)
419       status = cf_util_get_string(child, &st->url);
420     else if (strcasecmp("VerifyHost", child->key) == 0)
421       status = cf_util_get_boolean(child, &st->verifyhost);
422     else if (strcasecmp("Version", child->key) == 0)
423       status = cf_util_get_int(child, &st->version);
424     else {
425       WARNING("openldap plugin: Option `%s' not allowed here.", child->key);
426       status = -1;
427     }
428
429     if (status != 0)
430       break;
431   }
432
433   /* Check if struct is complete.. */
434   if ((status == 0) && (st->url == NULL)) {
435     ERROR("openldap plugin: Instance `%s': "
436           "No URL has been configured.",
437           st->name);
438     status = -1;
439   }
440
441   /* Check if URL is valid */
442   if ((status == 0) && (st->url != NULL)) {
443     LDAPURLDesc *ludpp;
444
445     if (ldap_url_parse(st->url, &ludpp) != 0) {
446       ERROR("openldap plugin: Instance `%s': "
447             "Invalid URL: `%s'",
448             st->name, st->url);
449       status = -1;
450     }
451
452     if ((status == 0) && (ludpp->lud_host != NULL))
453       st->host = strdup(ludpp->lud_host);
454
455     ldap_free_urldesc(ludpp);
456   }
457
458   if (status != 0) {
459     cldap_free(st);
460     return -1;
461   }
462
463   char callback_name[3 * DATA_MAX_NAME_LEN] = {0};
464
465   snprintf(callback_name, sizeof(callback_name), "openldap/%s/%s",
466            (st->host != NULL) ? st->host : hostname_g,
467            (st->name != NULL) ? st->name : "default");
468
469   return plugin_register_complex_read(/* group = */ NULL,
470                                       /* name      = */ callback_name,
471                                       /* callback  = */ cldap_read_host,
472                                       /* interval  = */ 0,
473                                       &(user_data_t){
474                                           .data = st, .free_func = cldap_free,
475                                       });
476 } /* }}} int cldap_config_add */
477
478 static int cldap_config(oconfig_item_t *ci) /* {{{ */
479 {
480   int status = 0;
481
482   for (int i = 0; i < ci->children_num; i++) {
483     oconfig_item_t *child = ci->children + i;
484
485     if (strcasecmp("Instance", child->key) == 0)
486       cldap_config_add(child);
487     else
488       WARNING("openldap plugin: The configuration option "
489               "\"%s\" is not allowed here. Did you "
490               "forget to add an <Instance /> block "
491               "around the configuration?",
492               child->key);
493   } /* for (ci->children) */
494
495   return status;
496 } /* }}} int cldap_config */
497
498 /* }}} End of configuration handling functions */
499
500 static int cldap_init(void) /* {{{ */
501 {
502   /* Initialize LDAP library while still single-threaded as recommended in
503    * ldap_initialize(3) */
504   int debug_level;
505   ldap_get_option(NULL, LDAP_OPT_DEBUG_LEVEL, &debug_level);
506   return 0;
507 } /* }}} int cldap_init */
508
509 void module_register(void) /* {{{ */
510 {
511   plugin_register_complex_config("openldap", cldap_config);
512   plugin_register_init("openldap", cldap_init);
513 } /* }}} void module_register */
514
515 #if defined(__APPLE__)
516 #pragma clang diagnostic pop
517 #endif