ofp-util: Reload ofpbuf pointers after nx_put_match().
[openvswitch] / lib / unixctl.c
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
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 <errno.h>
21 #include <unistd.h>
22 #include "coverage.h"
23 #include "dirs.h"
24 #include "dynamic-string.h"
25 #include "json.h"
26 #include "jsonrpc.h"
27 #include "list.h"
28 #include "poll-loop.h"
29 #include "shash.h"
30 #include "stream.h"
31 #include "svec.h"
32 #include "vlog.h"
33
34 VLOG_DEFINE_THIS_MODULE(unixctl);
35
36 COVERAGE_DEFINE(unixctl_received);
37 COVERAGE_DEFINE(unixctl_replied);
38 \f
39 struct unixctl_command {
40     const char *usage;
41     int min_args, max_args;
42     unixctl_cb_func *cb;
43     void *aux;
44 };
45
46 struct unixctl_conn {
47     struct list node;
48     struct jsonrpc *rpc;
49
50     /* Only one request can be in progress at a time.  While the request is
51      * being processed, 'request_id' is populated, otherwise it is null. */
52     struct json *request_id;   /* ID of the currently active request. */
53 };
54
55 /* Server for control connection. */
56 struct unixctl_server {
57     struct pstream *listener;
58     struct list conns;
59 };
60
61 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5);
62
63 static struct shash commands = SHASH_INITIALIZER(&commands);
64
65 static void
66 unixctl_help(struct unixctl_conn *conn, int argc OVS_UNUSED,
67              const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
68 {
69     struct ds ds = DS_EMPTY_INITIALIZER;
70     const struct shash_node **nodes = shash_sort(&commands);
71     size_t i;
72
73     ds_put_cstr(&ds, "The available commands are:\n");
74
75     for (i = 0; i < shash_count(&commands); i++) {
76         const struct shash_node *node = nodes[i];
77         const struct unixctl_command *command = node->data;
78
79         ds_put_format(&ds, "  %-23s %s\n", node->name, command->usage);
80     }
81     free(nodes);
82
83     unixctl_command_reply(conn, ds_cstr(&ds));
84     ds_destroy(&ds);
85 }
86
87 static void
88 unixctl_version(struct unixctl_conn *conn, int argc OVS_UNUSED,
89                 const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
90 {
91     unixctl_command_reply(conn, get_program_version());
92 }
93
94 /* Registers a unixctl command with the given 'name'.  'usage' describes the
95  * arguments to the command; it is used only for presentation to the user in
96  * "help" output.
97  *
98  * 'cb' is called when the command is received.  It is passed the actual set of
99  * arguments, as a text string, plus a copy of 'aux'.  Normally 'cb' should
100  * reply by calling unixctl_command_reply() or unixctl_command_reply_error()
101  * before it returns, but if the command cannot be handled immediately then it
102  * can defer the reply until later.  A given connection can only process a
103  * single request at a time, so a reply must be made eventually to avoid
104  * blocking that connection. */
105 void
106 unixctl_command_register(const char *name, const char *usage,
107                          int min_args, int max_args,
108                          unixctl_cb_func *cb, void *aux)
109 {
110     struct unixctl_command *command;
111     struct unixctl_command *lookup = shash_find_data(&commands, name);
112
113     assert(!lookup || lookup->cb == cb);
114
115     if (lookup) {
116         return;
117     }
118
119     command = xmalloc(sizeof *command);
120     command->usage = usage;
121     command->min_args = min_args;
122     command->max_args = max_args;
123     command->cb = cb;
124     command->aux = aux;
125     shash_add(&commands, name, command);
126 }
127
128 static void
129 unixctl_command_reply__(struct unixctl_conn *conn,
130                         bool success, const char *body)
131 {
132     struct json *body_json;
133     struct jsonrpc_msg *reply;
134
135     COVERAGE_INC(unixctl_replied);
136     assert(conn->request_id);
137
138     if (!body) {
139         body = "";
140     }
141
142     if (body[0] && body[strlen(body) - 1] != '\n') {
143         body_json = json_string_create_nocopy(xasprintf("%s\n", body));
144     } else {
145         body_json = json_string_create(body);
146     }
147
148     if (success) {
149         reply = jsonrpc_create_reply(body_json, conn->request_id);
150     } else {
151         reply = jsonrpc_create_error(body_json, conn->request_id);
152     }
153
154     /* If jsonrpc_send() returns an error, the run loop will take care of the
155      * problem eventually. */
156     jsonrpc_send(conn->rpc, reply);
157     json_destroy(conn->request_id);
158     conn->request_id = NULL;
159 }
160
161 /* Replies to the active unixctl connection 'conn'.  'result' is sent to the
162  * client indicating the command was processed successfully.  Only one call to
163  * unixctl_command_reply() or unixctl_command_reply_error() may be made per
164  * request. */
165 void
166 unixctl_command_reply(struct unixctl_conn *conn, const char *result)
167 {
168     unixctl_command_reply__(conn, true, result);
169 }
170
171 /* Replies to the active unixctl connection 'conn'. 'error' is sent to the
172  * client indicating an error occured processing the command.  Only one call to
173  * unixctl_command_reply() or unixctl_command_reply_error() may be made per
174  * request. */
175 void
176 unixctl_command_reply_error(struct unixctl_conn *conn, const char *error)
177 {
178     unixctl_command_reply__(conn, false, error);
179 }
180
181 /* Creates a unixctl server listening on 'path', which may be:
182  *
183  *      - NULL, in which case <rundir>/<program>.<pid>.ctl is used.
184  *
185  *      - "none", in which case the function will return successfully but
186  *        no socket will actually be created.
187  *
188  *      - A name that does not start with '/', in which case it is put in
189  *        <rundir>.
190  *
191  *      - An absolute path (starting with '/') that gives the exact name of
192  *        the Unix domain socket to listen on.
193  *
194  * A program that (optionally) daemonizes itself should call this function
195  * *after* daemonization, so that the socket name contains the pid of the
196  * daemon instead of the pid of the program that exited.  (Otherwise,
197  * "ovs-appctl --target=<program>" will fail.)
198  *
199  * Returns 0 if successful, otherwise a positive errno value.  If successful,
200  * sets '*serverp' to the new unixctl_server (or to NULL if 'path' was "none"),
201  * otherwise to NULL. */
202 int
203 unixctl_server_create(const char *path, struct unixctl_server **serverp)
204 {
205     struct unixctl_server *server;
206     struct pstream *listener;
207     char *punix_path;
208     int error;
209
210     *serverp = NULL;
211     if (path && !strcmp(path, "none")) {
212         return 0;
213     }
214
215     if (path) {
216         char *abs_path = abs_file_name(ovs_rundir(), path);
217         punix_path = xasprintf("punix:%s", abs_path);
218         free(abs_path);
219     } else {
220         punix_path = xasprintf("punix:%s/%s.%ld.ctl", ovs_rundir(),
221                                program_name, (long int) getpid());
222     }
223
224     error = pstream_open(punix_path, &listener, 0);
225     if (error) {
226         ovs_error(error, "could not initialize control socket %s", punix_path);
227         goto exit;
228     }
229
230     unixctl_command_register("help", "", 0, 0, unixctl_help, NULL);
231     unixctl_command_register("version", "", 0, 0, unixctl_version, NULL);
232
233     server = xmalloc(sizeof *server);
234     server->listener = listener;
235     list_init(&server->conns);
236     *serverp = server;
237
238 exit:
239     free(punix_path);
240     return error;
241 }
242
243 static void
244 process_command(struct unixctl_conn *conn, struct jsonrpc_msg *request)
245 {
246     char *error = NULL;
247
248     struct unixctl_command *command;
249     struct json_array *params;
250
251     COVERAGE_INC(unixctl_received);
252     conn->request_id = json_clone(request->id);
253
254     params = json_array(request->params);
255     command = shash_find_data(&commands, request->method);
256     if (!command) {
257         error = xasprintf("\"%s\" is not a valid command", request->method);
258     } else if (params->n < command->min_args) {
259         error = xasprintf("\"%s\" command requires at least %d arguments",
260                           request->method, command->min_args);
261     } else if (params->n > command->max_args) {
262         error = xasprintf("\"%s\" command takes at most %d arguments",
263                           request->method, command->max_args);
264     } else {
265         struct svec argv = SVEC_EMPTY_INITIALIZER;
266         int  i;
267
268         svec_add(&argv, request->method);
269         for (i = 0; i < params->n; i++) {
270             if (params->elems[i]->type != JSON_STRING) {
271                 error = xasprintf("\"%s\" command has non-string argument",
272                                   request->method);
273                 break;
274             }
275             svec_add(&argv, json_string(params->elems[i]));
276         }
277         svec_terminate(&argv);
278
279         if (!error) {
280             command->cb(conn, argv.n, (const char **) argv.names,
281                         command->aux);
282         }
283
284         svec_destroy(&argv);
285     }
286
287     if (error) {
288         unixctl_command_reply_error(conn, error);
289         free(error);
290     }
291 }
292
293 static int
294 run_connection(struct unixctl_conn *conn)
295 {
296     int error, i;
297
298     jsonrpc_run(conn->rpc);
299     error = jsonrpc_get_status(conn->rpc);
300     if (error || jsonrpc_get_backlog(conn->rpc)) {
301         return error;
302     }
303
304     for (i = 0; i < 10; i++) {
305         struct jsonrpc_msg *msg;
306
307         if (error || conn->request_id) {
308             break;
309         }
310
311         jsonrpc_recv(conn->rpc, &msg);
312         if (msg) {
313             if (msg->type == JSONRPC_REQUEST) {
314                 process_command(conn, msg);
315             } else {
316                 VLOG_WARN_RL(&rl, "%s: received unexpected %s message",
317                              jsonrpc_get_name(conn->rpc),
318                              jsonrpc_msg_type_to_string(msg->type));
319                 error = EINVAL;
320             }
321             jsonrpc_msg_destroy(msg);
322         }
323         error = error ? error : jsonrpc_get_status(conn->rpc);
324     }
325
326     return error;
327 }
328
329 static void
330 kill_connection(struct unixctl_conn *conn)
331 {
332     list_remove(&conn->node);
333     jsonrpc_close(conn->rpc);
334     json_destroy(conn->request_id);
335     free(conn);
336 }
337
338 void
339 unixctl_server_run(struct unixctl_server *server)
340 {
341     struct unixctl_conn *conn, *next;
342     int i;
343
344     if (!server) {
345         return;
346     }
347
348     for (i = 0; i < 10; i++) {
349         struct stream *stream;
350         int error;
351
352         error = pstream_accept(server->listener, &stream);
353         if (!error) {
354             struct unixctl_conn *conn = xzalloc(sizeof *conn);
355             list_push_back(&server->conns, &conn->node);
356             conn->rpc = jsonrpc_open(stream);
357         } else if (error == EAGAIN) {
358             break;
359         } else {
360             VLOG_WARN_RL(&rl, "%s: accept failed: %s",
361                          pstream_get_name(server->listener),
362                          strerror(error));
363         }
364     }
365
366     LIST_FOR_EACH_SAFE (conn, next, node, &server->conns) {
367         int error = run_connection(conn);
368         if (error && error != EAGAIN) {
369             kill_connection(conn);
370         }
371     }
372 }
373
374 void
375 unixctl_server_wait(struct unixctl_server *server)
376 {
377     struct unixctl_conn *conn;
378
379     if (!server) {
380         return;
381     }
382
383     pstream_wait(server->listener);
384     LIST_FOR_EACH (conn, node, &server->conns) {
385         jsonrpc_wait(conn->rpc);
386         if (!jsonrpc_get_backlog(conn->rpc)) {
387             jsonrpc_recv_wait(conn->rpc);
388         }
389     }
390 }
391
392 /* Destroys 'server' and stops listening for connections. */
393 void
394 unixctl_server_destroy(struct unixctl_server *server)
395 {
396     if (server) {
397         struct unixctl_conn *conn, *next;
398
399         LIST_FOR_EACH_SAFE (conn, next, node, &server->conns) {
400             kill_connection(conn);
401         }
402
403         pstream_close(server->listener);
404         free(server);
405     }
406 }
407 \f
408 /* Connects to a unixctl server socket.  'path' should be the name of a unixctl
409  * server socket.  If it does not start with '/', it will be prefixed with the
410  * rundir (e.g. /usr/local/var/run/openvswitch).
411  *
412  * Returns 0 if successful, otherwise a positive errno value.  If successful,
413  * sets '*client' to the new jsonrpc, otherwise to NULL. */
414 int
415 unixctl_client_create(const char *path, struct jsonrpc **client)
416 {
417     char *abs_path, *unix_path;
418     struct stream *stream;
419     int error;
420
421     *client = NULL;
422
423     abs_path = abs_file_name(ovs_rundir(), path);
424     unix_path = xasprintf("unix:%s", abs_path);
425     error = stream_open_block(stream_open(unix_path, &stream, DSCP_DEFAULT),
426                               &stream);
427     free(unix_path);
428     free(abs_path);
429
430     if (error) {
431         VLOG_WARN("failed to connect to %s", path);
432         return error;
433     }
434
435     *client = jsonrpc_open(stream);
436     return 0;
437 }
438
439 /* Executes 'command' on the server with an argument vector 'argv' containing
440  * 'argc' elements.  If successfully communicated with the server, returns 0
441  * and sets '*result', or '*err' (not both) to the result or error the server
442  * returned.  Otherwise, sets '*result' and '*err' to NULL and returns a
443  * positive errno value.  The caller is responsible for freeing '*result' or
444  * '*err' if not NULL. */
445 int
446 unixctl_client_transact(struct jsonrpc *client, const char *command, int argc,
447                         char *argv[], char **result, char **err)
448 {
449     struct jsonrpc_msg *request, *reply;
450     struct json **json_args, *params;
451     int error, i;
452
453     *result = NULL;
454     *err = NULL;
455
456     json_args = xmalloc(argc * sizeof *json_args);
457     for (i = 0; i < argc; i++) {
458         json_args[i] = json_string_create(argv[i]);
459     }
460     params = json_array_create(json_args, argc);
461     request = jsonrpc_create_request(command, params, NULL);
462
463     error = jsonrpc_transact_block(client, request, &reply);
464     if (error) {
465         VLOG_WARN("error communicating with %s: %s", jsonrpc_get_name(client),
466                   strerror(error));
467         return error;
468     }
469
470     if (reply->error) {
471         if (reply->error->type == JSON_STRING) {
472             *err = xstrdup(json_string(reply->error));
473         } else {
474             VLOG_WARN("%s: unexpected error type in JSON RPC reply: %s",
475                       jsonrpc_get_name(client),
476                       json_type_to_string(reply->error->type));
477             error = EINVAL;
478         }
479     } else if (reply->result) {
480         if (reply->result->type == JSON_STRING) {
481             *result = xstrdup(json_string(reply->result));
482         } else {
483             VLOG_WARN("%s: unexpected result type in JSON rpc reply: %s",
484                       jsonrpc_get_name(client),
485                       json_type_to_string(reply->result->type));
486             error = EINVAL;
487         }
488     }
489
490     jsonrpc_msg_destroy(reply);
491     return error;
492 }