Code

Merge pull request #2320 from maryamtahhan/feat_snmp_compilation_issue
[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  **/
26 #define _DEFAULT_SOURCE
27 #define _BSD_SOURCE /* For setgroups */
29 #include "collectd.h"
31 #include "common.h"
32 #include "plugin.h"
34 #include "utils_cmd_putnotif.h"
35 #include "utils_cmd_putval.h"
37 #include <grp.h>
38 #include <pwd.h>
39 #include <signal.h>
40 #include <sys/types.h>
42 #ifdef HAVE_SYS_CAPABILITY_H
43 #include <sys/capability.h>
44 #endif
46 #define PL_NORMAL 0x01
47 #define PL_NOTIF_ACTION 0x02
49 #define PL_RUNNING 0x10
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 };
75 typedef struct program_list_and_notification_s {
76   program_list_t *pl;
77   notification_t n;
78 } program_list_and_notification_t;
80 /*
81  * Private variables
82  */
83 static program_list_t *pl_head = NULL;
84 static pthread_mutex_t pl_lock = PTHREAD_MUTEX_INITIALIZER;
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 }}} */
103 static int exec_config_exec(oconfig_item_t *ci) /* {{{ */
105   program_list_t *pl;
106   char buffer[128];
107   int i;
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   }
127   pl = calloc(1, sizeof(*pl));
128   if (pl == NULL) {
129     ERROR("exec plugin: calloc failed.");
130     return -1;
131   }
133   if (strcasecmp("NotificationExec", ci->key) == 0)
134     pl->flags |= PL_NOTIF_ACTION;
135   else
136     pl->flags |= PL_NORMAL;
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   }
145   pl->group = strchr(pl->user, ':');
146   if (pl->group != NULL) {
147     *pl->group = '\0';
148     pl->group++;
149   }
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   }
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   }
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   }
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         ssnprintf(buffer, sizeof(buffer), "%lf",
191                   ci->values[i + 1].value.number);
192       } else {
193         if (ci->values[i + 1].value.boolean)
194           sstrncpy(buffer, "true", sizeof(buffer));
195         else
196           sstrncpy(buffer, "false", sizeof(buffer));
197       }
199       pl->argv[i] = strdup(buffer);
200     }
202     if (pl->argv[i] == NULL) {
203       ERROR("exec plugin: strdup failed.");
204       break;
205     }
206   } /* for (i) */
208   if (i < (ci->values_num - 1)) {
209     while ((--i) >= 0) {
210       sfree(pl->argv[i]);
211     }
212     sfree(pl->argv);
213     sfree(pl->exec);
214     sfree(pl->user);
215     sfree(pl);
216     return -1;
217   }
219   for (i = 0; pl->argv[i] != NULL; i++) {
220     DEBUG("exec plugin: argv[%i] = %s", i, pl->argv[i]);
221   }
223   pl->next = pl_head;
224   pl_head = pl;
226   return 0;
227 } /* int exec_config_exec }}} */
229 static int exec_config(oconfig_item_t *ci) /* {{{ */
231   for (int i = 0; i < ci->children_num; i++) {
232     oconfig_item_t *child = ci->children + i;
233     if ((strcasecmp("Exec", child->key) == 0) ||
234         (strcasecmp("NotificationExec", child->key) == 0))
235       exec_config_exec(child);
236     else {
237       WARNING("exec plugin: Unknown config option `%s'.", child->key);
238     }
239   } /* for (i) */
241   return 0;
242 } /* int exec_config }}} */
244 static void set_environment(void) /* {{{ */
246   char buffer[1024];
248 #ifdef HAVE_SETENV
249   ssnprintf(buffer, sizeof(buffer), "%.3f",
250             CDTIME_T_TO_DOUBLE(plugin_get_interval()));
251   setenv("COLLECTD_INTERVAL", buffer, /* overwrite = */ 1);
253   sstrncpy(buffer, hostname_g, sizeof(buffer));
254   setenv("COLLECTD_HOSTNAME", buffer, /* overwrite = */ 1);
255 #else
256   ssnprintf(buffer, sizeof(buffer), "COLLECTD_INTERVAL=%.3f",
257             CDTIME_T_TO_DOUBLE(plugin_get_interval()));
258   putenv(buffer);
260   ssnprintf(buffer, sizeof(buffer), "COLLECTD_HOSTNAME=%s", hostname_g);
261   putenv(buffer);
262 #endif
263 } /* }}} void set_environment */
265 __attribute__((noreturn)) static void exec_child(program_list_t *pl, int uid,
266                                                  int gid, int egid) /* {{{ */
268   int status;
269   char errbuf[1024];
271 #if HAVE_SETGROUPS
272   if (getuid() == 0) {
273     gid_t glist[2];
274     size_t glist_len;
276     glist[0] = gid;
277     glist_len = 1;
279     if ((gid != egid) && (egid != -1)) {
280       glist[1] = egid;
281       glist_len = 2;
282     }
284     setgroups(glist_len, glist);
285   }
286 #endif /* HAVE_SETGROUPS */
288   status = setgid(gid);
289   if (status != 0) {
290     ERROR("exec plugin: setgid (%i) failed: %s", gid,
291           sstrerror(errno, errbuf, sizeof(errbuf)));
292     exit(-1);
293   }
295   if (egid != -1) {
296     status = setegid(egid);
297     if (status != 0) {
298       ERROR("exec plugin: setegid (%i) failed: %s", egid,
299             sstrerror(errno, errbuf, sizeof(errbuf)));
300       exit(-1);
301     }
302   }
304   status = setuid(uid);
305   if (status != 0) {
306     ERROR("exec plugin: setuid (%i) failed: %s", uid,
307           sstrerror(errno, errbuf, sizeof(errbuf)));
308     exit(-1);
309   }
311   execvp(pl->exec, pl->argv);
313   ERROR("exec plugin: Failed to execute ``%s'': %s", pl->exec,
314         sstrerror(errno, errbuf, sizeof(errbuf)));
315   exit(-1);
316 } /* void exec_child }}} */
318 static void reset_signal_mask(void) /* {{{ */
320   sigset_t ss;
322   sigemptyset(&ss);
323   sigprocmask(SIG_SETMASK, &ss, /* old mask = */ NULL);
324 } /* }}} void reset_signal_mask */
326 static int create_pipe(int fd_pipe[2]) /* {{{ */
328   char errbuf[1024];
329   int status;
331   status = pipe(fd_pipe);
332   if (status != 0) {
333     ERROR("exec plugin: pipe failed: %s",
334           sstrerror(errno, errbuf, sizeof(errbuf)));
335     return -1;
336   }
338   return 0;
339 } /* }}} int create_pipe */
341 static void close_pipe(int fd_pipe[2]) /* {{{ */
343   if (fd_pipe[0] != -1)
344     close(fd_pipe[0]);
346   if (fd_pipe[1] != -1)
347     close(fd_pipe[1]);
348 } /* }}} void close_pipe */
350 /*
351  * Creates three pipes (one for reading, one for writing and one for errors),
352  * forks a child, sets up the pipes so that fd_in is connected to STDIN of
353  * the child and fd_out is connected to STDOUT and fd_err is connected to STDERR
354  * of the child. Then is calls `exec_child'.
355  */
356 static int fork_child(program_list_t *pl, int *fd_in, int *fd_out,
357                       int *fd_err) /* {{{ */
359   int fd_pipe_in[2] = {-1, -1};
360   int fd_pipe_out[2] = {-1, -1};
361   int fd_pipe_err[2] = {-1, -1};
362   char errbuf[1024];
363   int status;
364   int pid;
366   int uid;
367   int gid;
368   int egid;
370   struct passwd *sp_ptr;
371   struct passwd sp;
372   char nambuf[2048];
374   if (pl->pid != 0)
375     return -1;
377   if ((create_pipe(fd_pipe_in) == -1) || (create_pipe(fd_pipe_out) == -1) ||
378       (create_pipe(fd_pipe_err) == -1))
379     goto failed;
381   sp_ptr = NULL;
382   status = getpwnam_r(pl->user, &sp, nambuf, sizeof(nambuf), &sp_ptr);
383   if (status != 0) {
384     ERROR("exec plugin: Failed to get user information for user ``%s'': %s",
385           pl->user, sstrerror(errno, errbuf, sizeof(errbuf)));
386     goto failed;
387   }
389   if (sp_ptr == NULL) {
390     ERROR("exec plugin: No such user: `%s'", pl->user);
391     goto failed;
392   }
394   uid = sp.pw_uid;
395   gid = sp.pw_gid;
396   if (uid == 0) {
397     ERROR("exec plugin: Cowardly refusing to exec program as root.");
398     goto failed;
399   }
401   /* The group configured in the configfile is set as effective group, because
402    * this way the forked process can (re-)gain the user's primary group. */
403   egid = -1;
404   if (NULL != pl->group) {
405     if ('\0' != *pl->group) {
406       struct group *gr_ptr = NULL;
407       struct group gr;
409       status = getgrnam_r(pl->group, &gr, nambuf, sizeof(nambuf), &gr_ptr);
410       if (0 != status) {
411         ERROR("exec plugin: Failed to get group information "
412               "for group ``%s'': %s",
413               pl->group, sstrerror(errno, errbuf, sizeof(errbuf)));
414         goto failed;
415       }
416       if (NULL == gr_ptr) {
417         ERROR("exec plugin: No such group: `%s'", pl->group);
418         goto failed;
419       }
421       egid = gr.gr_gid;
422     } else {
423       egid = gid;
424     }
425   } /* if (pl->group == NULL) */
427   pid = fork();
428   if (pid < 0) {
429     ERROR("exec plugin: fork failed: %s",
430           sstrerror(errno, errbuf, sizeof(errbuf)));
431     goto failed;
432   } else if (pid == 0) {
433     int fd_num;
435     /* Close all file descriptors but the pipe end we need. */
436     fd_num = getdtablesize();
437     for (int fd = 0; fd < fd_num; fd++) {
438       if ((fd == fd_pipe_in[0]) || (fd == fd_pipe_out[1]) ||
439           (fd == fd_pipe_err[1]))
440         continue;
441       close(fd);
442     }
444     /* Connect the `in' pipe to STDIN */
445     if (fd_pipe_in[0] != STDIN_FILENO) {
446       dup2(fd_pipe_in[0], STDIN_FILENO);
447       close(fd_pipe_in[0]);
448     }
450     /* Now connect the `out' pipe to STDOUT */
451     if (fd_pipe_out[1] != STDOUT_FILENO) {
452       dup2(fd_pipe_out[1], STDOUT_FILENO);
453       close(fd_pipe_out[1]);
454     }
456     /* Now connect the `err' pipe to STDERR */
457     if (fd_pipe_err[1] != STDERR_FILENO) {
458       dup2(fd_pipe_err[1], STDERR_FILENO);
459       close(fd_pipe_err[1]);
460     }
462     set_environment();
464     /* Unblock all signals */
465     reset_signal_mask();
467     exec_child(pl, uid, gid, egid);
468     /* does not return */
469   }
471   close(fd_pipe_in[0]);
472   close(fd_pipe_out[1]);
473   close(fd_pipe_err[1]);
475   if (fd_in != NULL)
476     *fd_in = fd_pipe_in[1];
477   else
478     close(fd_pipe_in[1]);
480   if (fd_out != NULL)
481     *fd_out = fd_pipe_out[0];
482   else
483     close(fd_pipe_out[0]);
485   if (fd_err != NULL)
486     *fd_err = fd_pipe_err[0];
487   else
488     close(fd_pipe_err[0]);
490   return pid;
492 failed:
493   close_pipe(fd_pipe_in);
494   close_pipe(fd_pipe_out);
495   close_pipe(fd_pipe_err);
497   return -1;
498 } /* int fork_child }}} */
500 static int parse_line(char *buffer) /* {{{ */
502   if (strncasecmp("PUTVAL", buffer, strlen("PUTVAL")) == 0)
503     return cmd_handle_putval(stdout, buffer);
504   else if (strncasecmp("PUTNOTIF", buffer, strlen("PUTNOTIF")) == 0)
505     return handle_putnotif(stdout, buffer);
506   else {
507     ERROR("exec plugin: Unable to parse command, ignoring line: \"%s\"",
508           buffer);
509     return -1;
510   }
511 } /* int parse_line }}} */
513 static void *exec_read_one(void *arg) /* {{{ */
515   program_list_t *pl = (program_list_t *)arg;
516   int fd, fd_err, highest_fd;
517   fd_set fdset, copy;
518   int status;
519   char buffer[1200]; /* if not completely read */
520   char buffer_err[1024];
521   char *pbuffer = buffer;
522   char *pbuffer_err = buffer_err;
524   status = fork_child(pl, NULL, &fd, &fd_err);
525   if (status < 0) {
526     /* Reset the "running" flag */
527     pthread_mutex_lock(&pl_lock);
528     pl->flags &= ~PL_RUNNING;
529     pthread_mutex_unlock(&pl_lock);
530     pthread_exit((void *)1);
531   }
532   pl->pid = status;
534   assert(pl->pid != 0);
536   FD_ZERO(&fdset);
537   FD_SET(fd, &fdset);
538   FD_SET(fd_err, &fdset);
540   /* Determine the highest file descriptor */
541   highest_fd = (fd > fd_err) ? fd : fd_err;
543   /* We use a copy of fdset, as select modifies it */
544   copy = fdset;
546   while (1) {
547     int len;
549     status = select(highest_fd + 1, &copy, NULL, NULL, NULL);
550     if (status < 0) {
551       if (errno == EINTR)
552         continue;
553       break;
554     }
556     if (FD_ISSET(fd, &copy)) {
557       char *pnl;
559       len = read(fd, pbuffer, sizeof(buffer) - 1 - (pbuffer - buffer));
561       if (len < 0) {
562         if (errno == EAGAIN || errno == EINTR)
563           continue;
564         break;
565       } else if (len == 0)
566         break; /* We've reached EOF */
568       pbuffer[len] = '\0';
570       len += pbuffer - buffer;
571       pbuffer = buffer;
573       while ((pnl = strchr(pbuffer, '\n'))) {
574         *pnl = '\0';
575         if (*(pnl - 1) == '\r')
576           *(pnl - 1) = '\0';
578         parse_line(pbuffer);
580         pbuffer = ++pnl;
581       }
582       /* not completely read ? */
583       if (pbuffer - buffer < len) {
584         len -= pbuffer - buffer;
585         memmove(buffer, pbuffer, len);
586         pbuffer = buffer + len;
587       } else
588         pbuffer = buffer;
589     } else if (FD_ISSET(fd_err, &copy)) {
590       char *pnl;
592       len = read(fd_err, pbuffer_err,
593                  sizeof(buffer_err) - 1 - (pbuffer_err - buffer_err));
595       if (len < 0) {
596         if (errno == EAGAIN || errno == EINTR)
597           continue;
598         break;
599       } else if (len == 0) {
600         /* We've reached EOF */
601         NOTICE("exec plugin: Program `%s' has closed STDERR.", pl->exec);
603         /* Remove file descriptor form select() set. */
604         FD_CLR(fd_err, &fdset);
605         copy = fdset;
606         highest_fd = fd;
608         /* Clean up file descriptor */
609         close(fd_err);
610         fd_err = -1;
611         continue;
612       }
614       pbuffer_err[len] = '\0';
616       len += pbuffer_err - buffer_err;
617       pbuffer_err = buffer_err;
619       while ((pnl = strchr(pbuffer_err, '\n'))) {
620         *pnl = '\0';
621         if (*(pnl - 1) == '\r')
622           *(pnl - 1) = '\0';
624         ERROR("exec plugin: exec_read_one: error = %s", pbuffer_err);
626         pbuffer_err = ++pnl;
627       }
628       /* not completely read ? */
629       if (pbuffer_err - buffer_err < len) {
630         len -= pbuffer_err - buffer_err;
631         memmove(buffer_err, pbuffer_err, len);
632         pbuffer_err = buffer_err + len;
633       } else
634         pbuffer_err = buffer_err;
635     }
636     /* reset copy */
637     copy = fdset;
638   }
640   DEBUG("exec plugin: exec_read_one: Waiting for `%s' to exit.", pl->exec);
641   if (waitpid(pl->pid, &status, 0) > 0)
642     pl->status = status;
644   DEBUG("exec plugin: Child %i exited with status %i.", (int)pl->pid,
645         pl->status);
647   pl->pid = 0;
649   pthread_mutex_lock(&pl_lock);
650   pl->flags &= ~PL_RUNNING;
651   pthread_mutex_unlock(&pl_lock);
653   close(fd);
654   if (fd_err >= 0)
655     close(fd_err);
657   pthread_exit((void *)0);
658   return NULL;
659 } /* void *exec_read_one }}} */
661 static void *exec_notification_one(void *arg) /* {{{ */
663   program_list_t *pl = ((program_list_and_notification_t *)arg)->pl;
664   notification_t *n = &((program_list_and_notification_t *)arg)->n;
665   int fd;
666   FILE *fh;
667   int pid;
668   int status;
669   const char *severity;
671   pid = fork_child(pl, &fd, NULL, NULL);
672   if (pid < 0) {
673     sfree(arg);
674     pthread_exit((void *)1);
675   }
677   fh = fdopen(fd, "w");
678   if (fh == NULL) {
679     char errbuf[1024];
680     ERROR("exec plugin: fdopen (%i) failed: %s", fd,
681           sstrerror(errno, errbuf, sizeof(errbuf)));
682     kill(pid, SIGTERM);
683     close(fd);
684     sfree(arg);
685     pthread_exit((void *)1);
686   }
688   severity = "FAILURE";
689   if (n->severity == NOTIF_WARNING)
690     severity = "WARNING";
691   else if (n->severity == NOTIF_OKAY)
692     severity = "OKAY";
694   fprintf(fh, "Severity: %s\n"
695               "Time: %.3f\n",
696           severity, CDTIME_T_TO_DOUBLE(n->time));
698   /* Print the optional fields */
699   if (strlen(n->host) > 0)
700     fprintf(fh, "Host: %s\n", n->host);
701   if (strlen(n->plugin) > 0)
702     fprintf(fh, "Plugin: %s\n", n->plugin);
703   if (strlen(n->plugin_instance) > 0)
704     fprintf(fh, "PluginInstance: %s\n", n->plugin_instance);
705   if (strlen(n->type) > 0)
706     fprintf(fh, "Type: %s\n", n->type);
707   if (strlen(n->type_instance) > 0)
708     fprintf(fh, "TypeInstance: %s\n", n->type_instance);
710   for (notification_meta_t *meta = n->meta; meta != NULL; meta = meta->next) {
711     if (meta->type == NM_TYPE_STRING)
712       fprintf(fh, "%s: %s\n", meta->name, meta->nm_value.nm_string);
713     else if (meta->type == NM_TYPE_SIGNED_INT)
714       fprintf(fh, "%s: %" PRIi64 "\n", meta->name,
715               meta->nm_value.nm_signed_int);
716     else if (meta->type == NM_TYPE_UNSIGNED_INT)
717       fprintf(fh, "%s: %" PRIu64 "\n", meta->name,
718               meta->nm_value.nm_unsigned_int);
719     else if (meta->type == NM_TYPE_DOUBLE)
720       fprintf(fh, "%s: %e\n", meta->name, meta->nm_value.nm_double);
721     else if (meta->type == NM_TYPE_BOOLEAN)
722       fprintf(fh, "%s: %s\n", meta->name,
723               meta->nm_value.nm_boolean ? "true" : "false");
724   }
726   fprintf(fh, "\n%s\n", n->message);
728   fflush(fh);
729   fclose(fh);
731   waitpid(pid, &status, 0);
733   DEBUG("exec plugin: Child %i exited with status %i.", pid, status);
735   if (n->meta != NULL)
736     plugin_notification_meta_free(n->meta);
737   n->meta = NULL;
738   sfree(arg);
739   pthread_exit((void *)0);
740   return NULL;
741 } /* void *exec_notification_one }}} */
743 static int exec_init(void) /* {{{ */
745   struct sigaction sa = {.sa_handler = sigchld_handler};
747   sigaction(SIGCHLD, &sa, NULL);
749 #if defined(HAVE_SYS_CAPABILITY_H) && defined(CAP_SETUID) && defined(CAP_SETGID)
750   if ((check_capability(CAP_SETUID) != 0) ||
751       (check_capability(CAP_SETGID) != 0)) {
752     if (getuid() == 0)
753       WARNING(
754           "exec plugin: Running collectd as root, but the CAP_SETUID "
755           "or CAP_SETGID capabilities are missing. The plugin's read function "
756           "will probably fail. Is your init system dropping capabilities?");
757     else
758       WARNING(
759           "exec plugin: collectd doesn't have the CAP_SETUID or "
760           "CAP_SETGID capabilities. If you don't want to run collectd as root, "
761           "try running \"setcap 'cap_setuid=ep cap_setgid=ep'\" on the "
762           "collectd binary.");
763   }
764 #endif
766   return 0;
767 } /* int exec_init }}} */
769 static int exec_read(void) /* {{{ */
771   for (program_list_t *pl = pl_head; pl != NULL; pl = pl->next) {
772     pthread_t t;
773     pthread_attr_t attr;
775     /* Only execute `normal' style executables here. */
776     if ((pl->flags & PL_NORMAL) == 0)
777       continue;
779     pthread_mutex_lock(&pl_lock);
780     /* Skip if a child is already running. */
781     if ((pl->flags & PL_RUNNING) != 0) {
782       pthread_mutex_unlock(&pl_lock);
783       continue;
784     }
785     pl->flags |= PL_RUNNING;
786     pthread_mutex_unlock(&pl_lock);
788     pthread_attr_init(&attr);
789     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
790     plugin_thread_create(&t, &attr, exec_read_one, (void *)pl, "exec read");
791     pthread_attr_destroy(&attr);
792   } /* for (pl) */
794   return 0;
795 } /* int exec_read }}} */
797 static int exec_notification(const notification_t *n, /* {{{ */
798                              user_data_t __attribute__((unused)) * user_data) {
799   program_list_and_notification_t *pln;
801   for (program_list_t *pl = pl_head; pl != NULL; pl = pl->next) {
802     pthread_t t;
803     pthread_attr_t attr;
805     /* Only execute `notification' style executables here. */
806     if ((pl->flags & PL_NOTIF_ACTION) == 0)
807       continue;
809     /* Skip if a child is already running. */
810     if (pl->pid != 0)
811       continue;
813     pln = malloc(sizeof(*pln));
814     if (pln == NULL) {
815       ERROR("exec plugin: malloc failed.");
816       continue;
817     }
819     pln->pl = pl;
820     memcpy(&pln->n, n, sizeof(notification_t));
822     /* Set the `meta' member to NULL, otherwise `plugin_notification_meta_copy'
823      * will run into an endless loop. */
824     pln->n.meta = NULL;
825     plugin_notification_meta_copy(&pln->n, n);
827     pthread_attr_init(&attr);
828     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
829     plugin_thread_create(&t, &attr, exec_notification_one, (void *)pln,
830                          "exec notify");
831     pthread_attr_destroy(&attr);
832   } /* for (pl) */
834   return 0;
835 } /* }}} int exec_notification */
837 static int exec_shutdown(void) /* {{{ */
839   program_list_t *pl;
840   program_list_t *next;
842   pl = pl_head;
843   while (pl != NULL) {
844     next = pl->next;
846     if (pl->pid > 0) {
847       kill(pl->pid, SIGTERM);
848       INFO("exec plugin: Sent SIGTERM to %hu", (unsigned short int)pl->pid);
849     }
851     sfree(pl->user);
852     sfree(pl);
854     pl = next;
855   } /* while (pl) */
856   pl_head = NULL;
858   return 0;
859 } /* int exec_shutdown }}} */
861 void module_register(void) {
862   plugin_register_complex_config("exec", exec_config);
863   plugin_register_init("exec", exec_init);
864   plugin_register_read("exec", exec_read);
865   plugin_register_notification("exec", exec_notification,
866                                /* user_data = */ NULL);
867   plugin_register_shutdown("exec", exec_shutdown);
868 } /* void module_register */