ovsdb-server: Make database connections configurable from database itself.
[openvswitch] / ofproto / executer.c
1 /*
2  * Copyright (c) 2008, 2009 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "executer.h"
19 #include <errno.h>
20 #include <fcntl.h>
21 #include <fnmatch.h>
22 #include <poll.h>
23 #include <signal.h>
24 #include <stdlib.h>
25 #include <sys/stat.h>
26 #include <sys/wait.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include "dirs.h"
30 #include "dynamic-string.h"
31 #include "fatal-signal.h"
32 #include "openflow/nicira-ext.h"
33 #include "ofpbuf.h"
34 #include "openflow/openflow.h"
35 #include "poll-loop.h"
36 #include "rconn.h"
37 #include "socket-util.h"
38 #include "util.h"
39 #include "vconn.h"
40
41 #define THIS_MODULE VLM_executer
42 #include "vlog.h"
43
44 #define MAX_CHILDREN 8
45
46 struct child {
47     /* Information about child process. */
48     char *name;                 /* argv[0] passed to child. */
49     pid_t pid;                  /* Child's process ID. */
50
51     /* For sending a reply to the controller when the child dies. */
52     struct rconn *rconn;
53     uint32_t xid;               /* Transaction ID used by controller. */
54
55     /* We read up to MAX_OUTPUT bytes of output and send them back to the
56      * controller when the child dies. */
57 #define MAX_OUTPUT 4096
58     int output_fd;              /* FD from which to read child's output. */
59     uint8_t *output;            /* Output data. */
60     size_t output_size;         /* Number of bytes of output data so far. */
61 };
62
63 struct executer {
64     /* Settings. */
65     char *command_acl;          /* Command white/blacklist, as shell globs. */
66     char *command_dir;          /* Directory that contains commands. */
67
68     /* Children. */
69     struct child children[MAX_CHILDREN];
70     size_t n_children;
71 };
72
73 /* File descriptors for waking up when a child dies. */
74 static int signal_fds[2] = {-1, -1};
75
76 static void send_child_status(struct rconn *, uint32_t xid, uint32_t status,
77                               const void *data, size_t size);
78 static void send_child_message(struct rconn *, uint32_t xid, uint32_t status,
79                                const char *message);
80
81 /* Returns true if 'cmd' is allowed by 'acl', which is a command-separated
82  * access control list in the format described for --command-acl in
83  * ovs-openflowd(8). */
84 static bool
85 executer_is_permitted(const char *acl_, const char *cmd)
86 {
87     char *acl, *save_ptr, *pattern;
88     bool allowed, denied;
89
90     /* Verify that 'cmd' consists only of alphanumerics plus _ or -. */
91     if (cmd[strspn(cmd, "abcdefghijklmnopqrstuvwxyz"
92                    "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-")] != '\0') {
93         VLOG_WARN("rejecting command name \"%s\" that contain forbidden "
94                   "characters", cmd);
95         return false;
96     }
97
98     /* Check 'cmd' against 'acl'. */
99     acl = xstrdup(acl_);
100     save_ptr = acl;
101     allowed = denied = false;
102     while ((pattern = strsep(&save_ptr, ",")) != NULL && !denied) {
103         if (pattern[0] != '!' && !fnmatch(pattern, cmd, 0)) {
104             allowed = true;
105         } else if (pattern[0] == '!' && !fnmatch(pattern + 1, cmd, 0)) {
106             denied = true;
107         }
108     }
109     free(acl);
110
111     /* Check the command white/blacklisted state. */
112     if (allowed && !denied) {
113         VLOG_INFO("permitting command execution: \"%s\" is whitelisted", cmd);
114     } else if (allowed && denied) {
115         VLOG_WARN("denying command execution: \"%s\" is both blacklisted "
116                   "and whitelisted", cmd);
117     } else if (!allowed) {
118         VLOG_WARN("denying command execution: \"%s\" is not whitelisted", cmd);
119     } else if (denied) {
120         VLOG_WARN("denying command execution: \"%s\" is blacklisted", cmd);
121     }
122     return allowed && !denied;
123 }
124
125 int
126 executer_handle_request(struct executer *e, struct rconn *rconn,
127                         struct nicira_header *request)
128 {
129     char **argv;
130     char *args;
131     char *exec_file = NULL;
132     int max_fds;
133     struct stat s;
134     size_t args_size;
135     size_t argc;
136     size_t i;
137     pid_t pid;
138     int output_fds[2];
139
140     /* Verify limit on children not exceeded.
141      * XXX should probably kill children when the connection drops? */
142     if (e->n_children >= MAX_CHILDREN) {
143         send_child_message(rconn, request->header.xid, NXT_STATUS_ERROR,
144                            "too many child processes");
145         return 0;
146     }
147
148     /* Copy argument buffer, adding a null terminator at the end.  Now every
149      * argument is null-terminated, instead of being merely null-delimited. */
150     args_size = ntohs(request->header.length) - sizeof *request;
151     args = xmemdup0((const void *) (request + 1), args_size);
152
153     /* Count arguments. */
154     argc = 0;
155     for (i = 0; i <= args_size; i++) {
156         argc += args[i] == '\0';
157     }
158
159     /* Set argv[*] to point to each argument. */
160     argv = xmalloc((argc + 1) * sizeof *argv);
161     argv[0] = args;
162     for (i = 1; i < argc; i++) {
163         argv[i] = strchr(argv[i - 1], '\0') + 1;
164     }
165     argv[argc] = NULL;
166
167     /* Check permissions. */
168     if (!executer_is_permitted(e->command_acl, argv[0])) {
169         send_child_message(rconn, request->header.xid, NXT_STATUS_ERROR,
170                            "command not allowed");
171         goto done;
172     }
173
174     /* Find the executable. */
175     exec_file = xasprintf("%s/%s", e->command_dir, argv[0]);
176     if (stat(exec_file, &s)) {
177         VLOG_WARN("failed to stat \"%s\": %s", exec_file, strerror(errno));
178         send_child_message(rconn, request->header.xid, NXT_STATUS_ERROR,
179                            "command not allowed");
180         goto done;
181     }
182     if (!S_ISREG(s.st_mode)) {
183         VLOG_WARN("\"%s\" is not a regular file", exec_file);
184         send_child_message(rconn, request->header.xid, NXT_STATUS_ERROR,
185                            "command not allowed");
186         goto done;
187     }
188     argv[0] = exec_file;
189
190     /* Arrange to capture output. */
191     if (pipe(output_fds)) {
192         VLOG_WARN("pipe failed: %s", strerror(errno));
193         send_child_message(rconn, request->header.xid, NXT_STATUS_ERROR,
194                            "internal error (pipe)");
195         goto done;
196     }
197
198     pid = fork();
199     if (!pid) {
200         /* Running in child.
201          * XXX should run in new process group so that we can signal all
202          * subprocesses at once?  Would also want to catch fatal signals and
203          * kill them at the same time though. */
204         fatal_signal_fork();
205         dup2(get_null_fd(), 0);
206         dup2(output_fds[1], 1);
207         dup2(get_null_fd(), 2);
208         max_fds = get_max_fds();
209         for (i = 3; i < max_fds; i++) {
210             close(i);
211         }
212         if (chdir(e->command_dir)) {
213             printf("could not change directory to \"%s\": %s",
214                    e->command_dir, strerror(errno));
215             exit(EXIT_FAILURE);
216         }
217         execv(argv[0], argv);
218         printf("failed to start \"%s\": %s\n", argv[0], strerror(errno));
219         exit(EXIT_FAILURE);
220     } else if (pid > 0) {
221         /* Running in parent. */
222         struct child *child;
223
224         VLOG_INFO("started \"%s\" subprocess", argv[0]);
225         send_child_status(rconn, request->header.xid, NXT_STATUS_STARTED,
226                           NULL, 0);
227         child = &e->children[e->n_children++];
228         child->name = xstrdup(argv[0]);
229         child->pid = pid;
230         child->rconn = rconn;
231         child->xid = request->header.xid;
232         child->output_fd = output_fds[0];
233         child->output = xmalloc(MAX_OUTPUT);
234         child->output_size = 0;
235         set_nonblocking(output_fds[0]);
236         close(output_fds[1]);
237     } else {
238         VLOG_WARN("fork failed: %s", strerror(errno));
239         send_child_message(rconn, request->header.xid, NXT_STATUS_ERROR,
240                            "internal error (fork)");
241         close(output_fds[0]);
242         close(output_fds[1]);
243     }
244
245 done:
246     free(exec_file);
247     free(args);
248     free(argv);
249     return 0;
250 }
251
252 static void
253 send_child_status(struct rconn *rconn, uint32_t xid, uint32_t status,
254                   const void *data, size_t size)
255 {
256     if (rconn) {
257         struct nx_command_reply *r;
258         struct ofpbuf *buffer;
259
260         r = make_openflow_xid(sizeof *r, OFPT_VENDOR, xid, &buffer);
261         r->nxh.vendor = htonl(NX_VENDOR_ID);
262         r->nxh.subtype = htonl(NXT_COMMAND_REPLY);
263         r->status = htonl(status);
264         ofpbuf_put(buffer, data, size);
265         update_openflow_length(buffer);
266         if (rconn_send(rconn, buffer, NULL)) {
267             ofpbuf_delete(buffer);
268         }
269     }
270 }
271
272 static void
273 send_child_message(struct rconn *rconn, uint32_t xid, uint32_t status,
274                    const char *message)
275 {
276     send_child_status(rconn, xid, status, message, strlen(message));
277 }
278
279 /* 'child' died with 'status' as its return code.  Deal with it. */
280 static void
281 child_terminated(struct child *child, int status)
282 {
283     struct ds ds;
284     uint32_t ofp_status;
285
286     /* Log how it terminated. */
287     ds_init(&ds);
288     if (WIFEXITED(status)) {
289         ds_put_format(&ds, "normally with status %d", WEXITSTATUS(status));
290     } else if (WIFSIGNALED(status)) {
291         const char *name = NULL;
292 #ifdef HAVE_STRSIGNAL
293         name = strsignal(WTERMSIG(status));
294 #endif
295         ds_put_format(&ds, "by signal %d", WTERMSIG(status));
296         if (name) {
297             ds_put_format(&ds, " (%s)", name);
298         }
299     }
300     if (WCOREDUMP(status)) {
301         ds_put_cstr(&ds, " (core dumped)");
302     }
303     VLOG_INFO("child process \"%s\" with pid %ld terminated %s",
304               child->name, (long int) child->pid, ds_cstr(&ds));
305     ds_destroy(&ds);
306
307     /* Send a status message back to the controller that requested the
308      * command. */
309     if (WIFEXITED(status)) {
310         ofp_status = WEXITSTATUS(status) | NXT_STATUS_EXITED;
311     } else if (WIFSIGNALED(status)) {
312         ofp_status = WTERMSIG(status) | NXT_STATUS_SIGNALED;
313     } else {
314         ofp_status = NXT_STATUS_UNKNOWN;
315     }
316     if (WCOREDUMP(status)) {
317         ofp_status |= NXT_STATUS_COREDUMP;
318     }
319     send_child_status(child->rconn, child->xid, ofp_status,
320                       child->output, child->output_size);
321 }
322
323 /* Read output from 'child' and append it to its output buffer. */
324 static void
325 poll_child(struct child *child)
326 {
327     ssize_t n;
328
329     if (child->output_fd < 0) {
330         return;
331     }
332
333     do {
334         n = read(child->output_fd, child->output + child->output_size,
335                  MAX_OUTPUT - child->output_size);
336     } while (n < 0 && errno == EINTR);
337     if (n > 0) {
338         child->output_size += n;
339         if (child->output_size < MAX_OUTPUT) {
340             return;
341         }
342     } else if (n < 0 && errno == EAGAIN) {
343         return;
344     }
345     close(child->output_fd);
346     child->output_fd = -1;
347 }
348
349 void
350 executer_run(struct executer *e)
351 {
352     char buffer[MAX_CHILDREN];
353     size_t i;
354
355     if (!e->n_children) {
356         return;
357     }
358
359     /* Read output from children. */
360     for (i = 0; i < e->n_children; i++) {
361         struct child *child = &e->children[i];
362         poll_child(child);
363     }
364
365     /* If SIGCHLD was received, reap dead children. */
366     if (read(signal_fds[0], buffer, sizeof buffer) <= 0) {
367         return;
368     }
369     for (;;) {
370         int status;
371         pid_t pid;
372
373         /* Get dead child in 'pid' and its return code in 'status'. */
374         pid = waitpid(WAIT_ANY, &status, WNOHANG);
375         if (pid < 0 && errno == EINTR) {
376             continue;
377         } else if (pid <= 0) {
378             return;
379         }
380
381         /* Find child with given 'pid' and drop it from the list. */
382         for (i = 0; i < e->n_children; i++) {
383             struct child *child = &e->children[i];
384             if (child->pid == pid) {
385                 poll_child(child);
386                 child_terminated(child, status);
387                 free(child->name);
388                 free(child->output);
389                 *child = e->children[--e->n_children];
390                 goto found;
391             }
392         }
393         VLOG_WARN("child with unknown pid %ld terminated", (long int) pid);
394     found:;
395     }
396
397 }
398
399 void
400 executer_wait(struct executer *e)
401 {
402     if (e->n_children) {
403         size_t i;
404
405         /* Wake up on SIGCHLD. */
406         poll_fd_wait(signal_fds[0], POLLIN);
407
408         /* Wake up when we get output from a child. */
409         for (i = 0; i < e->n_children; i++) {
410             struct child *child = &e->children[i];
411             if (child->output_fd >= 0) {
412                 poll_fd_wait(child->output_fd, POLLIN);
413             }
414         }
415     }
416 }
417
418 void
419 executer_rconn_closing(struct executer *e, struct rconn *rconn)
420 {
421     size_t i;
422
423     /* If any of our children was connected to 'r', then disconnect it so we
424      * don't try to reference a dead connection when the process terminates
425      * later.
426      * XXX kill the children started by 'r'? */
427     for (i = 0; i < e->n_children; i++) {
428         if (e->children[i].rconn == rconn) {
429             e->children[i].rconn = NULL;
430         }
431     }
432 }
433
434 static void
435 sigchld_handler(int signr UNUSED)
436 {
437     ignore(write(signal_fds[1], "", 1));
438 }
439
440 int
441 executer_create(const char *command_acl, const char *command_dir,
442                 struct executer **executerp)
443 {
444     struct executer *e;
445     struct sigaction sa;
446
447     *executerp = NULL;
448     if (signal_fds[0] == -1) {
449         /* Make sure we can get a fd for /dev/null. */
450         int null_fd = get_null_fd();
451         if (null_fd < 0) {
452             return -null_fd;
453         }
454
455         /* Create pipe for notifying us that SIGCHLD was invoked. */
456         if (pipe(signal_fds)) {
457             VLOG_ERR("pipe failed: %s", strerror(errno));
458             return errno;
459         }
460         set_nonblocking(signal_fds[0]);
461         set_nonblocking(signal_fds[1]);
462     }
463
464     /* Set up signal handler. */
465     memset(&sa, 0, sizeof sa);
466     sa.sa_handler = sigchld_handler;
467     sigemptyset(&sa.sa_mask);
468     sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
469     if (sigaction(SIGCHLD, &sa, NULL)) {
470         VLOG_ERR("sigaction(SIGCHLD) failed: %s", strerror(errno));
471         return errno;
472     }
473
474     e = xzalloc(sizeof *e);
475     e->command_acl = xstrdup(command_acl);
476     e->command_dir = (command_dir
477                       ? xstrdup(command_dir)
478                       : xasprintf("%s/commands", ovs_pkgdatadir));
479     e->n_children = 0;
480     *executerp = e;
481     return 0;
482 }
483
484 void
485 executer_destroy(struct executer *e)
486 {
487     if (e) {
488         size_t i;
489
490         free(e->command_acl);
491         free(e->command_dir);
492         for (i = 0; i < e->n_children; i++) {
493             struct child *child = &e->children[i];
494
495             free(child->name);
496             kill(child->pid, SIGHUP);
497             /* We don't own child->rconn. */
498             free(child->output);
499             free(child);
500         }
501         free(e);
502     }
503 }
504
505 void
506 executer_set_acl(struct executer *e, const char *acl, const char *dir)
507 {
508     free(e->command_acl);
509     e->command_acl = xstrdup(acl);
510     free(e->command_dir);
511     e->command_dir = xstrdup(dir);
512 }