tests: Add test suite for packets.h.
[openvswitch] / utilities / ovs-dpctl.c
1 /*
2  * Copyright (c) 2008, 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 #include <arpa/inet.h>
19 #include <errno.h>
20 #include <getopt.h>
21 #include <inttypes.h>
22 #include <sys/socket.h>
23 #include <net/if.h>
24 #include <netinet/in.h>
25 #include <signal.h>
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <unistd.h>
30 #include <sys/stat.h>
31 #include <sys/time.h>
32
33 #include "command-line.h"
34 #include "compiler.h"
35 #include "dirs.h"
36 #include "dpif.h"
37 #include "dynamic-string.h"
38 #include "netdev.h"
39 #include "odp-util.h"
40 #include "shash.h"
41 #include "svec.h"
42 #include "timeval.h"
43 #include "util.h"
44 #include "vlog.h"
45
46 VLOG_DEFINE_THIS_MODULE(dpctl);
47
48 static const struct command all_commands[];
49
50 static void usage(void) NO_RETURN;
51 static void parse_options(int argc, char *argv[]);
52
53 int
54 main(int argc, char *argv[])
55 {
56     set_program_name(argv[0]);
57     parse_options(argc, argv);
58     signal(SIGPIPE, SIG_IGN);
59     run_command(argc - optind, argv + optind, all_commands);
60     return 0;
61 }
62
63 static void
64 parse_options(int argc, char *argv[])
65 {
66     enum {
67         OPT_DUMMY = UCHAR_MAX + 1,
68         VLOG_OPTION_ENUMS
69     };
70     static struct option long_options[] = {
71         {"timeout", required_argument, 0, 't'},
72         {"help", no_argument, 0, 'h'},
73         {"version", no_argument, 0, 'V'},
74         VLOG_LONG_OPTIONS,
75         {0, 0, 0, 0},
76     };
77     char *short_options = long_options_to_short_options(long_options);
78
79     for (;;) {
80         unsigned long int timeout;
81         int c;
82
83         c = getopt_long(argc, argv, short_options, long_options, NULL);
84         if (c == -1) {
85             break;
86         }
87
88         switch (c) {
89         case 't':
90             timeout = strtoul(optarg, NULL, 10);
91             if (timeout <= 0) {
92                 ovs_fatal(0, "value %s on -t or --timeout is not at least 1",
93                           optarg);
94             } else {
95                 time_alarm(timeout);
96             }
97             break;
98
99         case 'h':
100             usage();
101
102         case 'V':
103             OVS_PRINT_VERSION(0, 0);
104             exit(EXIT_SUCCESS);
105
106         VLOG_OPTION_HANDLERS
107
108         case '?':
109             exit(EXIT_FAILURE);
110
111         default:
112             abort();
113         }
114     }
115     free(short_options);
116 }
117
118 static void
119 usage(void)
120 {
121     printf("%s: Open vSwitch datapath management utility\n"
122            "usage: %s [OPTIONS] COMMAND [ARG...]\n"
123            "  add-dp DP [IFACE...]     add new datapath DP (with IFACEs)\n"
124            "  del-dp DP                delete local datapath DP\n"
125            "  add-if DP IFACE...       add each IFACE as a port on DP\n"
126            "  del-if DP IFACE...       delete each IFACE from DP\n"
127            "  dump-dps                 display names of all datapaths\n"
128            "  show                     show basic info on all datapaths\n"
129            "  show DP...               show basic info on each DP\n"
130            "  dump-flows DP            display flows in DP\n"
131            "  del-flows DP             delete all flows from DP\n",
132            program_name, program_name);
133     vlog_usage();
134     printf("\nOther options:\n"
135            "  -t, --timeout=SECS          give up after SECS seconds\n"
136            "  -h, --help                  display this help message\n"
137            "  -V, --version               display version information\n");
138     exit(EXIT_SUCCESS);
139 }
140
141 static void run(int retval, const char *message, ...)
142     PRINTF_FORMAT(2, 3);
143
144 static void run(int retval, const char *message, ...)
145 {
146     if (retval) {
147         va_list args;
148
149         fprintf(stderr, "%s: ", program_name);
150         va_start(args, message);
151         vfprintf(stderr, message, args);
152         va_end(args);
153         if (retval == EOF) {
154             fputs(": unexpected end of file\n", stderr);
155         } else {
156             fprintf(stderr, ": %s\n", strerror(retval));
157         }
158
159         exit(EXIT_FAILURE);
160     }
161 }
162 \f
163 static void do_add_if(int argc, char *argv[]);
164
165 static int if_up(const char *netdev_name)
166 {
167     struct netdev *netdev;
168     int retval;
169
170     retval = netdev_open_default(netdev_name, &netdev);
171     if (!retval) {
172         retval = netdev_turn_flags_on(netdev, NETDEV_UP, true);
173         netdev_close(netdev);
174     }
175     return retval;
176 }
177
178 static int
179 parsed_dpif_open(const char *arg_, bool create, struct dpif **dpifp)
180 {
181     int result;
182     char *name, *type;
183
184     dp_parse_name(arg_, &name, &type);
185
186     if (create) {
187         result = dpif_create(name, type, dpifp);
188     } else {
189         result = dpif_open(name, type, dpifp);
190     }
191
192     free(name);
193     free(type);
194     return result;
195 }
196
197 static void
198 do_add_dp(int argc OVS_UNUSED, char *argv[])
199 {
200     struct dpif *dpif;
201     run(parsed_dpif_open(argv[1], true, &dpif), "add_dp");
202     dpif_close(dpif);
203     if (argc > 2) {
204         do_add_if(argc, argv);
205     }
206 }
207
208 static void
209 do_del_dp(int argc OVS_UNUSED, char *argv[])
210 {
211     struct dpif *dpif;
212     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
213     run(dpif_delete(dpif), "del_dp");
214     dpif_close(dpif);
215 }
216
217 static void
218 do_add_if(int argc OVS_UNUSED, char *argv[])
219 {
220     bool failure = false;
221     struct dpif *dpif;
222     int i;
223
224     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
225     for (i = 2; i < argc; i++) {
226         char *save_ptr = NULL;
227         struct netdev_options options;
228         struct netdev *netdev;
229         struct shash args;
230         char *option;
231         int error;
232
233         options.name = strtok_r(argv[i], ",", &save_ptr);
234         options.type = "system";
235         options.args = &args;
236         options.ethertype = NETDEV_ETH_TYPE_NONE;
237
238         if (!options.name) {
239             ovs_error(0, "%s is not a valid network device name", argv[i]);
240             continue;
241         }
242
243         shash_init(&args);
244         while ((option = strtok_r(NULL, "", &save_ptr)) != NULL) {
245             char *save_ptr_2 = NULL;
246             char *key, *value;
247
248             key = strtok_r(option, "=", &save_ptr_2);
249             value = strtok_r(NULL, "", &save_ptr_2);
250             if (!value) {
251                 value = "";
252             }
253
254             if (!strcmp(key, "type")) {
255                 options.type = value;
256             } else if (!shash_add_once(&args, key, value)) {
257                 ovs_error(0, "duplicate \"%s\" option", key);
258             }
259         }
260
261         error = netdev_open(&options, &netdev);
262         if (error) {
263             ovs_error(error, "%s: failed to open network device",
264                       options.name);
265         } else {
266             error = dpif_port_add(dpif, netdev, NULL);
267             if (error) {
268                 ovs_error(error, "adding %s to %s failed",
269                           options.name, argv[1]);
270             } else {
271                 error = if_up(options.name);
272             }
273             netdev_close(netdev);
274         }
275         if (error) {
276             failure = true;
277         }
278     }
279     dpif_close(dpif);
280     if (failure) {
281         exit(EXIT_FAILURE);
282     }
283 }
284
285 static bool
286 get_port_number(struct dpif *dpif, const char *name, uint16_t *port)
287 {
288     struct dpif_port dpif_port;
289
290     if (!dpif_port_query_by_name(dpif, name, &dpif_port)) {
291         *port = dpif_port.port_no;
292         dpif_port_destroy(&dpif_port);
293         return true;
294     } else {
295         ovs_error(0, "no port named %s", name);
296         return false;
297     }
298 }
299
300 static void
301 do_del_if(int argc OVS_UNUSED, char *argv[])
302 {
303     bool failure = false;
304     struct dpif *dpif;
305     int i;
306
307     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
308     for (i = 2; i < argc; i++) {
309         const char *name = argv[i];
310         uint16_t port;
311         int error;
312
313         if (!name[strspn(name, "0123456789")]) {
314             port = atoi(name);
315         } else if (!get_port_number(dpif, name, &port)) {
316             failure = true;
317             continue;
318         }
319
320         error = dpif_port_del(dpif, port);
321         if (error) {
322             ovs_error(error, "deleting port %s from %s failed", name, argv[1]);
323             failure = true;
324         }
325     }
326     dpif_close(dpif);
327     if (failure) {
328         exit(EXIT_FAILURE);
329     }
330 }
331
332 static void
333 show_dpif(struct dpif *dpif)
334 {
335     struct dpif_port_dump dump;
336     struct dpif_port dpif_port;
337     struct odp_stats stats;
338
339     printf("%s:\n", dpif_name(dpif));
340     if (!dpif_get_dp_stats(dpif, &stats)) {
341         printf("\tlookups: frags:%llu, hit:%llu, missed:%llu, lost:%llu\n",
342                (unsigned long long int) stats.n_frags,
343                (unsigned long long int) stats.n_hit,
344                (unsigned long long int) stats.n_missed,
345                (unsigned long long int) stats.n_lost);
346     }
347     DPIF_PORT_FOR_EACH (&dpif_port, &dump, dpif) {
348         printf("\tport %u: %s", dpif_port.port_no, dpif_port.name);
349
350         if (strcmp(dpif_port.type, "system")) {
351             struct netdev_options netdev_options;
352             struct netdev *netdev;
353             int error;
354
355             printf (" (%s", dpif_port.type);
356
357             netdev_options.name = dpif_port.name;
358             netdev_options.type = dpif_port.type;
359             netdev_options.args = NULL;
360             netdev_options.ethertype = NETDEV_ETH_TYPE_NONE;
361             error = netdev_open(&netdev_options, &netdev);
362             if (!error) {
363                 const struct shash_node **nodes;
364                 const struct shash *config;
365                 size_t i;
366
367                 config = netdev_get_config(netdev);
368                 nodes = shash_sort(config);
369                 for (i = 0; i < shash_count(config); i++) {
370                     const struct shash_node *node = nodes[i];
371                     printf("%c %s=%s", i ? ',' : ':',
372                            node->name, (char *) node->data);
373                 }
374                 free(nodes);
375
376                 netdev_close(netdev);
377             } else {
378                 printf(": open failed (%s)", strerror(error));
379             }
380             putchar(')');
381         }
382         putchar('\n');
383     }
384     dpif_close(dpif);
385 }
386
387 static void
388 do_show(int argc, char *argv[])
389 {
390     bool failure = false;
391     if (argc > 1) {
392         int i;
393         for (i = 1; i < argc; i++) {
394             const char *name = argv[i];
395             struct dpif *dpif;
396             int error;
397
398             error = parsed_dpif_open(name, false, &dpif);
399             if (!error) {
400                 show_dpif(dpif);
401             } else {
402                 ovs_error(error, "opening datapath %s failed", name);
403                 failure = true;
404             }
405         }
406     } else {
407         struct svec types;
408         const char *type;
409         size_t i;
410
411         svec_init(&types);
412         dp_enumerate_types(&types);
413         SVEC_FOR_EACH (i, type, &types) {
414             struct svec names;
415             const char *name;
416             size_t j;
417
418             svec_init(&names);
419             if (dp_enumerate_names(type, &names)) {
420                 failure = true;
421                 continue;
422             }
423             SVEC_FOR_EACH (j, name, &names) {
424                 struct dpif *dpif;
425                 int error;
426
427                 error = dpif_open(name, type, &dpif);
428                 if (!error) {
429                     show_dpif(dpif);
430                 } else {
431                     ovs_error(error, "opening datapath %s failed", name);
432                     failure = true;
433                 }
434             }
435             svec_destroy(&names);
436         }
437         svec_destroy(&types);
438     }
439     if (failure) {
440         exit(EXIT_FAILURE);
441     }
442 }
443
444 static void
445 do_dump_dps(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
446 {
447     struct svec dpif_names, dpif_types;
448     unsigned int i;
449     int error = 0;
450
451     svec_init(&dpif_names);
452     svec_init(&dpif_types);
453     dp_enumerate_types(&dpif_types);
454
455     for (i = 0; i < dpif_types.n; i++) {
456         unsigned int j;
457         int retval;
458
459         retval = dp_enumerate_names(dpif_types.names[i], &dpif_names);
460         if (retval) {
461             error = retval;
462         }
463
464         for (j = 0; j < dpif_names.n; j++) {
465             struct dpif *dpif;
466             if (!dpif_open(dpif_names.names[j], dpif_types.names[i], &dpif)) {
467                 printf("%s\n", dpif_name(dpif));
468                 dpif_close(dpif);
469             }
470         }
471     }
472
473     svec_destroy(&dpif_names);
474     svec_destroy(&dpif_types);
475     if (error) {
476         exit(EXIT_FAILURE);
477     }
478 }
479
480 static void
481 do_dump_flows(int argc OVS_UNUSED, char *argv[])
482 {
483     const struct dpif_flow_stats *stats;
484     const struct nlattr *actions;
485     struct dpif_flow_dump dump;
486     const struct nlattr *key;
487     size_t actions_len;
488     struct dpif *dpif;
489     size_t key_len;
490     struct ds ds;
491
492     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
493
494     ds_init(&ds);
495     dpif_flow_dump_start(&dump, dpif);
496     while (dpif_flow_dump_next(&dump, &key, &key_len,
497                                &actions, &actions_len, &stats)) {
498         ds_clear(&ds);
499         odp_flow_key_format(key, key_len, &ds);
500         ds_put_cstr(&ds, ", ");
501         dpif_flow_stats_format(stats, &ds);
502         ds_put_cstr(&ds, ", actions:");
503         format_odp_actions(&ds, actions, actions_len);
504         printf("%s\n", ds_cstr(&ds));
505     }
506     dpif_flow_dump_done(&dump);
507     ds_destroy(&ds);
508     dpif_close(dpif);
509 }
510
511 static void
512 do_del_flows(int argc OVS_UNUSED, char *argv[])
513 {
514     struct dpif *dpif;
515
516     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
517     run(dpif_flow_flush(dpif), "deleting all flows");
518     dpif_close(dpif);
519 }
520
521 static void
522 do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
523 {
524     usage();
525 }
526
527 static const struct command all_commands[] = {
528     { "add-dp", 1, INT_MAX, do_add_dp },
529     { "del-dp", 1, 1, do_del_dp },
530     { "add-if", 2, INT_MAX, do_add_if },
531     { "del-if", 2, INT_MAX, do_del_if },
532     { "dump-dps", 0, 0, do_dump_dps },
533     { "show", 0, INT_MAX, do_show },
534     { "dump-flows", 1, 1, do_dump_flows },
535     { "del-flows", 1, 1, do_del_flows },
536     { "help", 0, INT_MAX, do_help },
537     { NULL, 0, 0, NULL },
538 };