Merge remote-tracking branch 'github/pr/2135'
[collectd.git] / src / email.c
1 /**
2  * collectd - src/email.c
3  * Copyright (C) 2006-2008  Sebastian Harl
4  *
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:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
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.
22  *
23  * Authors:
24  *   Sebastian Harl <sh at tokkee.org>
25  **/
26
27 /*
28  * This plugin communicates with a spam filter, a virus scanner or similar
29  * software using a UNIX socket and a very simple protocol:
30  *
31  * e-mail type (e.g. ham, spam, virus, ...) and size
32  * e:<type>:<bytes>
33  *
34  * spam score
35  * s:<value>
36  *
37  * successful spam checks
38  * c:<type1>[,<type2>,...]
39  */
40
41 #include "collectd.h"
42
43 #include "common.h"
44 #include "plugin.h"
45
46 #include <stddef.h>
47
48 #include <sys/select.h>
49 #include <sys/un.h>
50
51 /* some systems (e.g. Darwin) seem to not define UNIX_PATH_MAX at all */
52 #ifndef UNIX_PATH_MAX
53 #define UNIX_PATH_MAX sizeof(((struct sockaddr_un *)0)->sun_path)
54 #endif /* UNIX_PATH_MAX */
55
56 #if HAVE_GRP_H
57 #include <grp.h>
58 #endif /* HAVE_GRP_H */
59
60 #define SOCK_PATH LOCALSTATEDIR "/run/" PACKAGE_NAME "-email"
61 #define MAX_CONNS 5
62 #define MAX_CONNS_LIMIT 16384
63
64 #define log_debug(...) DEBUG("email: "__VA_ARGS__)
65 #define log_err(...) ERROR("email: "__VA_ARGS__)
66 #define log_warn(...) WARNING("email: "__VA_ARGS__)
67
68 /*
69  * Private data structures
70  */
71 /* linked list of email and check types */
72 typedef struct type {
73   char *name;
74   int value;
75   struct type *next;
76 } type_t;
77
78 typedef struct {
79   type_t *head;
80   type_t *tail;
81 } type_list_t;
82
83 /* collector thread control information */
84 typedef struct collector {
85   pthread_t thread;
86
87   /* socket descriptor of the current/last connection */
88   FILE *socket;
89 } collector_t;
90
91 /* linked list of pending connections */
92 typedef struct conn {
93   /* socket to read data from */
94   FILE *socket;
95
96   /* linked list of connections */
97   struct conn *next;
98 } conn_t;
99
100 typedef struct {
101   conn_t *head;
102   conn_t *tail;
103 } conn_list_t;
104
105 /*
106  * Private variables
107  */
108 /* valid configuration file keys */
109 static const char *config_keys[] = {"SocketFile", "SocketGroup", "SocketPerms",
110                                     "MaxConns"};
111 static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
112
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;
118
119 /* state of the plugin */
120 static int disabled = 0;
121
122 /* thread managing "client" connections */
123 static pthread_t connector = (pthread_t)0;
124 static int connector_socket = -1;
125
126 /* tell the collector threads that a new connection is available */
127 static pthread_cond_t conn_available = PTHREAD_COND_INITIALIZER;
128
129 /* connections that are waiting to be processed */
130 static pthread_mutex_t conns_mutex = PTHREAD_MUTEX_INITIALIZER;
131 static conn_list_t conns;
132
133 /* tell the connector thread that a collector is available */
134 static pthread_cond_t collector_available = PTHREAD_COND_INITIALIZER;
135
136 /* collector threads */
137 static collector_t **collectors = NULL;
138
139 static pthread_mutex_t available_mutex = PTHREAD_MUTEX_INITIALIZER;
140 static int available_collectors;
141
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;
145
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;
149
150 static pthread_mutex_t score_mutex = PTHREAD_MUTEX_INITIALIZER;
151 static double score;
152 static int score_count;
153
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;
157
158 /*
159  * Private functions
160  */
161 static int email_config(const char *key, const char *value) {
162   if (strcasecmp(key, "SocketFile") == 0) {
163     if (sock_file != NULL)
164       free(sock_file);
165     sock_file = sstrdup(value);
166   } else if (strcasecmp(key, "SocketGroup") == 0) {
167     if (sock_group != NULL)
168       free(sock_group);
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);
175
176     if (tmp < 1) {
177       fprintf(stderr, "email plugin: `MaxConns' was set to invalid "
178                       "value %li, will use default %i.\n",
179               tmp, MAX_CONNS);
180       ERROR("email plugin: `MaxConns' was set to invalid "
181             "value %li, will use default %i.\n",
182             tmp, MAX_CONNS);
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;
192     } else {
193       max_conns = (int)tmp;
194     }
195   } else {
196     return -1;
197   }
198   return 0;
199 } /* static int email_config (char *, char *) */
200
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));
205
206     list->head->name = sstrdup(name);
207     list->head->value = incr;
208     list->head->next = NULL;
209
210     list->tail = list->head;
211   } else {
212     type_t *ptr;
213
214     for (ptr = list->head; NULL != ptr; ptr = ptr->next) {
215       if (strcmp(name, ptr->name) == 0)
216         break;
217     }
218
219     if (ptr == NULL) {
220       list->tail->next = smalloc(sizeof(*list->tail->next));
221       list->tail = list->tail->next;
222
223       list->tail->name = sstrdup(name);
224       list->tail->value = incr;
225       list->tail->next = NULL;
226     } else {
227       ptr->value += incr;
228     }
229   }
230   return;
231 } /* static void type_list_incr (type_list_t *, char *) */
232
233 static void *collect(void *arg) {
234   collector_t *this = (collector_t *)arg;
235
236   while (1) {
237     conn_t *connection;
238
239     pthread_mutex_lock(&conns_mutex);
240
241     while (conns.head == NULL) {
242       pthread_cond_wait(&conn_available, &conns_mutex);
243     }
244
245     connection = conns.head;
246     conns.head = conns.head->next;
247
248     if (conns.head == NULL) {
249       conns.tail = NULL;
250     }
251
252     pthread_mutex_unlock(&conns_mutex);
253
254     /* make the socket available to the global
255      * thread and connection management */
256     this->socket = connection->socket;
257
258     log_debug("collect: handling connection on fd #%i", fileno(this->socket));
259
260     while (42) {
261       /* 256 bytes ought to be enough for anybody ;-) */
262       char line[256 + 1]; /* line + '\0' */
263       int len = 0;
264
265       errno = 0;
266       if (fgets(line, sizeof(line), this->socket) == NULL) {
267         if (errno != 0) {
268           char errbuf[1024];
269           log_err("collect: reading from socket (fd #%i) "
270                   "failed: %s",
271                   fileno(this->socket),
272                   sstrerror(errno, errbuf, sizeof(errbuf)));
273         }
274         break;
275       }
276
277       len = strlen(line);
278       if ((line[len - 1] != '\n') && (line[len - 1] != '\r')) {
279         log_warn("collect: line too long (> %zu characters): "
280                  "'%s' (truncated)",
281                  sizeof(line) - 1, line);
282
283         while (fgets(line, sizeof(line), this->socket) != NULL)
284           if ((line[len - 1] == '\n') || (line[len - 1] == '\r'))
285             break;
286         continue;
287       }
288       if (len < 3) { /* [a-z] ':' '\n' */
289         continue;
290       }
291
292       line[len - 1] = 0;
293
294       log_debug("collect: line = '%s'", line);
295
296       if (line[1] != ':') {
297         log_err("collect: syntax error in line '%s'", line);
298         continue;
299       }
300
301       if (line[0] == 'e') { /* e:<type>:<bytes> */
302         char *ptr = NULL;
303         char *type = strtok_r(line + 2, ":", &ptr);
304         char *tmp = strtok_r(NULL, ":", &ptr);
305         int bytes = 0;
306
307         if (tmp == NULL) {
308           log_err("collect: syntax error in line '%s'", line);
309           continue;
310         }
311
312         bytes = atoi(tmp);
313
314         pthread_mutex_lock(&count_mutex);
315         type_list_incr(&list_count, type, /* increment = */ 1);
316         pthread_mutex_unlock(&count_mutex);
317
318         if (bytes > 0) {
319           pthread_mutex_lock(&size_mutex);
320           type_list_incr(&list_size, type, /* increment = */ bytes);
321           pthread_mutex_unlock(&size_mutex);
322         }
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);
327         ++score_count;
328         pthread_mutex_unlock(&score_mutex);
329       } else if (line[0] == 'c') { /* c:<type1>[,<type2>,...] */
330         char *dummy = line + 2;
331         char *endptr = NULL;
332         char *type;
333
334         pthread_mutex_lock(&check_mutex);
335         while ((type = strtok_r(dummy, ",", &endptr)) != NULL) {
336           dummy = NULL;
337           type_list_incr(&list_check, type, /* increment = */ 1);
338         }
339         pthread_mutex_unlock(&check_mutex);
340       } else {
341         log_err("collect: unknown type '%c'", line[0]);
342       }
343     } /* while (42) */
344
345     log_debug("Shutting down connection on fd #%i", fileno(this->socket));
346
347     fclose(connection->socket);
348     free(connection);
349
350     this->socket = NULL;
351
352     pthread_mutex_lock(&available_mutex);
353     ++available_collectors;
354     pthread_mutex_unlock(&available_mutex);
355
356     pthread_cond_signal(&collector_available);
357   } /* while (1) */
358
359   pthread_exit((void *)0);
360   return (void *)0;
361 } /* static void *collect (void *) */
362
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;
366
367   /* create UNIX socket */
368   errno = 0;
369   if ((connector_socket = socket(PF_UNIX, SOCK_STREAM, 0)) == -1) {
370     char errbuf[1024];
371     disabled = 1;
372     log_err("socket() failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
373     pthread_exit((void *)1);
374   }
375
376   struct sockaddr_un addr = {
377     .sun_family = AF_UNIX
378   };
379   sstrncpy(addr.sun_path, path, (size_t)(UNIX_PATH_MAX - 1));
380
381   errno = 0;
382   if (bind(connector_socket, (struct sockaddr *)&addr,
383            offsetof(struct sockaddr_un, sun_path) + strlen(addr.sun_path)) == -1) {
384     char errbuf[1024];
385     disabled = 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);
390   }
391
392   errno = 0;
393   if (listen(connector_socket, 5) == -1) {
394     char errbuf[1024];
395     disabled = 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);
400   }
401
402   {
403     struct group sg;
404     struct group *grp;
405     int status;
406
407     long int grbuf_size = sysconf(_SC_GETGR_R_SIZE_MAX);
408     if (grbuf_size <= 0)
409       grbuf_size = sysconf(_SC_PAGESIZE);
410     if (grbuf_size <= 0)
411       grbuf_size = 4096;
412     char grbuf[grbuf_size];
413
414     grp = NULL;
415     status = getgrnam_r(group, &sg, grbuf, sizeof(grbuf), &grp);
416     if (status != 0) {
417       char errbuf[1024];
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);
422     } else {
423       status = chown(path, (uid_t)-1, grp->gr_gid);
424       if (status != 0) {
425         char errbuf[1024];
426         log_warn("chown (%s, -1, %i) failed: %s", path, (int)grp->gr_gid,
427                  sstrerror(errno, errbuf, sizeof(errbuf)));
428       }
429     }
430   }
431
432   errno = 0;
433   if (chmod(path, sock_perms) != 0) {
434     char errbuf[1024];
435     log_warn("chmod() failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
436   }
437
438   { /* initialize collector threads */
439     pthread_attr_t ptattr;
440
441     conns.head = NULL;
442     conns.tail = NULL;
443
444     pthread_attr_init(&ptattr);
445     pthread_attr_setdetachstate(&ptattr, PTHREAD_CREATE_DETACHED);
446
447     available_collectors = max_conns;
448
449     collectors = smalloc(max_conns * sizeof(*collectors));
450
451     for (int i = 0; i < max_conns; ++i) {
452       collectors[i] = smalloc(sizeof(*collectors[i]));
453       collectors[i]->socket = NULL;
454
455       if (plugin_thread_create(&collectors[i]->thread, &ptattr, collect,
456                                collectors[i], "email collector") != 0) {
457         char errbuf[1024];
458         log_err("plugin_thread_create() failed: %s",
459                 sstrerror(errno, errbuf, sizeof(errbuf)));
460         collectors[i]->thread = (pthread_t)0;
461       }
462     }
463
464     pthread_attr_destroy(&ptattr);
465   }
466
467   while (1) {
468     int remote = 0;
469
470     conn_t *connection;
471
472     pthread_mutex_lock(&available_mutex);
473
474     while (available_collectors == 0) {
475       pthread_cond_wait(&collector_available, &available_mutex);
476     }
477
478     --available_collectors;
479
480     pthread_mutex_unlock(&available_mutex);
481
482     while (42) {
483       errno = 0;
484
485       remote = accept(connector_socket, NULL, NULL);
486       if (remote == -1) {
487         char errbuf[1024];
488
489         if (errno == EINTR)
490           continue;
491
492         disabled = 1;
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);
498       }
499
500       /* access() succeeded. */
501       break;
502     }
503
504     connection = calloc(1, sizeof(*connection));
505     if (connection == NULL) {
506       close(remote);
507       continue;
508     }
509
510     connection->socket = fdopen(remote, "r");
511     connection->next = NULL;
512
513     if (connection->socket == NULL) {
514       close(remote);
515       sfree(connection);
516       continue;
517     }
518
519     pthread_mutex_lock(&conns_mutex);
520
521     if (conns.head == NULL) {
522       conns.head = connection;
523       conns.tail = connection;
524     } else {
525       conns.tail->next = connection;
526       conns.tail = conns.tail->next;
527     }
528
529     pthread_mutex_unlock(&conns_mutex);
530
531     pthread_cond_signal(&conn_available);
532   }
533
534   pthread_exit((void *)0);
535   return (void *)0;
536 } /* static void *open_connection (void *) */
537
538 static int email_init(void) {
539   if (plugin_thread_create(&connector, NULL, open_connection, NULL,
540                            "email listener") != 0) {
541     char errbuf[1024];
542     disabled = 1;
543     log_err("plugin_thread_create() failed: %s",
544             sstrerror(errno, errbuf, sizeof(errbuf)));
545     return -1;
546   }
547
548   return 0;
549 } /* int email_init */
550
551 static void type_list_free(type_list_t *t) {
552   type_t *this;
553
554   this = t->head;
555   while (this != NULL) {
556     type_t *next = this->next;
557
558     sfree(this->name);
559     sfree(this);
560
561     this = next;
562   }
563
564   t->head = NULL;
565   t->tail = NULL;
566 }
567
568 static int email_shutdown(void) {
569   if (connector != ((pthread_t)0)) {
570     pthread_kill(connector, SIGTERM);
571     connector = (pthread_t)0;
572   }
573
574   if (connector_socket >= 0) {
575     close(connector_socket);
576     connector_socket = -1;
577   }
578
579   /* don't allow any more connections to be processed */
580   pthread_mutex_lock(&conns_mutex);
581
582   available_collectors = 0;
583
584   if (collectors != NULL) {
585     for (int i = 0; i < max_conns; ++i) {
586       if (collectors[i] == NULL)
587         continue;
588
589       if (collectors[i]->thread != ((pthread_t)0)) {
590         pthread_kill(collectors[i]->thread, SIGTERM);
591         collectors[i]->thread = (pthread_t)0;
592       }
593
594       if (collectors[i]->socket != NULL) {
595         fclose(collectors[i]->socket);
596         collectors[i]->socket = NULL;
597       }
598
599       sfree(collectors[i]);
600     }
601     sfree(collectors);
602   } /* if (collectors != NULL) */
603
604   pthread_mutex_unlock(&conns_mutex);
605
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);
612
613   unlink((sock_file == NULL) ? SOCK_PATH : sock_file);
614
615   sfree(sock_file);
616   sfree(sock_group);
617   return 0;
618 } /* static void email_shutdown (void) */
619
620 static void email_submit(const char *type, const char *type_instance,
621                          gauge_t value) {
622   value_list_t vl = VALUE_LIST_INIT;
623
624   vl.values = &(value_t){.gauge = value};
625   vl.values_len = 1;
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));
629
630   plugin_dispatch_values(&vl);
631 } /* void email_submit */
632
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) {
638   type_t *last = NULL;
639
640   for (type_t *ptr1 = l1->head, *ptr2 = l2->head; ptr1 != NULL;
641        ptr1 = ptr1->next, last = ptr2, ptr2 = ptr2->next) {
642     if (ptr2 == NULL) {
643       ptr2 = smalloc(sizeof(*ptr2));
644       ptr2->name = NULL;
645       ptr2->next = NULL;
646
647       if (last == NULL) {
648         l2->head = ptr2;
649       } else {
650         last->next = ptr2;
651       }
652
653       l2->tail = ptr2;
654     }
655
656     if (ptr2->name == NULL) {
657       ptr2->name = sstrdup(ptr1->name);
658     }
659
660     ptr2->value = ptr1->value;
661     ptr1->value = 0;
662   }
663   return;
664 }
665
666 static int email_read(void) {
667   double score_old;
668   int score_count_old;
669
670   if (disabled)
671     return -1;
672
673   /* email count */
674   pthread_mutex_lock(&count_mutex);
675
676   copy_type_list(&list_count, &list_count_copy);
677
678   pthread_mutex_unlock(&count_mutex);
679
680   for (type_t *ptr = list_count_copy.head; ptr != NULL; ptr = ptr->next) {
681     email_submit("email_count", ptr->name, ptr->value);
682   }
683
684   /* email size */
685   pthread_mutex_lock(&size_mutex);
686
687   copy_type_list(&list_size, &list_size_copy);
688
689   pthread_mutex_unlock(&size_mutex);
690
691   for (type_t *ptr = list_size_copy.head; ptr != NULL; ptr = ptr->next) {
692     email_submit("email_size", ptr->name, ptr->value);
693   }
694
695   /* spam score */
696   pthread_mutex_lock(&score_mutex);
697
698   score_old = score;
699   score_count_old = score_count;
700   score = 0.0;
701   score_count = 0;
702
703   pthread_mutex_unlock(&score_mutex);
704
705   if (score_count_old > 0)
706     email_submit("spam_score", "", score_old);
707
708   /* spam checks */
709   pthread_mutex_lock(&check_mutex);
710
711   copy_type_list(&list_check, &list_check_copy);
712
713   pthread_mutex_unlock(&check_mutex);
714
715   for (type_t *ptr = list_check_copy.head; ptr != NULL; ptr = ptr->next)
716     email_submit("spam_check", ptr->name, ptr->value);
717
718   return 0;
719 } /* int email_read */
720
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 */