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