Debian Codegraph @

src/openldap.c

raw
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 "plugin.h"
32 #include "utils/common/common.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 ssnprintf(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 ssnprintf(typeinst, sizeof(typeinst), "bdbdncache-%s",
320 nc_data.bv_val);
321 cldap_submit_gauge("cache_size", typeinst, atoll(olmbdb_data.bv_val),
322 st);
323 ldap_value_free_len(olmbdb_list);
324 }
325
326 if ((olmbdb_list = ldap_get_values_len(st->ld, e, "olmBDBIDLCache")) !=
327 NULL) {
328 olmbdb_data = *olmbdb_list[0];
329 ssnprintf(typeinst, sizeof(typeinst), "bdbidlcache-%s",
330 nc_data.bv_val);
331 cldap_submit_gauge("cache_size", typeinst, atoll(olmbdb_data.bv_val),
332 st);
333 ldap_value_free_len(olmbdb_list);
334 }
335
336 ldap_value_free_len(nc_list);
337 } else if (strcmp(dn, "cn=Bytes,cn=Statistics,cn=Monitor") == 0) {
338 cldap_submit_derive("derive", "statistics-bytes", counter, st);
339 } else if (strcmp(dn, "cn=PDU,cn=Statistics,cn=Monitor") == 0) {
340 cldap_submit_derive("derive", "statistics-pdu", counter, st);
341 } else if (strcmp(dn, "cn=Entries,cn=Statistics,cn=Monitor") == 0) {
342 cldap_submit_derive("derive", "statistics-entries", counter, st);
343 } else if (strcmp(dn, "cn=Referrals,cn=Statistics,cn=Monitor") == 0) {
344 cldap_submit_derive("derive", "statistics-referrals", counter, st);
345 } else if (strcmp(dn, "cn=Open,cn=Threads,cn=Monitor") == 0) {
346 cldap_submit_gauge("threads", "threads-open", info, st);
347 } else if (strcmp(dn, "cn=Starting,cn=Threads,cn=Monitor") == 0) {
348 cldap_submit_gauge("threads", "threads-starting", info, st);
349 } else if (strcmp(dn, "cn=Active,cn=Threads,cn=Monitor") == 0) {
350 cldap_submit_gauge("threads", "threads-active", info, st);
351 } else if (strcmp(dn, "cn=Pending,cn=Threads,cn=Monitor") == 0) {
352 cldap_submit_gauge("threads", "threads-pending", info, st);
353 } else if (strcmp(dn, "cn=Backload,cn=Threads,cn=Monitor") == 0) {
354 cldap_submit_gauge("threads", "threads-backload", info, st);
355 } else if (strcmp(dn, "cn=Read,cn=Waiters,cn=Monitor") == 0) {
356 cldap_submit_derive("derive", "waiters-read", counter, st);
357 } else if (strcmp(dn, "cn=Write,cn=Waiters,cn=Monitor") == 0) {
358 cldap_submit_derive("derive", "waiters-write", counter, st);
359 }
360
361 ldap_value_free_len(counter_list);
362 ldap_value_free_len(opc_list);
363 ldap_value_free_len(opi_list);
364 ldap_value_free_len(info_list);
365 }
366
367 ldap_memfree(dn);
368 }
369
370 ldap_msgfree(result);
371 return 0;
372 } /* }}} int cldap_read_host */
373
374 /* Configuration handling functions {{{
375 *
376 * <Plugin ldap>
377 * <Instance "plugin_instance1">
378 * URL "ldap://localhost"
379 * ...
380 * </Instance>
381 * </Plugin>
382 */
383
384 static int cldap_config_add(oconfig_item_t *ci) /* {{{ */
385 {
386 cldap_t *st;
387 int status;
388
389 st = calloc(1, sizeof(*st));
390 if (st == NULL) {
391 ERROR("openldap plugin: calloc failed.");
392 return -1;
393 }
394
395 status = cf_util_get_string(ci, &st->name);
396 if (status != 0) {
397 sfree(st);
398 return status;
399 }
400
401 st->starttls = false;
402 st->timeout = (long)CDTIME_T_TO_TIME_T(plugin_get_interval());
403 st->verifyhost = true;
404 st->version = LDAP_VERSION3;
405
406 for (int i = 0; i < ci->children_num; i++) {
407 oconfig_item_t *child = ci->children + i;
408
409 if (strcasecmp("BindDN", child->key) == 0)
410 status = cf_util_get_string(child, &st->binddn);
411 else if (strcasecmp("Password", child->key) == 0)
412 status = cf_util_get_string(child, &st->password);
413 else if (strcasecmp("CACert", child->key) == 0)
414 status = cf_util_get_string(child, &st->cacert);
415 else if (strcasecmp("StartTLS", child->key) == 0)
416 status = cf_util_get_boolean(child, &st->starttls);
417 else if (strcasecmp("Timeout", child->key) == 0)
418 status = cf_util_get_int(child, &st->timeout);
419 else if (strcasecmp("URL", child->key) == 0)
420 status = cf_util_get_string(child, &st->url);
421 else if (strcasecmp("VerifyHost", child->key) == 0)
422 status = cf_util_get_boolean(child, &st->verifyhost);
423 else if (strcasecmp("Version", child->key) == 0)
424 status = cf_util_get_int(child, &st->version);
425 else {
426 WARNING("openldap plugin: Option `%s' not allowed here.", child->key);
427 status = -1;
428 }
429
430 if (status != 0)
431 break;
432 }
433
434 /* Check if struct is complete.. */
435 if ((status == 0) && (st->url == NULL)) {
436 ERROR("openldap plugin: Instance `%s': "
437 "No URL has been configured.",
438 st->name);
439 status = -1;
440 }
441
442 /* Check if URL is valid */
443 if ((status == 0) && (st->url != NULL)) {
444 LDAPURLDesc *ludpp;
445
446 if (ldap_url_parse(st->url, &ludpp) != 0) {
447 ERROR("openldap plugin: Instance `%s': "
448 "Invalid URL: `%s'",
449 st->name, st->url);
450 status = -1;
451 }
452
453 if ((status == 0) && (ludpp->lud_host != NULL))
454 st->host = strdup(ludpp->lud_host);
455
456 ldap_free_urldesc(ludpp);
457 }
458
459 if (status != 0) {
460 cldap_free(st);
461 return -1;
462 }
463
464 char callback_name[3 * DATA_MAX_NAME_LEN] = {0};
465
466 ssnprintf(callback_name, sizeof(callback_name), "openldap/%s/%s",
467 (st->host != NULL) ? st->host : hostname_g,
468 (st->name != NULL) ? st->name : "default");
469
470 return plugin_register_complex_read(/* group = */ NULL,
471 /* name = */ callback_name,
472 /* callback = */ cldap_read_host,
473 /* interval = */ 0,
474 &(user_data_t){
475 .data = st,
476 .free_func = cldap_free,
477 });
478 } /* }}} int cldap_config_add */
479
480 static int cldap_config(oconfig_item_t *ci) /* {{{ */
481 {
482 int status = 0;
483
484 for (int i = 0; i < ci->children_num; i++) {
485 oconfig_item_t *child = ci->children + i;
486
487 if (strcasecmp("Instance", child->key) == 0)
488 cldap_config_add(child);
489 else
490 WARNING("openldap plugin: The configuration option "
491 "\"%s\" is not allowed here. Did you "
492 "forget to add an <Instance /> block "
493 "around the configuration?",
494 child->key);
495 } /* for (ci->children) */
496
497 return status;
498 } /* }}} int cldap_config */
499
500 /* }}} End of configuration handling functions */
501
502 static int cldap_init(void) /* {{{ */
503 {
504 /* Initialize LDAP library while still single-threaded as recommended in
505 * ldap_initialize(3) */
506 int debug_level;
507 ldap_get_option(NULL, LDAP_OPT_DEBUG_LEVEL, &debug_level);
508 return 0;
509 } /* }}} int cldap_init */
510
511 void module_register(void) /* {{{ */
512 {
513 plugin_register_complex_config("openldap", cldap_config);
514 plugin_register_init("openldap", cldap_init);
515 } /* }}} void module_register */
516
517 #if defined(__APPLE__)
518 #pragma clang diagnostic pop
519 #endif