ofpbuf: Make ofpbufs initialized with ofpbuf_use_stack() not expandable.
[sliver-openvswitch.git] / lib / unixctl.c
1 /*
2  * Copyright (c) 2008, 2009, 2010 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 "unixctl.h"
19 #include <assert.h>
20 #include <ctype.h>
21 #include <errno.h>
22 #include <poll.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/socket.h>
26 #include <sys/stat.h>
27 #include <unistd.h>
28 #include "coverage.h"
29 #include "dirs.h"
30 #include "dynamic-string.h"
31 #include "fatal-signal.h"
32 #include "list.h"
33 #include "ofpbuf.h"
34 #include "poll-loop.h"
35 #include "shash.h"
36 #include "socket-util.h"
37 #include "svec.h"
38 #include "util.h"
39 #include "vlog.h"
40
41 #ifndef SCM_CREDENTIALS
42 #include <time.h>
43 #endif
44
45 VLOG_DEFINE_THIS_MODULE(unixctl);
46
47 COVERAGE_DEFINE(unixctl_received);
48 COVERAGE_DEFINE(unixctl_replied);
49 \f
50 struct unixctl_command {
51     unixctl_cb_func *cb;
52     void *aux;
53 };
54
55 struct unixctl_conn {
56     struct list node;
57     int fd;
58
59     enum { S_RECV, S_PROCESS, S_SEND } state;
60     struct ofpbuf in;
61     struct ds out;
62     size_t out_pos;
63 };
64
65 /* Server for control connection. */
66 struct unixctl_server {
67     char *path;
68     int fd;
69     struct list conns;
70 };
71
72 /* Client for control connection. */
73 struct unixctl_client {
74     char *connect_path;
75     char *bind_path;
76     FILE *stream;
77 };
78
79 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5);
80
81 static struct shash commands = SHASH_INITIALIZER(&commands);
82
83 static void
84 unixctl_help(struct unixctl_conn *conn, const char *args OVS_UNUSED,
85              void *aux OVS_UNUSED)
86 {
87     struct ds ds = DS_EMPTY_INITIALIZER;
88     struct shash_node *node;
89     struct svec names;
90     const char *name;
91     size_t i;
92
93     ds_put_cstr(&ds, "The available commands are:\n");
94
95     svec_init(&names);
96     SHASH_FOR_EACH (node, &commands) {
97         svec_add(&names, node->name);
98     }
99     svec_sort(&names);
100
101     SVEC_FOR_EACH (i, name, &names) {
102         ds_put_format(&ds, "\t%s\n", name);
103     }
104     svec_destroy(&names);
105
106     unixctl_command_reply(conn, 214, ds_cstr(&ds));
107     ds_destroy(&ds);
108 }
109
110 void
111 unixctl_command_register(const char *name, unixctl_cb_func *cb, void *aux)
112 {
113     struct unixctl_command *command;
114
115     assert(!shash_find_data(&commands, name)
116            || shash_find_data(&commands, name) == cb);
117     command = xmalloc(sizeof *command);
118     command->cb = cb;
119     command->aux = aux;
120     shash_add(&commands, name, command);
121 }
122
123 static const char *
124 translate_reply_code(int code)
125 {
126     switch (code) {
127     case 200: return "OK";
128     case 201: return "Created";
129     case 202: return "Accepted";
130     case 204: return "No Content";
131     case 211: return "System Status";
132     case 214: return "Help";
133     case 400: return "Bad Request";
134     case 401: return "Unauthorized";
135     case 403: return "Forbidden";
136     case 404: return "Not Found";
137     case 500: return "Internal Server Error";
138     case 501: return "Invalid Argument";
139     case 503: return "Service Unavailable";
140     default: return "Unknown";
141     }
142 }
143
144 void
145 unixctl_command_reply(struct unixctl_conn *conn,
146                       int code, const char *body)
147 {
148     struct ds *out = &conn->out;
149
150     COVERAGE_INC(unixctl_replied);
151     assert(conn->state == S_PROCESS);
152     conn->state = S_SEND;
153     conn->out_pos = 0;
154
155     ds_clear(out);
156     ds_put_format(out, "%03d %s\n", code, translate_reply_code(code));
157     if (body) {
158         const char *p;
159         for (p = body; *p != '\0'; ) {
160             size_t n = strcspn(p, "\n");
161
162             if (*p == '.') {
163                 ds_put_char(out, '.');
164             }
165             ds_put_buffer(out, p, n);
166             ds_put_char(out, '\n');
167             p += n;
168             if (*p == '\n') {
169                 p++;
170             }
171         }
172     }
173     ds_put_cstr(out, ".\n");
174 }
175
176 /* Creates a unixctl server listening on 'path', which may be:
177  *
178  *      - NULL, in which case <rundir>/<program>.<pid>.ctl is used.
179  *
180  *      - "none", in which case the function will return successfully but
181  *        no socket will actually be created.
182  *
183  *      - A name that does not start with '/', in which case it is put in
184  *        <rundir>.
185  *
186  *      - An absolute path (starting with '/') that gives the exact name of
187  *        the Unix domain socket to listen on.
188  *
189  * A program that (optionally) daemonizes itself should call this function
190  * *after* daemonization, so that the socket name contains the pid of the
191  * daemon instead of the pid of the program that exited.  (Otherwise,
192  * "ovs-appctl --target=<program>" will fail.)
193  *
194  * Returns 0 if successful, otherwise a positive errno value.  If successful,
195  * sets '*serverp' to the new unixctl_server (or to NULL if 'path' was "none"),
196  * otherwise to NULL. */
197 int
198 unixctl_server_create(const char *path, struct unixctl_server **serverp)
199 {
200     struct unixctl_server *server;
201     int error;
202
203     if (path && !strcmp(path, "none")) {
204         *serverp = NULL;
205         return 0;
206     }
207
208     unixctl_command_register("help", unixctl_help, NULL);
209
210     server = xmalloc(sizeof *server);
211     list_init(&server->conns);
212
213     if (path) {
214         server->path = abs_file_name(ovs_rundir(), path);
215     } else {
216         server->path = xasprintf("%s/%s.%ld.ctl", ovs_rundir(),
217                                  program_name, (long int) getpid());
218     }
219
220     server->fd = make_unix_socket(SOCK_STREAM, true, false, server->path,
221                                   NULL);
222     if (server->fd < 0) {
223         error = -server->fd;
224         ovs_error(error, "could not initialize control socket %s",
225                   server->path);
226         goto error;
227     }
228
229     if (chmod(server->path, S_IRUSR | S_IWUSR) < 0) {
230         error = errno;
231         ovs_error(error, "failed to chmod control socket %s", server->path);
232         goto error;
233     }
234
235     if (listen(server->fd, 10) < 0) {
236         error = errno;
237         ovs_error(error, "Failed to listen on control socket %s",
238                   server->path);
239         goto error;
240     }
241
242     *serverp = server;
243     return 0;
244
245 error:
246     if (server->fd >= 0) {
247         close(server->fd);
248     }
249     free(server->path);
250     free(server);
251     *serverp = NULL;
252     return error;
253 }
254
255 static void
256 new_connection(struct unixctl_server *server, int fd)
257 {
258     struct unixctl_conn *conn;
259
260     set_nonblocking(fd);
261
262     conn = xmalloc(sizeof *conn);
263     list_push_back(&server->conns, &conn->node);
264     conn->fd = fd;
265     conn->state = S_RECV;
266     ofpbuf_init(&conn->in, 128);
267     ds_init(&conn->out);
268     conn->out_pos = 0;
269 }
270
271 static int
272 run_connection_output(struct unixctl_conn *conn)
273 {
274     while (conn->out_pos < conn->out.length) {
275         size_t bytes_written;
276         int error;
277
278         error = write_fully(conn->fd, conn->out.string + conn->out_pos,
279                             conn->out.length - conn->out_pos, &bytes_written);
280         conn->out_pos += bytes_written;
281         if (error) {
282             return error;
283         }
284     }
285     conn->state = S_RECV;
286     return 0;
287 }
288
289 static void
290 process_command(struct unixctl_conn *conn, char *s)
291 {
292     struct unixctl_command *command;
293     size_t name_len;
294     char *name, *args;
295
296     COVERAGE_INC(unixctl_received);
297     conn->state = S_PROCESS;
298
299     name = s;
300     name_len = strcspn(name, " ");
301     args = name + name_len;
302     args += strspn(args, " ");
303     name[name_len] = '\0';
304
305     command = shash_find_data(&commands, name);
306     if (command) {
307         command->cb(conn, args, command->aux);
308     } else {
309         char *msg = xasprintf("\"%s\" is not a valid command", name);
310         unixctl_command_reply(conn, 400, msg);
311         free(msg);
312     }
313 }
314
315 static int
316 run_connection_input(struct unixctl_conn *conn)
317 {
318     for (;;) {
319         size_t bytes_read;
320         char *newline;
321         int error;
322
323         newline = memchr(conn->in.data, '\n', conn->in.size);
324         if (newline) {
325             char *command = conn->in.data;
326             size_t n = newline - command + 1;
327
328             if (n > 0 && newline[-1] == '\r') {
329                 newline--;
330             }
331             *newline = '\0';
332
333             process_command(conn, command);
334
335             ofpbuf_pull(&conn->in, n);
336             if (!conn->in.size) {
337                 ofpbuf_clear(&conn->in);
338             }
339             return 0;
340         }
341
342         ofpbuf_prealloc_tailroom(&conn->in, 128);
343         error = read_fully(conn->fd, ofpbuf_tail(&conn->in),
344                            ofpbuf_tailroom(&conn->in), &bytes_read);
345         conn->in.size += bytes_read;
346         if (conn->in.size > 65536) {
347             VLOG_WARN_RL(&rl, "excess command length, killing connection");
348             return EPROTO;
349         }
350         if (error) {
351             if (error == EAGAIN || error == EWOULDBLOCK) {
352                 if (!bytes_read) {
353                     return EAGAIN;
354                 }
355             } else {
356                 if (error != EOF || conn->in.size != 0) {
357                     VLOG_WARN_RL(&rl, "read failed: %s",
358                                  (error == EOF
359                                   ? "connection dropped mid-command"
360                                   : strerror(error)));
361                 }
362                 return error;
363             }
364         }
365     }
366 }
367
368 static int
369 run_connection(struct unixctl_conn *conn)
370 {
371     int old_state;
372     do {
373         int error;
374
375         old_state = conn->state;
376         switch (conn->state) {
377         case S_RECV:
378             error = run_connection_input(conn);
379             break;
380
381         case S_PROCESS:
382             error = 0;
383             break;
384
385         case S_SEND:
386             error = run_connection_output(conn);
387             break;
388
389         default:
390             NOT_REACHED();
391         }
392         if (error) {
393             return error;
394         }
395     } while (conn->state != old_state);
396     return 0;
397 }
398
399 static void
400 kill_connection(struct unixctl_conn *conn)
401 {
402     list_remove(&conn->node);
403     ofpbuf_uninit(&conn->in);
404     ds_destroy(&conn->out);
405     close(conn->fd);
406     free(conn);
407 }
408
409 void
410 unixctl_server_run(struct unixctl_server *server)
411 {
412     struct unixctl_conn *conn, *next;
413     int i;
414
415     if (!server) {
416         return;
417     }
418
419     for (i = 0; i < 10; i++) {
420         int fd = accept(server->fd, NULL, NULL);
421         if (fd < 0) {
422             if (errno != EAGAIN && errno != EWOULDBLOCK) {
423                 VLOG_WARN_RL(&rl, "accept failed: %s", strerror(errno));
424             }
425             break;
426         }
427         new_connection(server, fd);
428     }
429
430     LIST_FOR_EACH_SAFE (conn, next, node, &server->conns) {
431         int error = run_connection(conn);
432         if (error && error != EAGAIN) {
433             kill_connection(conn);
434         }
435     }
436 }
437
438 void
439 unixctl_server_wait(struct unixctl_server *server)
440 {
441     struct unixctl_conn *conn;
442
443     if (!server) {
444         return;
445     }
446
447     poll_fd_wait(server->fd, POLLIN);
448     LIST_FOR_EACH (conn, node, &server->conns) {
449         if (conn->state == S_RECV) {
450             poll_fd_wait(conn->fd, POLLIN);
451         } else if (conn->state == S_SEND) {
452             poll_fd_wait(conn->fd, POLLOUT);
453         }
454     }
455 }
456
457 /* Destroys 'server' and stops listening for connections. */
458 void
459 unixctl_server_destroy(struct unixctl_server *server)
460 {
461     if (server) {
462         struct unixctl_conn *conn, *next;
463
464         LIST_FOR_EACH_SAFE (conn, next, node, &server->conns) {
465             kill_connection(conn);
466         }
467
468         close(server->fd);
469         fatal_signal_unlink_file_now(server->path);
470         free(server->path);
471         free(server);
472     }
473 }
474 \f
475 /* Connects to a Vlog server socket.  'path' should be the name of a Vlog
476  * server socket.  If it does not start with '/', it will be prefixed with
477  * the rundir (e.g. /usr/local/var/run/openvswitch).
478  *
479  * Returns 0 if successful, otherwise a positive errno value.  If successful,
480  * sets '*clientp' to the new unixctl_client, otherwise to NULL. */
481 int
482 unixctl_client_create(const char *path, struct unixctl_client **clientp)
483 {
484     static int counter;
485     struct unixctl_client *client;
486     int error;
487     int fd = -1;
488
489     /* Determine location. */
490     client = xmalloc(sizeof *client);
491     client->connect_path = abs_file_name(ovs_rundir(), path);
492     client->bind_path = xasprintf("/tmp/vlog.%ld.%d",
493                                   (long int) getpid(), counter++);
494
495     /* Open socket. */
496     fd = make_unix_socket(SOCK_STREAM, false, false,
497                           client->bind_path, client->connect_path);
498     if (fd < 0) {
499         error = -fd;
500         goto error;
501     }
502
503     /* Bind socket to stream. */
504     client->stream = fdopen(fd, "r+");
505     if (!client->stream) {
506         error = errno;
507         VLOG_WARN("%s: fdopen failed (%s)",
508                   client->connect_path, strerror(error));
509         goto error;
510     }
511     *clientp = client;
512     return 0;
513
514 error:
515     if (fd >= 0) {
516         close(fd);
517     }
518     free(client->connect_path);
519     free(client->bind_path);
520     free(client);
521     *clientp = NULL;
522     return error;
523 }
524
525 /* Destroys 'client'. */
526 void
527 unixctl_client_destroy(struct unixctl_client *client)
528 {
529     if (client) {
530         fatal_signal_unlink_file_now(client->bind_path);
531         free(client->bind_path);
532         free(client->connect_path);
533         fclose(client->stream);
534         free(client);
535     }
536 }
537
538 /* Sends 'request' to the server socket and waits for a reply.  Returns 0 if
539  * successful, otherwise to a positive errno value.  If successful, sets
540  * '*reply' to the reply, which the caller must free, otherwise to NULL. */
541 int
542 unixctl_client_transact(struct unixctl_client *client,
543                         const char *request,
544                         int *reply_code, char **reply_body)
545 {
546     struct ds line = DS_EMPTY_INITIALIZER;
547     struct ds reply = DS_EMPTY_INITIALIZER;
548     int error;
549
550     /* Send 'request' to server.  Add a new-line if 'request' didn't end in
551      * one. */
552     fputs(request, client->stream);
553     if (request[0] == '\0' || request[strlen(request) - 1] != '\n') {
554         putc('\n', client->stream);
555     }
556     if (ferror(client->stream)) {
557         VLOG_WARN("error sending request to %s: %s",
558                   client->connect_path, strerror(errno));
559         return errno;
560     }
561
562     /* Wait for response. */
563     *reply_code = -1;
564     for (;;) {
565         const char *s;
566
567         error = ds_get_line(&line, client->stream);
568         if (error) {
569             VLOG_WARN("error reading reply from %s: %s",
570                       client->connect_path,
571                       (error == EOF ? "unexpected end of file"
572                        : strerror(error)));
573             goto error;
574         }
575
576         s = ds_cstr(&line);
577         if (*reply_code == -1) {
578             if (!isdigit((unsigned char)s[0])
579                     || !isdigit((unsigned char)s[1])
580                     || !isdigit((unsigned char)s[2])) {
581                 VLOG_WARN("reply from %s does not start with 3-digit code",
582                           client->connect_path);
583                 error = EPROTO;
584                 goto error;
585             }
586             sscanf(s, "%3d", reply_code);
587         } else {
588             if (s[0] == '.') {
589                 if (s[1] == '\0') {
590                     break;
591                 }
592                 s++;
593             }
594             ds_put_cstr(&reply, s);
595             ds_put_char(&reply, '\n');
596         }
597     }
598     *reply_body = ds_cstr(&reply);
599     ds_destroy(&line);
600     return 0;
601
602 error:
603     ds_destroy(&line);
604     ds_destroy(&reply);
605     *reply_code = 0;
606     *reply_body = NULL;
607     return error == EOF ? EPROTO : error;
608 }
609
610 /* Returns the path of the server socket to which 'client' is connected.  The
611  * caller must not modify or free the returned string. */
612 const char *
613 unixctl_client_target(const struct unixctl_client *client)
614 {
615     return client->connect_path;
616 }