2 * collectd - src/email.c
3 * Copyright (C) 2006-2008 Sebastian Harl
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
24 * Sebastian Harl <sh at tokkee.org>
28 * This plugin communicates with a spam filter, a virus scanner or similar
29 * software using a UNIX socket and a very simple protocol:
31 * e-mail type (e.g. ham, spam, virus, ...) and size
37 * successful spam checks
38 * c:<type1>[,<type2>,...]
48 #include <sys/select.h>
51 /* some systems (e.g. Darwin) seem to not define UNIX_PATH_MAX at all */
53 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *)0)->sun_path)
54 #endif /* UNIX_PATH_MAX */
58 #endif /* HAVE_GRP_H */
60 #define SOCK_PATH LOCALSTATEDIR "/run/" PACKAGE_NAME "-email"
62 #define MAX_CONNS_LIMIT 16384
64 #define log_debug(...) DEBUG("email: "__VA_ARGS__)
65 #define log_err(...) ERROR("email: "__VA_ARGS__)
66 #define log_warn(...) WARNING("email: "__VA_ARGS__)
69 * Private data structures
71 /* linked list of email and check types */
83 /* collector thread control information */
84 typedef struct collector {
87 /* socket descriptor of the current/last connection */
91 /* linked list of pending connections */
93 /* socket to read data from */
96 /* linked list of connections */
108 /* valid configuration file keys */
109 static const char *config_keys[] = {"SocketFile", "SocketGroup", "SocketPerms",
111 static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
113 /* socket configuration */
114 static char *sock_file = NULL;
115 static char *sock_group = NULL;
116 static int sock_perms = S_IRWXU | S_IRWXG;
117 static int max_conns = MAX_CONNS;
119 /* state of the plugin */
120 static int disabled = 0;
122 /* thread managing "client" connections */
123 static pthread_t connector = (pthread_t)0;
124 static int connector_socket = -1;
126 /* tell the collector threads that a new connection is available */
127 static pthread_cond_t conn_available = PTHREAD_COND_INITIALIZER;
129 /* connections that are waiting to be processed */
130 static pthread_mutex_t conns_mutex = PTHREAD_MUTEX_INITIALIZER;
131 static conn_list_t conns;
133 /* tell the connector thread that a collector is available */
134 static pthread_cond_t collector_available = PTHREAD_COND_INITIALIZER;
136 /* collector threads */
137 static collector_t **collectors = NULL;
139 static pthread_mutex_t available_mutex = PTHREAD_MUTEX_INITIALIZER;
140 static int available_collectors;
142 static pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
143 static type_list_t list_count;
144 static type_list_t list_count_copy;
146 static pthread_mutex_t size_mutex = PTHREAD_MUTEX_INITIALIZER;
147 static type_list_t list_size;
148 static type_list_t list_size_copy;
150 static pthread_mutex_t score_mutex = PTHREAD_MUTEX_INITIALIZER;
152 static int score_count;
154 static pthread_mutex_t check_mutex = PTHREAD_MUTEX_INITIALIZER;
155 static type_list_t list_check;
156 static type_list_t list_check_copy;
161 static int email_config(const char *key, const char *value) {
162 if (strcasecmp(key, "SocketFile") == 0) {
163 if (sock_file != NULL)
165 sock_file = sstrdup(value);
166 } else if (strcasecmp(key, "SocketGroup") == 0) {
167 if (sock_group != NULL)
169 sock_group = sstrdup(value);
170 } else if (strcasecmp(key, "SocketPerms") == 0) {
171 /* the user is responsible for providing reasonable values */
172 sock_perms = (int)strtol(value, NULL, 8);
173 } else if (strcasecmp(key, "MaxConns") == 0) {
174 long int tmp = strtol(value, NULL, 0);
177 fprintf(stderr, "email plugin: `MaxConns' was set to invalid "
178 "value %li, will use default %i.\n",
180 ERROR("email plugin: `MaxConns' was set to invalid "
181 "value %li, will use default %i.\n",
183 max_conns = MAX_CONNS;
184 } else if (tmp > MAX_CONNS_LIMIT) {
185 fprintf(stderr, "email plugin: `MaxConns' was set to invalid "
186 "value %li, will use hardcoded limit %i.\n",
187 tmp, MAX_CONNS_LIMIT);
188 ERROR("email plugin: `MaxConns' was set to invalid "
189 "value %li, will use hardcoded limit %i.\n",
190 tmp, MAX_CONNS_LIMIT);
191 max_conns = MAX_CONNS_LIMIT;
193 max_conns = (int)tmp;
199 } /* static int email_config (char *, char *) */
201 /* Increment the value of the given name in the given list by incr. */
202 static void type_list_incr(type_list_t *list, char *name, int incr) {
203 if (list->head == NULL) {
204 list->head = smalloc(sizeof(*list->head));
206 list->head->name = sstrdup(name);
207 list->head->value = incr;
208 list->head->next = NULL;
210 list->tail = list->head;
214 for (ptr = list->head; NULL != ptr; ptr = ptr->next) {
215 if (strcmp(name, ptr->name) == 0)
220 list->tail->next = smalloc(sizeof(*list->tail->next));
221 list->tail = list->tail->next;
223 list->tail->name = sstrdup(name);
224 list->tail->value = incr;
225 list->tail->next = NULL;
231 } /* static void type_list_incr (type_list_t *, char *) */
233 static void *collect(void *arg) {
234 collector_t *this = (collector_t *)arg;
239 pthread_mutex_lock(&conns_mutex);
241 while (conns.head == NULL) {
242 pthread_cond_wait(&conn_available, &conns_mutex);
245 connection = conns.head;
246 conns.head = conns.head->next;
248 if (conns.head == NULL) {
252 pthread_mutex_unlock(&conns_mutex);
254 /* make the socket available to the global
255 * thread and connection management */
256 this->socket = connection->socket;
258 log_debug("collect: handling connection on fd #%i", fileno(this->socket));
261 /* 256 bytes ought to be enough for anybody ;-) */
262 char line[256 + 1]; /* line + '\0' */
266 if (fgets(line, sizeof(line), this->socket) == NULL) {
269 log_err("collect: reading from socket (fd #%i) "
271 fileno(this->socket),
272 sstrerror(errno, errbuf, sizeof(errbuf)));
278 if ((line[len - 1] != '\n') && (line[len - 1] != '\r')) {
279 log_warn("collect: line too long (> %zu characters): "
281 sizeof(line) - 1, line);
283 while (fgets(line, sizeof(line), this->socket) != NULL)
284 if ((line[len - 1] == '\n') || (line[len - 1] == '\r'))
288 if (len < 3) { /* [a-z] ':' '\n' */
294 log_debug("collect: line = '%s'", line);
296 if (line[1] != ':') {
297 log_err("collect: syntax error in line '%s'", line);
301 if (line[0] == 'e') { /* e:<type>:<bytes> */
303 char *type = strtok_r(line + 2, ":", &ptr);
304 char *tmp = strtok_r(NULL, ":", &ptr);
308 log_err("collect: syntax error in line '%s'", line);
314 pthread_mutex_lock(&count_mutex);
315 type_list_incr(&list_count, type, /* increment = */ 1);
316 pthread_mutex_unlock(&count_mutex);
319 pthread_mutex_lock(&size_mutex);
320 type_list_incr(&list_size, type, /* increment = */ bytes);
321 pthread_mutex_unlock(&size_mutex);
323 } else if (line[0] == 's') { /* s:<value> */
324 pthread_mutex_lock(&score_mutex);
325 score = (score * (double)score_count + atof(line + 2)) /
326 (double)(score_count + 1);
328 pthread_mutex_unlock(&score_mutex);
329 } else if (line[0] == 'c') { /* c:<type1>[,<type2>,...] */
330 char *dummy = line + 2;
334 pthread_mutex_lock(&check_mutex);
335 while ((type = strtok_r(dummy, ",", &endptr)) != NULL) {
337 type_list_incr(&list_check, type, /* increment = */ 1);
339 pthread_mutex_unlock(&check_mutex);
341 log_err("collect: unknown type '%c'", line[0]);
345 log_debug("Shutting down connection on fd #%i", fileno(this->socket));
347 fclose(connection->socket);
352 pthread_mutex_lock(&available_mutex);
353 ++available_collectors;
354 pthread_mutex_unlock(&available_mutex);
356 pthread_cond_signal(&collector_available);
359 pthread_exit((void *)0);
361 } /* static void *collect (void *) */
363 static void *open_connection(void __attribute__((unused)) * arg) {
364 const char *path = (NULL == sock_file) ? SOCK_PATH : sock_file;
365 const char *group = (NULL == sock_group) ? COLLECTD_GRP_NAME : sock_group;
367 /* create UNIX socket */
369 if ((connector_socket = socket(PF_UNIX, SOCK_STREAM, 0)) == -1) {
372 log_err("socket() failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
373 pthread_exit((void *)1);
376 struct sockaddr_un addr = {
377 .sun_family = AF_UNIX
379 sstrncpy(addr.sun_path, path, (size_t)(UNIX_PATH_MAX - 1));
382 if (bind(connector_socket, (struct sockaddr *)&addr,
383 offsetof(struct sockaddr_un, sun_path) + strlen(addr.sun_path)) == -1) {
386 close(connector_socket);
387 connector_socket = -1;
388 log_err("bind() failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
389 pthread_exit((void *)1);
393 if (listen(connector_socket, 5) == -1) {
396 close(connector_socket);
397 connector_socket = -1;
398 log_err("listen() failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
399 pthread_exit((void *)1);
407 long int grbuf_size = sysconf(_SC_GETGR_R_SIZE_MAX);
409 grbuf_size = sysconf(_SC_PAGESIZE);
412 char grbuf[grbuf_size];
415 status = getgrnam_r(group, &sg, grbuf, sizeof(grbuf), &grp);
418 log_warn("getgrnam_r (%s) failed: %s", group,
419 sstrerror(status, errbuf, sizeof(errbuf)));
420 } else if (grp == NULL) {
421 log_warn("No such group: `%s'", group);
423 status = chown(path, (uid_t)-1, grp->gr_gid);
426 log_warn("chown (%s, -1, %i) failed: %s", path, (int)grp->gr_gid,
427 sstrerror(errno, errbuf, sizeof(errbuf)));
433 if (chmod(path, sock_perms) != 0) {
435 log_warn("chmod() failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
438 { /* initialize collector threads */
439 pthread_attr_t ptattr;
444 pthread_attr_init(&ptattr);
445 pthread_attr_setdetachstate(&ptattr, PTHREAD_CREATE_DETACHED);
447 available_collectors = max_conns;
449 collectors = smalloc(max_conns * sizeof(*collectors));
451 for (int i = 0; i < max_conns; ++i) {
452 collectors[i] = smalloc(sizeof(*collectors[i]));
453 collectors[i]->socket = NULL;
455 if (plugin_thread_create(&collectors[i]->thread, &ptattr, collect,
456 collectors[i], "email collector") != 0) {
458 log_err("plugin_thread_create() failed: %s",
459 sstrerror(errno, errbuf, sizeof(errbuf)));
460 collectors[i]->thread = (pthread_t)0;
464 pthread_attr_destroy(&ptattr);
472 pthread_mutex_lock(&available_mutex);
474 while (available_collectors == 0) {
475 pthread_cond_wait(&collector_available, &available_mutex);
478 --available_collectors;
480 pthread_mutex_unlock(&available_mutex);
485 remote = accept(connector_socket, NULL, NULL);
493 close(connector_socket);
494 connector_socket = -1;
495 log_err("accept() failed: %s",
496 sstrerror(errno, errbuf, sizeof(errbuf)));
497 pthread_exit((void *)1);
500 /* access() succeeded. */
504 connection = calloc(1, sizeof(*connection));
505 if (connection == NULL) {
510 connection->socket = fdopen(remote, "r");
511 connection->next = NULL;
513 if (connection->socket == NULL) {
519 pthread_mutex_lock(&conns_mutex);
521 if (conns.head == NULL) {
522 conns.head = connection;
523 conns.tail = connection;
525 conns.tail->next = connection;
526 conns.tail = conns.tail->next;
529 pthread_mutex_unlock(&conns_mutex);
531 pthread_cond_signal(&conn_available);
534 pthread_exit((void *)0);
536 } /* static void *open_connection (void *) */
538 static int email_init(void) {
539 if (plugin_thread_create(&connector, NULL, open_connection, NULL,
540 "email listener") != 0) {
543 log_err("plugin_thread_create() failed: %s",
544 sstrerror(errno, errbuf, sizeof(errbuf)));
549 } /* int email_init */
551 static void type_list_free(type_list_t *t) {
555 while (this != NULL) {
556 type_t *next = this->next;
568 static int email_shutdown(void) {
569 if (connector != ((pthread_t)0)) {
570 pthread_kill(connector, SIGTERM);
571 connector = (pthread_t)0;
574 if (connector_socket >= 0) {
575 close(connector_socket);
576 connector_socket = -1;
579 /* don't allow any more connections to be processed */
580 pthread_mutex_lock(&conns_mutex);
582 available_collectors = 0;
584 if (collectors != NULL) {
585 for (int i = 0; i < max_conns; ++i) {
586 if (collectors[i] == NULL)
589 if (collectors[i]->thread != ((pthread_t)0)) {
590 pthread_kill(collectors[i]->thread, SIGTERM);
591 collectors[i]->thread = (pthread_t)0;
594 if (collectors[i]->socket != NULL) {
595 fclose(collectors[i]->socket);
596 collectors[i]->socket = NULL;
599 sfree(collectors[i]);
602 } /* if (collectors != NULL) */
604 pthread_mutex_unlock(&conns_mutex);
606 type_list_free(&list_count);
607 type_list_free(&list_count_copy);
608 type_list_free(&list_size);
609 type_list_free(&list_size_copy);
610 type_list_free(&list_check);
611 type_list_free(&list_check_copy);
613 unlink((sock_file == NULL) ? SOCK_PATH : sock_file);
618 } /* static void email_shutdown (void) */
620 static void email_submit(const char *type, const char *type_instance,
622 value_list_t vl = VALUE_LIST_INIT;
624 vl.values = &(value_t){.gauge = value};
626 sstrncpy(vl.plugin, "email", sizeof(vl.plugin));
627 sstrncpy(vl.type, type, sizeof(vl.type));
628 sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
630 plugin_dispatch_values(&vl);
631 } /* void email_submit */
633 /* Copy list l1 to list l2. l2 may partly exist already, but it is assumed
634 * that neither the order nor the name of any element of either list is
635 * changed and no elements are deleted. The values of l1 are reset to zero
636 * after they have been copied to l2. */
637 static void copy_type_list(type_list_t *l1, type_list_t *l2) {
640 for (type_t *ptr1 = l1->head, *ptr2 = l2->head; ptr1 != NULL;
641 ptr1 = ptr1->next, last = ptr2, ptr2 = ptr2->next) {
643 ptr2 = smalloc(sizeof(*ptr2));
656 if (ptr2->name == NULL) {
657 ptr2->name = sstrdup(ptr1->name);
660 ptr2->value = ptr1->value;
666 static int email_read(void) {
674 pthread_mutex_lock(&count_mutex);
676 copy_type_list(&list_count, &list_count_copy);
678 pthread_mutex_unlock(&count_mutex);
680 for (type_t *ptr = list_count_copy.head; ptr != NULL; ptr = ptr->next) {
681 email_submit("email_count", ptr->name, ptr->value);
685 pthread_mutex_lock(&size_mutex);
687 copy_type_list(&list_size, &list_size_copy);
689 pthread_mutex_unlock(&size_mutex);
691 for (type_t *ptr = list_size_copy.head; ptr != NULL; ptr = ptr->next) {
692 email_submit("email_size", ptr->name, ptr->value);
696 pthread_mutex_lock(&score_mutex);
699 score_count_old = score_count;
703 pthread_mutex_unlock(&score_mutex);
705 if (score_count_old > 0)
706 email_submit("spam_score", "", score_old);
709 pthread_mutex_lock(&check_mutex);
711 copy_type_list(&list_check, &list_check_copy);
713 pthread_mutex_unlock(&check_mutex);
715 for (type_t *ptr = list_check_copy.head; ptr != NULL; ptr = ptr->next)
716 email_submit("spam_check", ptr->name, ptr->value);
719 } /* int email_read */
721 void module_register(void) {
722 plugin_register_config("email", email_config, config_keys, config_keys_num);
723 plugin_register_init("email", email_init);
724 plugin_register_read("email", email_read);
725 plugin_register_shutdown("email", email_shutdown);
726 } /* void module_register */