Merge branch 'collectd-5.7'
[collectd.git] / src / exec.c
1 /**
2  * collectd - src/exec.c
3  * Copyright (C) 2007-2010  Florian octo Forster
4  * Copyright (C) 2007-2009  Sebastian Harl
5  * Copyright (C) 2008       Peter Holik
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  *   Sebastian Harl <sh at tokkee.org>
23  *   Peter Holik <peter at holik.at>
24  **/
25
26 #define _DEFAULT_SOURCE
27 #define _BSD_SOURCE /* For setgroups */
28
29 #include "collectd.h"
30
31 #include "common.h"
32 #include "plugin.h"
33
34 #include "utils_cmd_putnotif.h"
35 #include "utils_cmd_putval.h"
36
37 #include <grp.h>
38 #include <pwd.h>
39 #include <signal.h>
40 #include <sys/types.h>
41
42 #ifdef HAVE_SYS_CAPABILITY_H
43 #include <sys/capability.h>
44 #endif
45
46 #define PL_NORMAL 0x01
47 #define PL_NOTIF_ACTION 0x02
48
49 #define PL_RUNNING 0x10
50
51 /*
52  * Private data types
53  */
54 /*
55  * Access to this structure is serialized using the `pl_lock' lock and the
56  * `PL_RUNNING' flag. The execution of notifications is *not* serialized, so
57  * all functions used to handle notifications MUST NOT write to this structure.
58  * The `pid' and `status' fields are thus unused if the `PL_NOTIF_ACTION' flag
59  * is set.
60  * The `PL_RUNNING' flag is set in `exec_read' and unset in `exec_read_one'.
61  */
62 struct program_list_s;
63 typedef struct program_list_s program_list_t;
64 struct program_list_s {
65   char *user;
66   char *group;
67   char *exec;
68   char **argv;
69   int pid;
70   int status;
71   int flags;
72   program_list_t *next;
73 };
74
75 typedef struct program_list_and_notification_s {
76   program_list_t *pl;
77   notification_t n;
78 } program_list_and_notification_t;
79
80 /*
81  * Private variables
82  */
83 static program_list_t *pl_head = NULL;
84 static pthread_mutex_t pl_lock = PTHREAD_MUTEX_INITIALIZER;
85
86 /*
87  * Functions
88  */
89 static void sigchld_handler(int __attribute__((unused)) signal) /* {{{ */
90 {
91   pid_t pid;
92   int status;
93   while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
94     program_list_t *pl;
95     for (pl = pl_head; pl != NULL; pl = pl->next)
96       if (pl->pid == pid)
97         break;
98     if (pl != NULL)
99       pl->status = status;
100   } /* while (waitpid) */
101 } /* void sigchld_handler }}} */
102
103 static int exec_config_exec(oconfig_item_t *ci) /* {{{ */
104 {
105   program_list_t *pl;
106   char buffer[128];
107   int i;
108
109   if (ci->children_num != 0) {
110     WARNING("exec plugin: The config option `%s' may not be a block.", ci->key);
111     return -1;
112   }
113   if (ci->values_num < 2) {
114     WARNING("exec plugin: The config option `%s' needs at least two "
115             "arguments.",
116             ci->key);
117     return -1;
118   }
119   if ((ci->values[0].type != OCONFIG_TYPE_STRING) ||
120       (ci->values[1].type != OCONFIG_TYPE_STRING)) {
121     WARNING("exec plugin: The first two arguments to the `%s' option must "
122             "be string arguments.",
123             ci->key);
124     return -1;
125   }
126
127   pl = calloc(1, sizeof(*pl));
128   if (pl == NULL) {
129     ERROR("exec plugin: calloc failed.");
130     return -1;
131   }
132
133   if (strcasecmp("NotificationExec", ci->key) == 0)
134     pl->flags |= PL_NOTIF_ACTION;
135   else
136     pl->flags |= PL_NORMAL;
137
138   pl->user = strdup(ci->values[0].value.string);
139   if (pl->user == NULL) {
140     ERROR("exec plugin: strdup failed.");
141     sfree(pl);
142     return -1;
143   }
144
145   pl->group = strchr(pl->user, ':');
146   if (pl->group != NULL) {
147     *pl->group = '\0';
148     pl->group++;
149   }
150
151   pl->exec = strdup(ci->values[1].value.string);
152   if (pl->exec == NULL) {
153     ERROR("exec plugin: strdup failed.");
154     sfree(pl->user);
155     sfree(pl);
156     return -1;
157   }
158
159   pl->argv = calloc(ci->values_num, sizeof(*pl->argv));
160   if (pl->argv == NULL) {
161     ERROR("exec plugin: calloc failed.");
162     sfree(pl->exec);
163     sfree(pl->user);
164     sfree(pl);
165     return -1;
166   }
167
168   {
169     char *tmp = strrchr(ci->values[1].value.string, '/');
170     if (tmp == NULL)
171       sstrncpy(buffer, ci->values[1].value.string, sizeof(buffer));
172     else
173       sstrncpy(buffer, tmp + 1, sizeof(buffer));
174   }
175   pl->argv[0] = strdup(buffer);
176   if (pl->argv[0] == NULL) {
177     ERROR("exec plugin: strdup failed.");
178     sfree(pl->argv);
179     sfree(pl->exec);
180     sfree(pl->user);
181     sfree(pl);
182     return -1;
183   }
184
185   for (i = 1; i < (ci->values_num - 1); i++) {
186     if (ci->values[i + 1].type == OCONFIG_TYPE_STRING) {
187       pl->argv[i] = strdup(ci->values[i + 1].value.string);
188     } else {
189       if (ci->values[i + 1].type == OCONFIG_TYPE_NUMBER) {
190         snprintf(buffer, sizeof(buffer), "%lf", ci->values[i + 1].value.number);
191       } else {
192         if (ci->values[i + 1].value.boolean)
193           sstrncpy(buffer, "true", sizeof(buffer));
194         else
195           sstrncpy(buffer, "false", sizeof(buffer));
196       }
197
198       pl->argv[i] = strdup(buffer);
199     }
200
201     if (pl->argv[i] == NULL) {
202       ERROR("exec plugin: strdup failed.");
203       break;
204     }
205   } /* for (i) */
206
207   if (i < (ci->values_num - 1)) {
208     while ((--i) >= 0) {
209       sfree(pl->argv[i]);
210     }
211     sfree(pl->argv);
212     sfree(pl->exec);
213     sfree(pl->user);
214     sfree(pl);
215     return -1;
216   }
217
218   for (i = 0; pl->argv[i] != NULL; i++) {
219     DEBUG("exec plugin: argv[%i] = %s", i, pl->argv[i]);
220   }
221
222   pl->next = pl_head;
223   pl_head = pl;
224
225   return 0;
226 } /* int exec_config_exec }}} */
227
228 static int exec_config(oconfig_item_t *ci) /* {{{ */
229 {
230   for (int i = 0; i < ci->children_num; i++) {
231     oconfig_item_t *child = ci->children + i;
232     if ((strcasecmp("Exec", child->key) == 0) ||
233         (strcasecmp("NotificationExec", child->key) == 0))
234       exec_config_exec(child);
235     else {
236       WARNING("exec plugin: Unknown config option `%s'.", child->key);
237     }
238   } /* for (i) */
239
240   return 0;
241 } /* int exec_config }}} */
242
243 static void set_environment(void) /* {{{ */
244 {
245   char buffer[1024];
246
247 #ifdef HAVE_SETENV
248   snprintf(buffer, sizeof(buffer), "%.3f",
249            CDTIME_T_TO_DOUBLE(plugin_get_interval()));
250   setenv("COLLECTD_INTERVAL", buffer, /* overwrite = */ 1);
251
252   sstrncpy(buffer, hostname_g, sizeof(buffer));
253   setenv("COLLECTD_HOSTNAME", buffer, /* overwrite = */ 1);
254 #else
255   snprintf(buffer, sizeof(buffer), "COLLECTD_INTERVAL=%.3f",
256            CDTIME_T_TO_DOUBLE(plugin_get_interval()));
257   putenv(buffer);
258
259   snprintf(buffer, sizeof(buffer), "COLLECTD_HOSTNAME=%s", hostname_g);
260   putenv(buffer);
261 #endif
262 } /* }}} void set_environment */
263
264 __attribute__((noreturn)) static void exec_child(program_list_t *pl, int uid,
265                                                  int gid, int egid) /* {{{ */
266 {
267   int status;
268   char errbuf[1024];
269
270 #if HAVE_SETGROUPS
271   if (getuid() == 0) {
272     gid_t glist[2];
273     size_t glist_len;
274
275     glist[0] = gid;
276     glist_len = 1;
277
278     if ((gid != egid) && (egid != -1)) {
279       glist[1] = egid;
280       glist_len = 2;
281     }
282
283     setgroups(glist_len, glist);
284   }
285 #endif /* HAVE_SETGROUPS */
286
287   status = setgid(gid);
288   if (status != 0) {
289     ERROR("exec plugin: setgid (%i) failed: %s", gid,
290           sstrerror(errno, errbuf, sizeof(errbuf)));
291     exit(-1);
292   }
293
294   if (egid != -1) {
295     status = setegid(egid);
296     if (status != 0) {
297       ERROR("exec plugin: setegid (%i) failed: %s", egid,
298             sstrerror(errno, errbuf, sizeof(errbuf)));
299       exit(-1);
300     }
301   }
302
303   status = setuid(uid);
304   if (status != 0) {
305     ERROR("exec plugin: setuid (%i) failed: %s", uid,
306           sstrerror(errno, errbuf, sizeof(errbuf)));
307     exit(-1);
308   }
309
310   execvp(pl->exec, pl->argv);
311
312   ERROR("exec plugin: Failed to execute ``%s'': %s", pl->exec,
313         sstrerror(errno, errbuf, sizeof(errbuf)));
314   exit(-1);
315 } /* void exec_child }}} */
316
317 static void reset_signal_mask(void) /* {{{ */
318 {
319   sigset_t ss;
320
321   sigemptyset(&ss);
322   sigprocmask(SIG_SETMASK, &ss, /* old mask = */ NULL);
323 } /* }}} void reset_signal_mask */
324
325 static int create_pipe(int fd_pipe[2]) /* {{{ */
326 {
327   char errbuf[1024];
328   int status;
329
330   status = pipe(fd_pipe);
331   if (status != 0) {
332     ERROR("exec plugin: pipe failed: %s",
333           sstrerror(errno, errbuf, sizeof(errbuf)));
334     return -1;
335   }
336
337   return 0;
338 } /* }}} int create_pipe */
339
340 static void close_pipe(int fd_pipe[2]) /* {{{ */
341 {
342   if (fd_pipe[0] != -1)
343     close(fd_pipe[0]);
344
345   if (fd_pipe[1] != -1)
346     close(fd_pipe[1]);
347 } /* }}} void close_pipe */
348
349 /*
350  * Creates three pipes (one for reading, one for writing and one for errors),
351  * forks a child, sets up the pipes so that fd_in is connected to STDIN of
352  * the child and fd_out is connected to STDOUT and fd_err is connected to STDERR
353  * of the child. Then is calls `exec_child'.
354  */
355 static int fork_child(program_list_t *pl, int *fd_in, int *fd_out,
356                       int *fd_err) /* {{{ */
357 {
358   int fd_pipe_in[2] = {-1, -1};
359   int fd_pipe_out[2] = {-1, -1};
360   int fd_pipe_err[2] = {-1, -1};
361   char errbuf[1024];
362   int status;
363   int pid;
364
365   int uid;
366   int gid;
367   int egid;
368
369   struct passwd *sp_ptr;
370   struct passwd sp;
371   char nambuf[4096];
372
373   if (pl->pid != 0)
374     return -1;
375
376   if ((create_pipe(fd_pipe_in) == -1) || (create_pipe(fd_pipe_out) == -1) ||
377       (create_pipe(fd_pipe_err) == -1))
378     goto failed;
379
380   sp_ptr = NULL;
381   status = getpwnam_r(pl->user, &sp, nambuf, sizeof(nambuf), &sp_ptr);
382   if (status != 0) {
383     ERROR("exec plugin: Failed to get user information for user ``%s'': %s",
384           pl->user, sstrerror(status, errbuf, sizeof(errbuf)));
385     goto failed;
386   }
387
388   if (sp_ptr == NULL) {
389     ERROR("exec plugin: No such user: `%s'", pl->user);
390     goto failed;
391   }
392
393   uid = sp.pw_uid;
394   gid = sp.pw_gid;
395   if (uid == 0) {
396     ERROR("exec plugin: Cowardly refusing to exec program as root.");
397     goto failed;
398   }
399
400   /* The group configured in the configfile is set as effective group, because
401    * this way the forked process can (re-)gain the user's primary group. */
402   egid = -1;
403   if (pl->group != NULL) {
404     if (*pl->group != '\0') {
405       struct group *gr_ptr = NULL;
406       struct group gr;
407
408       status = getgrnam_r(pl->group, &gr, nambuf, sizeof(nambuf), &gr_ptr);
409       if (status != 0) {
410         ERROR("exec plugin: Failed to get group information "
411               "for group ``%s'': %s",
412               pl->group, sstrerror(status, errbuf, sizeof(errbuf)));
413         goto failed;
414       }
415       if (gr_ptr == NULL) {
416         ERROR("exec plugin: No such group: `%s'", pl->group);
417         goto failed;
418       }
419
420       egid = gr.gr_gid;
421     } else {
422       egid = gid;
423     }
424   } /* if (pl->group == NULL) */
425
426   pid = fork();
427   if (pid < 0) {
428     ERROR("exec plugin: fork failed: %s",
429           sstrerror(errno, errbuf, sizeof(errbuf)));
430     goto failed;
431   } else if (pid == 0) {
432     int fd_num;
433
434     /* Close all file descriptors but the pipe end we need. */
435     fd_num = getdtablesize();
436     for (int fd = 0; fd < fd_num; fd++) {
437       if ((fd == fd_pipe_in[0]) || (fd == fd_pipe_out[1]) ||
438           (fd == fd_pipe_err[1]))
439         continue;
440       close(fd);
441     }
442
443     /* Connect the `in' pipe to STDIN */
444     if (fd_pipe_in[0] != STDIN_FILENO) {
445       dup2(fd_pipe_in[0], STDIN_FILENO);
446       close(fd_pipe_in[0]);
447     }
448
449     /* Now connect the `out' pipe to STDOUT */
450     if (fd_pipe_out[1] != STDOUT_FILENO) {
451       dup2(fd_pipe_out[1], STDOUT_FILENO);
452       close(fd_pipe_out[1]);
453     }
454
455     /* Now connect the `err' pipe to STDERR */
456     if (fd_pipe_err[1] != STDERR_FILENO) {
457       dup2(fd_pipe_err[1], STDERR_FILENO);
458       close(fd_pipe_err[1]);
459     }
460
461     set_environment();
462
463     /* Unblock all signals */
464     reset_signal_mask();
465
466     exec_child(pl, uid, gid, egid);
467     /* does not return */
468   }
469
470   close(fd_pipe_in[0]);
471   close(fd_pipe_out[1]);
472   close(fd_pipe_err[1]);
473
474   if (fd_in != NULL)
475     *fd_in = fd_pipe_in[1];
476   else
477     close(fd_pipe_in[1]);
478
479   if (fd_out != NULL)
480     *fd_out = fd_pipe_out[0];
481   else
482     close(fd_pipe_out[0]);
483
484   if (fd_err != NULL)
485     *fd_err = fd_pipe_err[0];
486   else
487     close(fd_pipe_err[0]);
488
489   return pid;
490
491 failed:
492   close_pipe(fd_pipe_in);
493   close_pipe(fd_pipe_out);
494   close_pipe(fd_pipe_err);
495
496   return -1;
497 } /* int fork_child }}} */
498
499 static int parse_line(char *buffer) /* {{{ */
500 {
501   if (strncasecmp("PUTVAL", buffer, strlen("PUTVAL")) == 0)
502     return cmd_handle_putval(stdout, buffer);
503   else if (strncasecmp("PUTNOTIF", buffer, strlen("PUTNOTIF")) == 0)
504     return handle_putnotif(stdout, buffer);
505   else {
506     ERROR("exec plugin: Unable to parse command, ignoring line: \"%s\"",
507           buffer);
508     return -1;
509   }
510 } /* int parse_line }}} */
511
512 static void *exec_read_one(void *arg) /* {{{ */
513 {
514   program_list_t *pl = (program_list_t *)arg;
515   int fd, fd_err, highest_fd;
516   fd_set fdset, copy;
517   int status;
518   char buffer[1200]; /* if not completely read */
519   char buffer_err[1024];
520   char *pbuffer = buffer;
521   char *pbuffer_err = buffer_err;
522
523   status = fork_child(pl, NULL, &fd, &fd_err);
524   if (status < 0) {
525     /* Reset the "running" flag */
526     pthread_mutex_lock(&pl_lock);
527     pl->flags &= ~PL_RUNNING;
528     pthread_mutex_unlock(&pl_lock);
529     pthread_exit((void *)1);
530   }
531   pl->pid = status;
532
533   assert(pl->pid != 0);
534
535   FD_ZERO(&fdset);
536   FD_SET(fd, &fdset);
537   FD_SET(fd_err, &fdset);
538
539   /* Determine the highest file descriptor */
540   highest_fd = (fd > fd_err) ? fd : fd_err;
541
542   /* We use a copy of fdset, as select modifies it */
543   copy = fdset;
544
545   while (1) {
546     int len;
547
548     status = select(highest_fd + 1, &copy, NULL, NULL, NULL);
549     if (status < 0) {
550       if (errno == EINTR)
551         continue;
552       break;
553     }
554
555     if (FD_ISSET(fd, &copy)) {
556       char *pnl;
557
558       len = read(fd, pbuffer, sizeof(buffer) - 1 - (pbuffer - buffer));
559
560       if (len < 0) {
561         if (errno == EAGAIN || errno == EINTR)
562           continue;
563         break;
564       } else if (len == 0)
565         break; /* We've reached EOF */
566
567       pbuffer[len] = '\0';
568
569       len += pbuffer - buffer;
570       pbuffer = buffer;
571
572       while ((pnl = strchr(pbuffer, '\n'))) {
573         *pnl = '\0';
574         if (*(pnl - 1) == '\r')
575           *(pnl - 1) = '\0';
576
577         parse_line(pbuffer);
578
579         pbuffer = ++pnl;
580       }
581       /* not completely read ? */
582       if (pbuffer - buffer < len) {
583         len -= pbuffer - buffer;
584         memmove(buffer, pbuffer, len);
585         pbuffer = buffer + len;
586       } else
587         pbuffer = buffer;
588     } else if (FD_ISSET(fd_err, &copy)) {
589       char *pnl;
590
591       len = read(fd_err, pbuffer_err,
592                  sizeof(buffer_err) - 1 - (pbuffer_err - buffer_err));
593
594       if (len < 0) {
595         if (errno == EAGAIN || errno == EINTR)
596           continue;
597         break;
598       } else if (len == 0) {
599         /* We've reached EOF */
600         NOTICE("exec plugin: Program `%s' has closed STDERR.", pl->exec);
601
602         /* Remove file descriptor form select() set. */
603         FD_CLR(fd_err, &fdset);
604         copy = fdset;
605         highest_fd = fd;
606
607         /* Clean up file descriptor */
608         close(fd_err);
609         fd_err = -1;
610         continue;
611       }
612
613       pbuffer_err[len] = '\0';
614
615       len += pbuffer_err - buffer_err;
616       pbuffer_err = buffer_err;
617
618       while ((pnl = strchr(pbuffer_err, '\n'))) {
619         *pnl = '\0';
620         if (*(pnl - 1) == '\r')
621           *(pnl - 1) = '\0';
622
623         ERROR("exec plugin: exec_read_one: error = %s", pbuffer_err);
624
625         pbuffer_err = ++pnl;
626       }
627       /* not completely read ? */
628       if (pbuffer_err - buffer_err < len) {
629         len -= pbuffer_err - buffer_err;
630         memmove(buffer_err, pbuffer_err, len);
631         pbuffer_err = buffer_err + len;
632       } else
633         pbuffer_err = buffer_err;
634     }
635     /* reset copy */
636     copy = fdset;
637   }
638
639   DEBUG("exec plugin: exec_read_one: Waiting for `%s' to exit.", pl->exec);
640   if (waitpid(pl->pid, &status, 0) > 0)
641     pl->status = status;
642
643   DEBUG("exec plugin: Child %i exited with status %i.", (int)pl->pid,
644         pl->status);
645
646   pl->pid = 0;
647
648   pthread_mutex_lock(&pl_lock);
649   pl->flags &= ~PL_RUNNING;
650   pthread_mutex_unlock(&pl_lock);
651
652   close(fd);
653   if (fd_err >= 0)
654     close(fd_err);
655
656   pthread_exit((void *)0);
657   return NULL;
658 } /* void *exec_read_one }}} */
659
660 static void *exec_notification_one(void *arg) /* {{{ */
661 {
662   program_list_t *pl = ((program_list_and_notification_t *)arg)->pl;
663   notification_t *n = &((program_list_and_notification_t *)arg)->n;
664   int fd;
665   FILE *fh;
666   int pid;
667   int status;
668   const char *severity;
669
670   pid = fork_child(pl, &fd, NULL, NULL);
671   if (pid < 0) {
672     sfree(arg);
673     pthread_exit((void *)1);
674   }
675
676   fh = fdopen(fd, "w");
677   if (fh == NULL) {
678     char errbuf[1024];
679     ERROR("exec plugin: fdopen (%i) failed: %s", fd,
680           sstrerror(errno, errbuf, sizeof(errbuf)));
681     kill(pid, SIGTERM);
682     close(fd);
683     sfree(arg);
684     pthread_exit((void *)1);
685   }
686
687   severity = "FAILURE";
688   if (n->severity == NOTIF_WARNING)
689     severity = "WARNING";
690   else if (n->severity == NOTIF_OKAY)
691     severity = "OKAY";
692
693   fprintf(fh, "Severity: %s\n"
694               "Time: %.3f\n",
695           severity, CDTIME_T_TO_DOUBLE(n->time));
696
697   /* Print the optional fields */
698   if (strlen(n->host) > 0)
699     fprintf(fh, "Host: %s\n", n->host);
700   if (strlen(n->plugin) > 0)
701     fprintf(fh, "Plugin: %s\n", n->plugin);
702   if (strlen(n->plugin_instance) > 0)
703     fprintf(fh, "PluginInstance: %s\n", n->plugin_instance);
704   if (strlen(n->type) > 0)
705     fprintf(fh, "Type: %s\n", n->type);
706   if (strlen(n->type_instance) > 0)
707     fprintf(fh, "TypeInstance: %s\n", n->type_instance);
708
709   for (notification_meta_t *meta = n->meta; meta != NULL; meta = meta->next) {
710     if (meta->type == NM_TYPE_STRING)
711       fprintf(fh, "%s: %s\n", meta->name, meta->nm_value.nm_string);
712     else if (meta->type == NM_TYPE_SIGNED_INT)
713       fprintf(fh, "%s: %" PRIi64 "\n", meta->name,
714               meta->nm_value.nm_signed_int);
715     else if (meta->type == NM_TYPE_UNSIGNED_INT)
716       fprintf(fh, "%s: %" PRIu64 "\n", meta->name,
717               meta->nm_value.nm_unsigned_int);
718     else if (meta->type == NM_TYPE_DOUBLE)
719       fprintf(fh, "%s: %e\n", meta->name, meta->nm_value.nm_double);
720     else if (meta->type == NM_TYPE_BOOLEAN)
721       fprintf(fh, "%s: %s\n", meta->name,
722               meta->nm_value.nm_boolean ? "true" : "false");
723   }
724
725   fprintf(fh, "\n%s\n", n->message);
726
727   fflush(fh);
728   fclose(fh);
729
730   waitpid(pid, &status, 0);
731
732   DEBUG("exec plugin: Child %i exited with status %i.", pid, status);
733
734   if (n->meta != NULL)
735     plugin_notification_meta_free(n->meta);
736   n->meta = NULL;
737   sfree(arg);
738   pthread_exit((void *)0);
739   return NULL;
740 } /* void *exec_notification_one }}} */
741
742 static int exec_init(void) /* {{{ */
743 {
744   struct sigaction sa = {.sa_handler = sigchld_handler};
745
746   sigaction(SIGCHLD, &sa, NULL);
747
748 #if defined(HAVE_SYS_CAPABILITY_H) && defined(CAP_SETUID) && defined(CAP_SETGID)
749   if ((check_capability(CAP_SETUID) != 0) ||
750       (check_capability(CAP_SETGID) != 0)) {
751     if (getuid() == 0)
752       WARNING(
753           "exec plugin: Running collectd as root, but the CAP_SETUID "
754           "or CAP_SETGID capabilities are missing. The plugin's read function "
755           "will probably fail. Is your init system dropping capabilities?");
756     else
757       WARNING(
758           "exec plugin: collectd doesn't have the CAP_SETUID or "
759           "CAP_SETGID capabilities. If you don't want to run collectd as root, "
760           "try running \"setcap 'cap_setuid=ep cap_setgid=ep'\" on the "
761           "collectd binary.");
762   }
763 #endif
764
765   return 0;
766 } /* int exec_init }}} */
767
768 static int exec_read(void) /* {{{ */
769 {
770   for (program_list_t *pl = pl_head; pl != NULL; pl = pl->next) {
771     pthread_t t;
772     pthread_attr_t attr;
773
774     /* Only execute `normal' style executables here. */
775     if ((pl->flags & PL_NORMAL) == 0)
776       continue;
777
778     pthread_mutex_lock(&pl_lock);
779     /* Skip if a child is already running. */
780     if ((pl->flags & PL_RUNNING) != 0) {
781       pthread_mutex_unlock(&pl_lock);
782       continue;
783     }
784     pl->flags |= PL_RUNNING;
785     pthread_mutex_unlock(&pl_lock);
786
787     pthread_attr_init(&attr);
788     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
789     plugin_thread_create(&t, &attr, exec_read_one, (void *)pl, "exec read");
790     pthread_attr_destroy(&attr);
791   } /* for (pl) */
792
793   return 0;
794 } /* int exec_read }}} */
795
796 static int exec_notification(const notification_t *n, /* {{{ */
797                              user_data_t __attribute__((unused)) * user_data) {
798   program_list_and_notification_t *pln;
799
800   for (program_list_t *pl = pl_head; pl != NULL; pl = pl->next) {
801     pthread_t t;
802     pthread_attr_t attr;
803
804     /* Only execute `notification' style executables here. */
805     if ((pl->flags & PL_NOTIF_ACTION) == 0)
806       continue;
807
808     /* Skip if a child is already running. */
809     if (pl->pid != 0)
810       continue;
811
812     pln = malloc(sizeof(*pln));
813     if (pln == NULL) {
814       ERROR("exec plugin: malloc failed.");
815       continue;
816     }
817
818     pln->pl = pl;
819     memcpy(&pln->n, n, sizeof(notification_t));
820
821     /* Set the `meta' member to NULL, otherwise `plugin_notification_meta_copy'
822      * will run into an endless loop. */
823     pln->n.meta = NULL;
824     plugin_notification_meta_copy(&pln->n, n);
825
826     pthread_attr_init(&attr);
827     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
828     plugin_thread_create(&t, &attr, exec_notification_one, (void *)pln,
829                          "exec notify");
830     pthread_attr_destroy(&attr);
831   } /* for (pl) */
832
833   return 0;
834 } /* }}} int exec_notification */
835
836 static int exec_shutdown(void) /* {{{ */
837 {
838   program_list_t *pl;
839   program_list_t *next;
840
841   pl = pl_head;
842   while (pl != NULL) {
843     next = pl->next;
844
845     if (pl->pid > 0) {
846       kill(pl->pid, SIGTERM);
847       INFO("exec plugin: Sent SIGTERM to %hu", (unsigned short int)pl->pid);
848     }
849
850     sfree(pl->user);
851     sfree(pl);
852
853     pl = next;
854   } /* while (pl) */
855   pl_head = NULL;
856
857   return 0;
858 } /* int exec_shutdown }}} */
859
860 void module_register(void) {
861   plugin_register_complex_config("exec", exec_config);
862   plugin_register_init("exec", exec_init);
863   plugin_register_read("exec", exec_read);
864   plugin_register_notification("exec", exec_notification,
865                                /* user_data = */ NULL);
866   plugin_register_shutdown("exec", exec_shutdown);
867 } /* void module_register */