Consistently write null pointer constants as NULL instead of 0.
[openvswitch] / ovsdb / ovsdb-client.c
1 /*
2  * Copyright (c) 2009, 2010, 2011 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
19 #include <assert.h>
20 #include <errno.h>
21 #include <getopt.h>
22 #include <limits.h>
23 #include <signal.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27
28 #include "command-line.h"
29 #include "column.h"
30 #include "compiler.h"
31 #include "daemon.h"
32 #include "dynamic-string.h"
33 #include "json.h"
34 #include "jsonrpc.h"
35 #include "lib/table.h"
36 #include "ovsdb.h"
37 #include "ovsdb-data.h"
38 #include "ovsdb-error.h"
39 #include "sort.h"
40 #include "stream.h"
41 #include "stream-ssl.h"
42 #include "table.h"
43 #include "timeval.h"
44 #include "util.h"
45 #include "vlog.h"
46
47 VLOG_DEFINE_THIS_MODULE(ovsdb_client);
48
49 /* Format for table output. */
50 static struct table_style table_style = TABLE_STYLE_DEFAULT;
51
52 static const struct command all_commands[];
53
54 static void usage(void) NO_RETURN;
55 static void parse_options(int argc, char *argv[]);
56
57 int
58 main(int argc, char *argv[])
59 {
60     proctitle_init(argc, argv);
61     set_program_name(argv[0]);
62     parse_options(argc, argv);
63     signal(SIGPIPE, SIG_IGN);
64     run_command(argc - optind, argv + optind, all_commands);
65     return 0;
66 }
67
68 static void
69 parse_options(int argc, char *argv[])
70 {
71     enum {
72         OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1,
73         DAEMON_OPTION_ENUMS,
74         TABLE_OPTION_ENUMS
75     };
76     static struct option long_options[] = {
77         {"verbose", optional_argument, NULL, 'v'},
78         {"help", no_argument, NULL, 'h'},
79         {"version", no_argument, NULL, 'V'},
80         DAEMON_LONG_OPTIONS,
81 #ifdef HAVE_OPENSSL
82         {"bootstrap-ca-cert", required_argument, NULL, OPT_BOOTSTRAP_CA_CERT},
83         STREAM_SSL_LONG_OPTIONS,
84 #endif
85         TABLE_LONG_OPTIONS,
86         {NULL, 0, NULL, 0},
87     };
88     char *short_options = long_options_to_short_options(long_options);
89
90     for (;;) {
91         int c;
92
93         c = getopt_long(argc, argv, short_options, long_options, NULL);
94         if (c == -1) {
95             break;
96         }
97
98         switch (c) {
99         case 'h':
100             usage();
101
102         case 'V':
103             OVS_PRINT_VERSION(0, 0);
104             exit(EXIT_SUCCESS);
105
106         case 'v':
107             vlog_set_verbosity(optarg);
108             break;
109
110         DAEMON_OPTION_HANDLERS
111
112         TABLE_OPTION_HANDLERS(&table_style)
113
114         STREAM_SSL_OPTION_HANDLERS
115
116         case OPT_BOOTSTRAP_CA_CERT:
117             stream_ssl_set_ca_cert_file(optarg, true);
118             break;
119
120         case '?':
121             exit(EXIT_FAILURE);
122
123         case 0:
124             /* getopt_long() already set the value for us. */
125             break;
126
127         default:
128             abort();
129         }
130     }
131     free(short_options);
132 }
133
134 static void
135 usage(void)
136 {
137     printf("%s: Open vSwitch database JSON-RPC client\n"
138            "usage: %s [OPTIONS] COMMAND [ARG...]\n"
139            "\nValid commands are:\n"
140            "\n  list-dbs SERVER\n"
141            "    list databases available on SERVER\n"
142            "\n  get-schema SERVER DATABASE\n"
143            "    retrieve schema for DATABASE from SERVER\n"
144            "\n  get-schema-version SERVER DATABASE\n"
145            "    retrieve schema for DATABASE from SERVER and report only its\n"
146            "    version number on stdout\n"
147            "\n  list-tables SERVER DATABASE\n"
148            "    list tables for DATABASE on SERVER\n"
149            "\n  list-columns SERVER DATABASE [TABLE]\n"
150            "    list columns in TABLE (or all tables) in DATABASE on SERVER\n"
151            "\n  transact SERVER TRANSACTION\n"
152            "    run TRANSACTION (a JSON array of operations) on SERVER\n"
153            "    and print the results as JSON on stdout\n"
154            "\n  monitor SERVER DATABASE TABLE [COLUMN,...]...\n"
155            "    monitor contents of COLUMNs in TABLE in DATABASE on SERVER.\n"
156            "    COLUMNs may include !initial, !insert, !delete, !modify\n"
157            "    to avoid seeing the specified kinds of changes.\n"
158            "\n  dump SERVER DATABASE\n"
159            "    dump contents of DATABASE on SERVER to stdout\n",
160            program_name, program_name);
161     stream_usage("SERVER", true, true, true);
162     printf("\nOutput formatting options:\n"
163            "  -f, --format=FORMAT         set output formatting to FORMAT\n"
164            "                              (\"table\", \"html\", \"csv\", "
165            "or \"json\")\n"
166            "  --no-headings               omit table heading row\n"
167            "  --pretty                    pretty-print JSON in output");
168     daemon_usage();
169     vlog_usage();
170     printf("\nOther options:\n"
171            "  -h, --help                  display this help message\n"
172            "  -V, --version               display version information\n");
173     exit(EXIT_SUCCESS);
174 }
175 \f
176 static struct json *
177 parse_json(const char *s)
178 {
179     struct json *json = json_from_string(s);
180     if (json->type == JSON_STRING) {
181         ovs_fatal(0, "\"%s\": %s", s, json->u.string);
182     }
183     return json;
184 }
185
186 static struct jsonrpc *
187 open_jsonrpc(const char *server)
188 {
189     struct stream *stream;
190     int error;
191
192     error = stream_open_block(jsonrpc_stream_open(server, &stream), &stream);
193     if (error == EAFNOSUPPORT) {
194         struct pstream *pstream;
195
196         error = jsonrpc_pstream_open(server, &pstream);
197         if (error) {
198             ovs_fatal(error, "failed to connect or listen to \"%s\"", server);
199         }
200
201         VLOG_INFO("%s: waiting for connection...", server);
202         error = pstream_accept_block(pstream, &stream);
203         if (error) {
204             ovs_fatal(error, "failed to accept connection on \"%s\"", server);
205         }
206
207         pstream_close(pstream);
208     } else if (error) {
209         ovs_fatal(error, "failed to connect to \"%s\"", server);
210     }
211
212     return jsonrpc_open(stream);
213 }
214
215 static void
216 print_json(struct json *json)
217 {
218     char *string = json_to_string(json, table_style.json_flags);
219     fputs(string, stdout);
220     free(string);
221 }
222
223 static void
224 print_and_free_json(struct json *json)
225 {
226     print_json(json);
227     json_destroy(json);
228 }
229
230 static void
231 check_ovsdb_error(struct ovsdb_error *error)
232 {
233     if (error) {
234         ovs_fatal(0, "%s", ovsdb_error_to_string(error));
235     }
236 }
237
238 static struct ovsdb_schema *
239 fetch_schema_from_rpc(struct jsonrpc *rpc, const char *database)
240 {
241     struct jsonrpc_msg *request, *reply;
242     struct ovsdb_schema *schema;
243     int error;
244
245     request = jsonrpc_create_request("get_schema",
246                                      json_array_create_1(
247                                          json_string_create(database)),
248                                      NULL);
249     error = jsonrpc_transact_block(rpc, request, &reply);
250     if (error) {
251         ovs_fatal(error, "transaction failed");
252     }
253     check_ovsdb_error(ovsdb_schema_from_json(reply->result, &schema));
254     jsonrpc_msg_destroy(reply);
255
256     return schema;
257 }
258
259 static struct ovsdb_schema *
260 fetch_schema(const char *server, const char *database)
261 {
262     struct ovsdb_schema *schema;
263     struct jsonrpc *rpc;
264
265     rpc = open_jsonrpc(server);
266     schema = fetch_schema_from_rpc(rpc, database);
267     jsonrpc_close(rpc);
268
269     return schema;
270 }
271 \f
272 \f
273 static void
274 do_list_dbs(int argc OVS_UNUSED, char *argv[])
275 {
276     struct jsonrpc_msg *request, *reply;
277     struct jsonrpc *rpc;
278     int error;
279     size_t i;
280
281     rpc = open_jsonrpc(argv[1]);
282     request = jsonrpc_create_request("list_dbs", json_array_create_empty(),
283                                      NULL);
284     error = jsonrpc_transact_block(rpc, request, &reply);
285     if (error) {
286         ovs_fatal(error, "transaction failed");
287     }
288
289     if (reply->result->type != JSON_ARRAY) {
290         ovs_fatal(0, "list_dbs response is not array");
291     }
292
293     for (i = 0; i < reply->result->u.array.n; i++) {
294         const struct json *name = reply->result->u.array.elems[i];
295
296         if (name->type != JSON_STRING) {
297             ovs_fatal(0, "list_dbs response %zu is not string", i);
298         }
299         puts(name->u.string);
300     }
301     jsonrpc_msg_destroy(reply);
302 }
303
304 static void
305 do_get_schema(int argc OVS_UNUSED, char *argv[])
306 {
307     struct ovsdb_schema *schema = fetch_schema(argv[1], argv[2]);
308     print_and_free_json(ovsdb_schema_to_json(schema));
309     ovsdb_schema_destroy(schema);
310 }
311
312 static void
313 do_get_schema_version(int argc OVS_UNUSED, char *argv[])
314 {
315     struct ovsdb_schema *schema = fetch_schema(argv[1], argv[2]);
316     puts(schema->version);
317     ovsdb_schema_destroy(schema);
318 }
319
320 static void
321 do_list_tables(int argc OVS_UNUSED, char *argv[])
322 {
323     struct ovsdb_schema *schema;
324     struct shash_node *node;
325     struct table t;
326
327     schema = fetch_schema(argv[1], argv[2]);
328     table_init(&t);
329     table_add_column(&t, "Table");
330     SHASH_FOR_EACH (node, &schema->tables) {
331         struct ovsdb_table_schema *ts = node->data;
332
333         table_add_row(&t);
334         table_add_cell(&t)->text = xstrdup(ts->name);
335     }
336     ovsdb_schema_destroy(schema);
337     table_print(&t, &table_style);
338 }
339
340 static void
341 do_list_columns(int argc OVS_UNUSED, char *argv[])
342 {
343     const char *table_name = argv[3];
344     struct ovsdb_schema *schema;
345     struct shash_node *table_node;
346     struct table t;
347
348     schema = fetch_schema(argv[1], argv[2]);
349     table_init(&t);
350     if (!table_name) {
351         table_add_column(&t, "Table");
352     }
353     table_add_column(&t, "Column");
354     table_add_column(&t, "Type");
355     SHASH_FOR_EACH (table_node, &schema->tables) {
356         struct ovsdb_table_schema *ts = table_node->data;
357
358         if (!table_name || !strcmp(table_name, ts->name)) {
359             struct shash_node *column_node;
360
361             SHASH_FOR_EACH (column_node, &ts->columns) {
362                 const struct ovsdb_column *column = column_node->data;
363
364                 table_add_row(&t);
365                 if (!table_name) {
366                     table_add_cell(&t)->text = xstrdup(ts->name);
367                 }
368                 table_add_cell(&t)->text = xstrdup(column->name);
369                 table_add_cell(&t)->json = ovsdb_type_to_json(&column->type);
370             }
371         }
372     }
373     ovsdb_schema_destroy(schema);
374     table_print(&t, &table_style);
375 }
376
377 static void
378 do_transact(int argc OVS_UNUSED, char *argv[])
379 {
380     struct jsonrpc_msg *request, *reply;
381     struct json *transaction;
382     struct jsonrpc *rpc;
383     int error;
384
385     transaction = parse_json(argv[2]);
386
387     rpc = open_jsonrpc(argv[1]);
388     request = jsonrpc_create_request("transact", transaction, NULL);
389     error = jsonrpc_transact_block(rpc, request, &reply);
390     if (error) {
391         ovs_fatal(error, "transaction failed");
392     }
393     if (reply->error) {
394         ovs_fatal(error, "transaction returned error: %s",
395                   json_to_string(reply->error, table_style.json_flags));
396     }
397     print_json(reply->result);
398     putchar('\n');
399     jsonrpc_msg_destroy(reply);
400     jsonrpc_close(rpc);
401 }
402
403 static void
404 monitor_print_row(struct json *row, const char *type, const char *uuid,
405                   const struct ovsdb_column_set *columns, struct table *t)
406 {
407     size_t i;
408
409     if (!row) {
410         ovs_error(0, "missing %s row", type);
411         return;
412     } else if (row->type != JSON_OBJECT) {
413         ovs_error(0, "<row> is not object");
414         return;
415     }
416
417     table_add_row(t);
418     table_add_cell(t)->text = xstrdup(uuid);
419     table_add_cell(t)->text = xstrdup(type);
420     for (i = 0; i < columns->n_columns; i++) {
421         const struct ovsdb_column *column = columns->columns[i];
422         struct json *value = shash_find_data(json_object(row), column->name);
423         struct cell *cell = table_add_cell(t);
424         if (value) {
425             cell->json = json_clone(value);
426             cell->type = &column->type;
427         }
428     }
429 }
430
431 static void
432 monitor_print(struct json *table_updates,
433               const struct ovsdb_table_schema *table,
434               const struct ovsdb_column_set *columns, bool initial)
435 {
436     struct json *table_update;
437     struct shash_node *node;
438     struct table t;
439     size_t i;
440
441     table_init(&t);
442
443     if (table_updates->type != JSON_OBJECT) {
444         ovs_error(0, "<table-updates> is not object");
445         return;
446     }
447     table_update = shash_find_data(json_object(table_updates), table->name);
448     if (!table_update) {
449         return;
450     }
451     if (table_update->type != JSON_OBJECT) {
452         ovs_error(0, "<table-update> is not object");
453         return;
454     }
455
456     table_add_column(&t, "row");
457     table_add_column(&t, "action");
458     for (i = 0; i < columns->n_columns; i++) {
459         table_add_column(&t, "%s", columns->columns[i]->name);
460     }
461     SHASH_FOR_EACH (node, json_object(table_update)) {
462         struct json *row_update = node->data;
463         struct json *old, *new;
464
465         if (row_update->type != JSON_OBJECT) {
466             ovs_error(0, "<row-update> is not object");
467             continue;
468         }
469         old = shash_find_data(json_object(row_update), "old");
470         new = shash_find_data(json_object(row_update), "new");
471         if (initial) {
472             monitor_print_row(new, "initial", node->name, columns, &t);
473         } else if (!old) {
474             monitor_print_row(new, "insert", node->name, columns, &t);
475         } else if (!new) {
476             monitor_print_row(old, "delete", node->name, columns, &t);
477         } else {
478             monitor_print_row(old, "old", node->name, columns, &t);
479             monitor_print_row(new, "new", "", columns, &t);
480         }
481     }
482     table_print(&t, &table_style);
483     table_destroy(&t);
484 }
485
486 static void
487 add_column(const char *server, const struct ovsdb_column *column,
488            struct ovsdb_column_set *columns, struct json *columns_json)
489 {
490     if (ovsdb_column_set_contains(columns, column->index)) {
491         ovs_fatal(0, "%s: column \"%s\" mentioned multiple times",
492                   server, column->name);
493     }
494     ovsdb_column_set_add(columns, column);
495     json_array_add(columns_json, json_string_create(column->name));
496 }
497
498 static struct json *
499 parse_monitor_columns(char *arg, const char *server, const char *database,
500                       const struct ovsdb_table_schema *table,
501                       struct ovsdb_column_set *columns)
502 {
503     bool initial, insert, delete, modify;
504     struct json *mr, *columns_json;
505     char *save_ptr = NULL;
506     char *token;
507
508     mr = json_object_create();
509     columns_json = json_array_create_empty();
510     json_object_put(mr, "columns", columns_json);
511
512     initial = insert = delete = modify = true;
513     for (token = strtok_r(arg, ",", &save_ptr); token != NULL;
514          token = strtok_r(NULL, ",", &save_ptr)) {
515         if (!strcmp(token, "!initial")) {
516             initial = false;
517         } else if (!strcmp(token, "!insert")) {
518             insert = false;
519         } else if (!strcmp(token, "!delete")) {
520             delete = false;
521         } else if (!strcmp(token, "!modify")) {
522             modify = false;
523         } else {
524             const struct ovsdb_column *column;
525
526             column = ovsdb_table_schema_get_column(table, token);
527             if (!column) {
528                 ovs_fatal(0, "%s: table \"%s\" in %s does not have a "
529                           "column named \"%s\"",
530                           server, table->name, database, token);
531             }
532             add_column(server, column, columns, columns_json);
533         }
534     }
535
536     if (columns_json->u.array.n == 0) {
537         const struct shash_node **nodes;
538         size_t i, n;
539
540         n = shash_count(&table->columns);
541         nodes = shash_sort(&table->columns);
542         for (i = 0; i < n; i++) {
543             const struct ovsdb_column *column = nodes[i]->data;
544             if (column->index != OVSDB_COL_UUID
545                 && column->index != OVSDB_COL_VERSION) {
546                 add_column(server, column, columns, columns_json);
547             }
548         }
549         free(nodes);
550
551         add_column(server, ovsdb_table_schema_get_column(table,"_version"),
552                    columns, columns_json);
553     }
554
555     if (!initial || !insert || !delete || !modify) {
556         struct json *select = json_object_create();
557         json_object_put(select, "initial", json_boolean_create(initial));
558         json_object_put(select, "insert", json_boolean_create(insert));
559         json_object_put(select, "delete", json_boolean_create(delete));
560         json_object_put(select, "modify", json_boolean_create(modify));
561         json_object_put(mr, "select", select);
562     }
563
564     return mr;
565 }
566
567 static void
568 do_monitor(int argc, char *argv[])
569 {
570     const char *server = argv[1];
571     const char *database = argv[2];
572     const char *table_name = argv[3];
573     struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
574     struct ovsdb_table_schema *table;
575     struct ovsdb_schema *schema;
576     struct jsonrpc_msg *request;
577     struct jsonrpc *rpc;
578     struct json *monitor, *monitor_request_array,
579         *monitor_requests, *request_id;
580
581     rpc = open_jsonrpc(server);
582
583     schema = fetch_schema_from_rpc(rpc, database);
584     table = shash_find_data(&schema->tables, table_name);
585     if (!table) {
586         ovs_fatal(0, "%s: %s does not have a table named \"%s\"",
587                   server, database, table_name);
588     }
589
590     monitor_request_array = json_array_create_empty();
591     if (argc > 4) {
592         int i;
593
594         for (i = 4; i < argc; i++) {
595             json_array_add(
596                 monitor_request_array,
597                 parse_monitor_columns(argv[i], server, database, table,
598                                       &columns));
599         }
600     } else {
601         /* Allocate a writable empty string since parse_monitor_columns() is
602          * going to strtok() it and that's risky with literal "". */
603         char empty[] = "";
604         json_array_add(
605             monitor_request_array,
606             parse_monitor_columns(empty, server, database, table, &columns));
607     }
608
609     monitor_requests = json_object_create();
610     json_object_put(monitor_requests, table_name, monitor_request_array);
611
612     monitor = json_array_create_3(json_string_create(database),
613                                   json_null_create(), monitor_requests);
614     request = jsonrpc_create_request("monitor", monitor, NULL);
615     request_id = json_clone(request->id);
616     jsonrpc_send(rpc, request);
617     for (;;) {
618         struct jsonrpc_msg *msg;
619         int error;
620
621         error = jsonrpc_recv_block(rpc, &msg);
622         if (error) {
623             ovsdb_schema_destroy(schema);
624             ovs_fatal(error, "%s: receive failed", server);
625         }
626
627         if (msg->type == JSONRPC_REQUEST && !strcmp(msg->method, "echo")) {
628             jsonrpc_send(rpc, jsonrpc_create_reply(json_clone(msg->params),
629                                                    msg->id));
630         } else if (msg->type == JSONRPC_REPLY
631                    && json_equal(msg->id, request_id)) {
632             monitor_print(msg->result, table, &columns, true);
633             fflush(stdout);
634             if (get_detach()) {
635                 /* daemonize() closes the standard file descriptors.  We output
636                  * to stdout, so we need to save and restore STDOUT_FILENO. */
637                 int fd = dup(STDOUT_FILENO);
638                 daemonize();
639                 dup2(fd, STDOUT_FILENO);
640                 close(fd);
641             }
642         } else if (msg->type == JSONRPC_NOTIFY
643                    && !strcmp(msg->method, "update")) {
644             struct json *params = msg->params;
645             if (params->type == JSON_ARRAY
646                 && params->u.array.n == 2
647                 && params->u.array.elems[0]->type == JSON_NULL) {
648                 monitor_print(params->u.array.elems[1],
649                               table, &columns, false);
650                 fflush(stdout);
651             }
652         }
653         jsonrpc_msg_destroy(msg);
654     }
655 }
656
657 struct dump_table_aux {
658     struct ovsdb_datum **data;
659     const struct ovsdb_column **columns;
660     size_t n_columns;
661 };
662
663 static int
664 compare_data(size_t a_y, size_t b_y, size_t x,
665              const struct dump_table_aux *aux)
666 {
667     return ovsdb_datum_compare_3way(&aux->data[a_y][x],
668                                     &aux->data[b_y][x],
669                                     &aux->columns[x]->type);
670 }
671
672 static int
673 compare_rows(size_t a_y, size_t b_y, void *aux_)
674 {
675     struct dump_table_aux *aux = aux_;
676     size_t x;
677
678     /* Skip UUID columns on the first pass, since their values tend to be
679      * random and make our results less reproducible. */
680     for (x = 0; x < aux->n_columns; x++) {
681         if (aux->columns[x]->type.key.type != OVSDB_TYPE_UUID) {
682             int cmp = compare_data(a_y, b_y, x, aux);
683             if (cmp) {
684                 return cmp;
685             }
686         }
687     }
688
689     /* Use UUID columns as tie-breakers. */
690     for (x = 0; x < aux->n_columns; x++) {
691         if (aux->columns[x]->type.key.type == OVSDB_TYPE_UUID) {
692             int cmp = compare_data(a_y, b_y, x, aux);
693             if (cmp) {
694                 return cmp;
695             }
696         }
697     }
698
699     return 0;
700 }
701
702 static void
703 swap_rows(size_t a_y, size_t b_y, void *aux_)
704 {
705     struct dump_table_aux *aux = aux_;
706     struct ovsdb_datum *tmp = aux->data[a_y];
707     aux->data[a_y] = aux->data[b_y];
708     aux->data[b_y] = tmp;
709 }
710
711 static int
712 compare_columns(const void *a_, const void *b_)
713 {
714     const struct ovsdb_column *const *ap = a_;
715     const struct ovsdb_column *const *bp = b_;
716     const struct ovsdb_column *a = *ap;
717     const struct ovsdb_column *b = *bp;
718
719     return strcmp(a->name, b->name);
720 }
721
722 static void
723 dump_table(const struct ovsdb_table_schema *ts, struct json_array *rows)
724 {
725     const struct ovsdb_column **columns;
726     size_t n_columns;
727
728     struct ovsdb_datum **data;
729
730     struct dump_table_aux aux;
731     struct shash_node *node;
732     struct table t;
733     size_t x, y;
734
735     /* Sort columns by name, for reproducibility. */
736     columns = xmalloc(shash_count(&ts->columns) * sizeof *columns);
737     n_columns = 0;
738     SHASH_FOR_EACH (node, &ts->columns) {
739         struct ovsdb_column *column = node->data;
740         if (strcmp(column->name, "_version")) {
741             columns[n_columns++] = column;
742         }
743     }
744     qsort(columns, n_columns, sizeof *columns, compare_columns);
745
746     /* Extract data from table. */
747     data = xmalloc(rows->n * sizeof *data);
748     for (y = 0; y < rows->n; y++) {
749         struct shash *row;
750
751         if (rows->elems[y]->type != JSON_OBJECT) {
752             ovs_fatal(0,  "row %zu in table %s response is not a JSON object: "
753                       "%s", y, ts->name, json_to_string(rows->elems[y], 0));
754         }
755         row = json_object(rows->elems[y]);
756
757         data[y] = xmalloc(n_columns * sizeof **data);
758         for (x = 0; x < n_columns; x++) {
759             const struct json *json = shash_find_data(row, columns[x]->name);
760             if (!json) {
761                 ovs_fatal(0, "row %zu in table %s response lacks %s column",
762                           y, ts->name, columns[x]->name);
763             }
764
765             check_ovsdb_error(ovsdb_datum_from_json(&data[y][x],
766                                                     &columns[x]->type,
767                                                     json, NULL));
768         }
769     }
770
771     /* Sort rows by column values, for reproducibility. */
772     aux.data = data;
773     aux.columns = columns;
774     aux.n_columns = n_columns;
775     sort(rows->n, compare_rows, swap_rows, &aux);
776
777     /* Add column headings. */
778     table_init(&t);
779     table_set_caption(&t, xasprintf("%s table", ts->name));
780     for (x = 0; x < n_columns; x++) {
781         table_add_column(&t, "%s", columns[x]->name);
782     }
783
784     /* Print rows. */
785     for (y = 0; y < rows->n; y++) {
786         table_add_row(&t);
787         for (x = 0; x < n_columns; x++) {
788             struct cell *cell = table_add_cell(&t);
789             cell->json = ovsdb_datum_to_json(&data[y][x], &columns[x]->type);
790             cell->type = &columns[x]->type;
791         }
792     }
793     table_print(&t, &table_style);
794     table_destroy(&t);
795 }
796
797 static void
798 do_dump(int argc OVS_UNUSED, char *argv[])
799 {
800     const char *server = argv[1];
801     const char *database = argv[2];
802
803     struct jsonrpc_msg *request, *reply;
804     struct ovsdb_schema *schema;
805     struct json *transaction;
806     struct jsonrpc *rpc;
807     int error;
808
809     const struct shash_node **tables;
810     size_t n_tables;
811
812     size_t i;
813
814     rpc = open_jsonrpc(server);
815
816     schema = fetch_schema_from_rpc(rpc, database);
817     tables = shash_sort(&schema->tables);
818     n_tables = shash_count(&schema->tables);
819
820     /* Construct transaction to retrieve entire database. */
821     transaction = json_array_create_1(json_string_create(database));
822     for (i = 0; i < n_tables; i++) {
823         const struct ovsdb_table_schema *ts = tables[i]->data;
824         struct json *op, *columns;
825         struct shash_node *node;
826
827         columns = json_array_create_empty();
828         SHASH_FOR_EACH (node, &ts->columns) {
829             const struct ovsdb_column *column = node->data;
830
831             if (strcmp(column->name, "_version")) {
832                 json_array_add(columns, json_string_create(column->name));
833             }
834         }
835
836         op = json_object_create();
837         json_object_put_string(op, "op", "select");
838         json_object_put_string(op, "table", tables[i]->name);
839         json_object_put(op, "where", json_array_create_empty());
840         json_object_put(op, "columns", columns);
841         json_array_add(transaction, op);
842     }
843
844     /* Send request, get reply. */
845     request = jsonrpc_create_request("transact", transaction, NULL);
846     error = jsonrpc_transact_block(rpc, request, &reply);
847     if (error) {
848         ovs_fatal(error, "transaction failed");
849     }
850
851     /* Print database contents. */
852     if (reply->result->type != JSON_ARRAY
853         || reply->result->u.array.n != n_tables) {
854         ovs_fatal(0, "reply is not array of %zu elements: %s",
855                   n_tables, json_to_string(reply->result, 0));
856     }
857     for (i = 0; i < n_tables; i++) {
858         const struct ovsdb_table_schema *ts = tables[i]->data;
859         const struct json *op_result = reply->result->u.array.elems[i];
860         struct json *rows;
861
862         if (op_result->type != JSON_OBJECT
863             || !(rows = shash_find_data(json_object(op_result), "rows"))
864             || rows->type != JSON_ARRAY) {
865             ovs_fatal(0, "%s table reply is not an object with a \"rows\" "
866                       "member array: %s",
867                       ts->name, json_to_string(op_result, 0));
868         }
869
870         dump_table(ts, &rows->u.array);
871     }
872 }
873
874 static void
875 do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
876 {
877     usage();
878 }
879
880 static const struct command all_commands[] = {
881     { "list-dbs", 1, 1, do_list_dbs },
882     { "get-schema", 2, 2, do_get_schema },
883     { "get-schema-version", 2, 2, do_get_schema_version },
884     { "list-tables", 2, 2, do_list_tables },
885     { "list-columns", 2, 3, do_list_columns },
886     { "transact", 2, 2, do_transact },
887     { "monitor", 3, INT_MAX, do_monitor },
888     { "dump", 2, 2, do_dump },
889     { "help", 0, INT_MAX, do_help },
890     { NULL, 0, 0, NULL },
891 };