Code

Merge branch 'collectd-4.2' into collectd-4.3
[collectd.git] / src / exec.c
1 /**
2  * collectd - src/exec.c
3  * Copyright (C) 2007,2008  Florian octo Forster
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by the
7  * Free Software Foundation; only version 2 of the License is applicable.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
17  *
18  * Authors:
19  *   Florian octo Forster <octo at verplant.org>
20  **/
22 #include "collectd.h"
23 #include "common.h"
24 #include "plugin.h"
26 #include "utils_cmd_putval.h"
27 #include "utils_cmd_putnotif.h"
29 #include <sys/types.h>
30 #include <pwd.h>
31 #include <grp.h>
32 #include <signal.h>
34 #include <pthread.h>
36 #define PL_NORMAL        0x01
37 #define PL_NOTIF_ACTION  0x02
39 #define PL_RUNNING       0x10
41 /*
42  * Private data types
43  */
44 /*
45  * Access to this structure is serialized using the `pl_lock' lock and the
46  * `PL_RUNNING' flag. The execution of notifications is *not* serialized, so
47  * all functions used to handle notifications MUST NOT write to this structure.
48  * The `pid' and `status' fields are thus unused if the `PL_NOTIF_ACTION' flag
49  * is set.
50  * The `PL_RUNNING' flag is set in `exec_read' and unset in `exec_read_one'.
51  */
52 struct program_list_s;
53 typedef struct program_list_s program_list_t;
54 struct program_list_s
55 {
56   char           *user;
57   char           *group;
58   char           *exec;
59   char          **argv;
60   int             pid;
61   int             status;
62   int             flags;
63   program_list_t *next;
64 };
66 typedef struct program_list_and_notification_s
67 {
68   program_list_t *pl;
69   notification_t n;
70 } program_list_and_notification_t;
72 /*
73  * Private variables
74  */
75 static program_list_t *pl_head = NULL;
76 static pthread_mutex_t pl_lock = PTHREAD_MUTEX_INITIALIZER;
78 /*
79  * Functions
80  */
81 static void sigchld_handler (int signal) /* {{{ */
82 {
83   pid_t pid;
84   int status;
85   while ((pid = waitpid (-1, &status, WNOHANG)) > 0)
86   {
87     program_list_t *pl;
88     for (pl = pl_head; pl != NULL; pl = pl->next)
89       if (pl->pid == pid)
90         break;
91     if (pl != NULL)
92       pl->status = status;
93   } /* while (waitpid) */
94 } /* void sigchld_handler }}} */
96 static int exec_config_exec (oconfig_item_t *ci) /* {{{ */
97 {
98   program_list_t *pl;
99   char buffer[128];
100   int i;
102   if (ci->children_num != 0)
103   {
104     WARNING ("exec plugin: The config option `%s' may not be a block.",
105         ci->key);
106     return (-1);
107   }
108   if (ci->values_num < 2)
109   {
110     WARNING ("exec plugin: The config option `%s' needs at least two "
111         "arguments.", ci->key);
112     return (-1);
113   }
114   if ((ci->values[0].type != OCONFIG_TYPE_STRING)
115       || (ci->values[1].type != OCONFIG_TYPE_STRING))
116   {
117     WARNING ("exec plugin: The first two arguments to the `%s' option must "
118         "be string arguments.", ci->key);
119     return (-1);
120   }
122   pl = (program_list_t *) malloc (sizeof (program_list_t));
123   if (pl == NULL)
124   {
125     ERROR ("exec plugin: malloc failed.");
126     return (-1);
127   }
128   memset (pl, '\0', sizeof (program_list_t));
130   if (strcasecmp ("NotificationExec", ci->key) == 0)
131     pl->flags |= PL_NOTIF_ACTION;
132   else
133     pl->flags |= PL_NORMAL;
135   pl->user = strdup (ci->values[0].value.string);
136   if (pl->user == NULL)
137   {
138     ERROR ("exec plugin: strdup failed.");
139     sfree (pl);
140     return (-1);
141   }
143   pl->group = strchr (pl->user, ':');
144   if (pl->group != NULL)
145   {
146     *pl->group = '\0';
147     pl->group++;
148   }
150   pl->exec = strdup (ci->values[1].value.string);
151   if (pl->exec == NULL)
152   {
153     ERROR ("exec plugin: strdup failed.");
154     sfree (pl->user);
155     sfree (pl);
156     return (-1);
157   }
159   pl->argv = (char **) malloc (ci->values_num * sizeof (char *));
160   if (pl->argv == NULL)
161   {
162     ERROR ("exec plugin: malloc failed.");
163     sfree (pl->exec);
164     sfree (pl->user);
165     sfree (pl);
166     return (-1);
167   }
168   memset (pl->argv, '\0', ci->values_num * sizeof (char *));
170   {
171     char *tmp = strrchr (ci->values[1].value.string, '/');
172     if (tmp == NULL)
173       strncpy (buffer, ci->values[1].value.string, sizeof (buffer));
174     else
175       strncpy (buffer, tmp + 1, sizeof (buffer));
176     buffer[sizeof (buffer) - 1] = '\0';
177   }
178   pl->argv[0] = strdup (buffer);
179   if (pl->argv[0] == NULL)
180   {
181     ERROR ("exec plugin: malloc failed.");
182     sfree (pl->argv);
183     sfree (pl->exec);
184     sfree (pl->user);
185     sfree (pl);
186     return (-1);
187   }
189   for (i = 1; i < (ci->values_num - 1); i++)
190   {
191     if (ci->values[i + 1].type == OCONFIG_TYPE_STRING)
192     {
193       pl->argv[i] = strdup (ci->values[i + 1].value.string);
194     }
195     else
196     {
197       if (ci->values[i + 1].type == OCONFIG_TYPE_NUMBER)
198       {
199         snprintf (buffer, sizeof (buffer), "%lf",
200             ci->values[i + 1].value.number);
201       }
202       else
203       {
204         if (ci->values[i + 1].value.boolean)
205           strncpy (buffer, "true", sizeof (buffer));
206         else
207           strncpy (buffer, "false", sizeof (buffer));
208       }
209       buffer[sizeof (buffer) - 1] = '\0';
211       pl->argv[i] = strdup (buffer);
212     }
214     if (pl->argv[i] == NULL)
215     {
216       ERROR ("exec plugin: strdup failed.");
217       break;
218     }
219   } /* for (i) */
221   if (i < (ci->values_num - 1))
222   {
223     while ((--i) >= 0)
224     {
225       sfree (pl->argv[i]);
226     }
227     sfree (pl->argv);
228     sfree (pl->exec);
229     sfree (pl->user);
230     sfree (pl);
231     return (-1);
232   }
234   for (i = 0; pl->argv[i] != NULL; i++)
235   {
236     DEBUG ("exec plugin: argv[%i] = %s", i, pl->argv[i]);
237   }
239   pl->next = pl_head;
240   pl_head = pl;
242   return (0);
243 } /* int exec_config_exec }}} */
245 static int exec_config (oconfig_item_t *ci) /* {{{ */
247   int i;
249   for (i = 0; i < ci->children_num; i++)
250   {
251     oconfig_item_t *child = ci->children + i;
252     if ((strcasecmp ("Exec", child->key) == 0)
253         || (strcasecmp ("NotificationExec", child->key) == 0))
254       exec_config_exec (child);
255     else
256     {
257       WARNING ("exec plugin: Unknown config option `%s'.", child->key);
258     }
259   } /* for (i) */
261   return (0);
262 } /* int exec_config }}} */
264 static void exec_child (program_list_t *pl) /* {{{ */
266   int status;
267   int uid;
268   int gid;
269   int egid;
271   struct passwd *sp_ptr;
272   struct passwd sp;
273   char nambuf[2048];
274   char errbuf[1024];
276   sp_ptr = NULL;
277   status = getpwnam_r (pl->user, &sp, nambuf, sizeof (nambuf), &sp_ptr);
278   if (status != 0)
279   {
280     ERROR ("exec plugin: getpwnam_r failed: %s",
281         sstrerror (errno, errbuf, sizeof (errbuf)));
282     exit (-1);
283   }
284   if (sp_ptr == NULL)
285   {
286     ERROR ("exec plugin: No such user: `%s'", pl->user);
287     exit (-1);
288   }
290   uid = sp.pw_uid;
291   gid = sp.pw_gid;
292   if (uid == 0)
293   {
294     ERROR ("exec plugin: Cowardly refusing to exec program as root.");
295     exit (-1);
296   }
298   /* The group configured in the configfile is set as effective group, because
299    * this way the forked process can (re-)gain the user's primary group. */
300   egid = -1;
301   if (NULL != pl->group)
302   {
303     if ('\0' != *pl->group) {
304       struct group *gr_ptr = NULL;
305       struct group gr;
307       status = getgrnam_r (pl->group, &gr, nambuf, sizeof (nambuf), &gr_ptr);
308       if (0 != status)
309       {
310         ERROR ("exec plugin: getgrnam_r failed: %s",
311             sstrerror (errno, errbuf, sizeof (errbuf)));
312         exit (-1);
313       }
314       if (NULL == gr_ptr)
315       {
316         ERROR ("exec plugin: No such group: `%s'", pl->group);
317         exit (-1);
318       }
320       egid = gr.gr_gid;
321     }
322     else
323     {
324       egid = gid;
325     }
326   } /* if (pl->group == NULL) */
328 #if HAVE_SETGROUPS
329   if (getuid () == 0)
330   {
331     gid_t  glist[2];
332     size_t glist_len;
334     glist[0] = gid;
335     glist_len = 1;
337     if ((gid != egid) && (egid != -1))
338     {
339       glist[1] = egid;
340       glist_len = 2;
341     }
343     setgroups (glist_len, glist);
344   }
345 #endif /* HAVE_SETGROUPS */
347   status = setgid (gid);
348   if (status != 0)
349   {
350     ERROR ("exec plugin: setgid (%i) failed: %s",
351         gid, sstrerror (errno, errbuf, sizeof (errbuf)));
352     exit (-1);
353   }
355   if (egid != -1)
356   {
357     status = setegid (egid);
358     if (status != 0)
359     {
360       ERROR ("exec plugin: setegid (%i) failed: %s",
361           egid, sstrerror (errno, errbuf, sizeof (errbuf)));
362       exit (-1);
363     }
364   }
366   status = setuid (uid);
367   if (status != 0)
368   {
369     ERROR ("exec plugin: setuid (%i) failed: %s",
370         uid, sstrerror (errno, errbuf, sizeof (errbuf)));
371     exit (-1);
372   }
374   status = execvp (pl->exec, pl->argv);
376   ERROR ("exec plugin: exec failed: %s",
377       sstrerror (errno, errbuf, sizeof (errbuf)));
378   exit (-1);
379 } /* void exec_child }}} */
381 /*
382  * Creates two pipes (one for reading, ong for writing), forks a child, sets up
383  * the pipes so that fd_in is connected to STDIN of the child and fd_out is
384  * connected to STDOUT and STDERR of the child. Then is calls `exec_child'.
385  */
386 static int fork_child (program_list_t *pl, int *fd_in, int *fd_out) /* {{{ */
388   int fd_pipe_in[2];
389   int fd_pipe_out[2];
390   int status;
391   int pid;
393   if (pl->pid != 0)
394     return (-1);
396   status = pipe (fd_pipe_in);
397   if (status != 0)
398   {
399     char errbuf[1024];
400     ERROR ("exec plugin: pipe failed: %s",
401         sstrerror (errno, errbuf, sizeof (errbuf)));
402     return (-1);
403   }
405   status = pipe (fd_pipe_out);
406   if (status != 0)
407   {
408     char errbuf[1024];
409     ERROR ("exec plugin: pipe failed: %s",
410         sstrerror (errno, errbuf, sizeof (errbuf)));
411     return (-1);
412   }
414   pid = fork ();
415   if (pid < 0)
416   {
417     char errbuf[1024];
418     ERROR ("exec plugin: fork failed: %s",
419         sstrerror (errno, errbuf, sizeof (errbuf)));
420     return (-1);
421   }
422   else if (pid == 0)
423   {
424     close (fd_pipe_in[1]);
425     close (fd_pipe_out[0]);
427     /* If the `out' pipe has the filedescriptor STDIN we have to be careful
428      * with the `dup's below. So, if this is the case we have to handle the
429      * `out' pipe first. */
430     if (fd_pipe_out[1] == STDIN_FILENO)
431     {
432       int new_fileno = (fd_pipe_in[0] == STDOUT_FILENO)
433         ? STDERR_FILENO : STDOUT_FILENO;
434       dup2 (fd_pipe_out[1], new_fileno);
435       close (fd_pipe_out[1]);
436       fd_pipe_out[1] = new_fileno;
437     }
438     /* Now `fd_pipe_out[1]' is either `STDOUT' or `STDERR', but definitely not
439      * `STDIN_FILENO'. */
441     /* Connect the `in' pipe to STDIN */
442     if (fd_pipe_in[0] != STDIN_FILENO)
443     {
444       dup2 (fd_pipe_in[0], STDIN_FILENO);
445       close (fd_pipe_in[0]);
446       fd_pipe_in[0] = STDIN_FILENO;
447     }
449     /* Now connect the `out' pipe to STDOUT and STDERR */
450     if (fd_pipe_out[1] != STDOUT_FILENO)
451       dup2 (fd_pipe_out[1], STDOUT_FILENO);
452     if (fd_pipe_out[1] != STDERR_FILENO)
453       dup2 (fd_pipe_out[1], STDERR_FILENO);
455     /* If the pipe has some FD that's something completely different, close it
456      * now. */
457     if ((fd_pipe_out[1] != STDOUT_FILENO) && (fd_pipe_out[1] != STDERR_FILENO))
458     {
459       close (fd_pipe_out[1]);
460       fd_pipe_out[1] = STDOUT_FILENO;
461     }
463     exec_child (pl);
464     /* does not return */
465   }
467   close (fd_pipe_in[0]);
468   close (fd_pipe_out[1]);
470   if (fd_in != NULL)
471     *fd_in = fd_pipe_in[1];
472   else
473     close (fd_pipe_in[1]);
475   if (fd_out != NULL)
476     *fd_out = fd_pipe_out[0];
477   else
478     close (fd_pipe_out[0]);
480   return (pid);
481 } /* int fork_child }}} */
483 static int parse_line (char *buffer) /* {{{ */
485   char *fields[256];
486   int fields_num;
488   fields[0] = "PUTVAL";
489   fields_num = strsplit (buffer, fields + 1, STATIC_ARRAY_SIZE(fields) - 1);
491   if (strcasecmp (fields[1], "putval") == 0)
492     return (handle_putval (stdout, fields + 1, fields_num));
493   else if (strcasecmp (fields[1], "putnotif") == 0)
494     return (handle_putnotif (stdout, fields + 1, fields_num));
496   /* compatibility code */
497   return (handle_putval (stdout, fields, fields_num + 1));
498 } /* int parse_line }}} */
500 static void *exec_read_one (void *arg) /* {{{ */
502   program_list_t *pl = (program_list_t *) arg;
503   int fd;
504   FILE *fh;
505   char buffer[1024];
506   int status;
508   status = fork_child (pl, NULL, &fd);
509   if (status < 0)
510     pthread_exit ((void *) 1);
511   pl->pid = status;
513   assert (pl->pid != 0);
515   fh = fdopen (fd, "r");
516   if (fh == NULL)
517   {
518     char errbuf[1024];
519     ERROR ("exec plugin: fdopen (%i) failed: %s", fd,
520         sstrerror (errno, errbuf, sizeof (errbuf)));
521     kill (pl->pid, SIGTERM);
522     pl->pid = 0;
523     close (fd);
524     pthread_exit ((void *) 1);
525   }
527   buffer[0] = '\0';
528   while (fgets (buffer, sizeof (buffer), fh) != NULL)
529   {
530     int len;
532     len = strlen (buffer);
534     /* Remove newline from end. */
535     while ((len > 0) && ((buffer[len - 1] == '\n')
536           || (buffer[len - 1] == '\r')))
537       buffer[--len] = '\0';
539     DEBUG ("exec plugin: exec_read_one: buffer = %s", buffer);
541     parse_line (buffer);
542   } /* while (fgets) */
544   fclose (fh);
546   if (waitpid (pl->pid, &status, 0) > 0)
547     pl->status = status;
549   DEBUG ("exec plugin: Child %i exited with status %i.",
550       (int) pl->pid, pl->status);
552   pl->pid = 0;
554   pthread_mutex_lock (&pl_lock);
555   pl->flags &= ~PL_RUNNING;
556   pthread_mutex_unlock (&pl_lock);
558   pthread_exit ((void *) 0);
559   return (NULL);
560 } /* void *exec_read_one }}} */
562 static void *exec_notification_one (void *arg) /* {{{ */
564   program_list_t *pl = ((program_list_and_notification_t *) arg)->pl;
565   const notification_t *n = &((program_list_and_notification_t *) arg)->n;
566   int fd;
567   FILE *fh;
568   int pid;
569   int status;
570   const char *severity;
572   pid = fork_child (pl, &fd, NULL);
573   if (pid < 0) {
574     sfree (arg);
575     pthread_exit ((void *) 1);
576   }
578   fh = fdopen (fd, "w");
579   if (fh == NULL)
580   {
581     char errbuf[1024];
582     ERROR ("exec plugin: fdopen (%i) failed: %s", fd,
583         sstrerror (errno, errbuf, sizeof (errbuf)));
584     kill (pl->pid, SIGTERM);
585     pl->pid = 0;
586     close (fd);
587     sfree (arg);
588     pthread_exit ((void *) 1);
589   }
591   severity = "FAILURE";
592   if (n->severity == NOTIF_WARNING)
593     severity = "WARNING";
594   else if (n->severity == NOTIF_OKAY)
595     severity = "OKAY";
597   fprintf (fh,
598       "Severity: %s\n"
599       "Time: %u\n",
600       severity, (unsigned int) n->time);
602   /* Print the optional fields */
603   if (strlen (n->host) > 0)
604     fprintf (fh, "Host: %s\n", n->host);
605   if (strlen (n->plugin) > 0)
606     fprintf (fh, "Plugin: %s\n", n->plugin);
607   if (strlen (n->plugin_instance) > 0)
608     fprintf (fh, "PluginInstance: %s\n", n->plugin_instance);
609   if (strlen (n->type) > 0)
610     fprintf (fh, "Type: %s\n", n->type);
611   if (strlen (n->type_instance) > 0)
612     fprintf (fh, "TypeInstance: %s\n", n->type_instance);
614   fprintf (fh, "\n%s\n", n->message);
616   fflush (fh);
617   fclose (fh);
619   waitpid (pid, &status, 0);
621   DEBUG ("exec plugin: Child %i exited with status %i.",
622       pid, status);
624   sfree (arg);
625   pthread_exit ((void *) 0);
626   return (NULL);
627 } /* void *exec_notification_one }}} */
629 static int exec_init (void) /* {{{ */
631   struct sigaction sa;
633   memset (&sa, '\0', sizeof (sa));
634   sa.sa_handler = sigchld_handler;
635   sigaction (SIGCHLD, &sa, NULL);
637   return (0);
638 } /* int exec_init }}} */
640 static int exec_read (void) /* {{{ */
642   program_list_t *pl;
644   for (pl = pl_head; pl != NULL; pl = pl->next)
645   {
646     pthread_t t;
647     pthread_attr_t attr;
649     /* Only execute `normal' style executables here. */
650     if ((pl->flags & PL_NORMAL) == 0)
651       continue;
653     pthread_mutex_lock (&pl_lock);
654     /* Skip if a child is already running. */
655     if ((pl->flags & PL_RUNNING) != 0)
656     {
657       pthread_mutex_unlock (&pl_lock);
658       continue;
659     }
660     pl->flags |= PL_RUNNING;
661     pthread_mutex_unlock (&pl_lock);
663     pthread_attr_init (&attr);
664     pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
665     pthread_create (&t, &attr, exec_read_one, (void *) pl);
666   } /* for (pl) */
668   return (0);
669 } /* int exec_read }}} */
671 static int exec_notification (const notification_t *n)
673   program_list_t *pl;
674   program_list_and_notification_t *pln;
676   for (pl = pl_head; pl != NULL; pl = pl->next)
677   {
678     pthread_t t;
679     pthread_attr_t attr;
681     /* Only execute `notification' style executables here. */
682     if ((pl->flags & PL_NOTIF_ACTION) == 0)
683       continue;
685     /* Skip if a child is already running. */
686     if (pl->pid != 0)
687       continue;
689     pln = (program_list_and_notification_t *) malloc (sizeof
690         (program_list_and_notification_t));
691     if (pln == NULL)
692     {
693       ERROR ("exec plugin: malloc failed.");
694       continue;
695     }
697     pln->pl = pl;
698     memcpy (&pln->n, n, sizeof (notification_t));
700     pthread_attr_init (&attr);
701     pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
702     pthread_create (&t, &attr, exec_notification_one, (void *) pln);
703   } /* for (pl) */
705   return (0);
706 } /* int exec_notification */
708 static int exec_shutdown (void) /* {{{ */
710   program_list_t *pl;
711   program_list_t *next;
713   pl = pl_head;
714   while (pl != NULL)
715   {
716     next = pl->next;
718     if (pl->pid > 0)
719     {
720       kill (pl->pid, SIGTERM);
721       INFO ("exec plugin: Sent SIGTERM to %hu", (unsigned short int) pl->pid);
722     }
724     sfree (pl->user);
725     sfree (pl);
727     pl = next;
728   } /* while (pl) */
729   pl_head = NULL;
731   return (0);
732 } /* int exec_shutdown }}} */
734 void module_register (void)
736   plugin_register_complex_config ("exec", exec_config);
737   plugin_register_init ("exec", exec_init);
738   plugin_register_read ("exec", exec_read);
739   plugin_register_notification ("exec", exec_notification);
740   plugin_register_shutdown ("exec", exec_shutdown);
741 } /* void module_register */
743 /*
744  * vim:shiftwidth=2:softtabstop=2:tabstop=8:fdm=marker
745  */