2 * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 #include <sys/socket.h>
28 #include <sys/fcntl.h>
32 #include "byte-order.h"
33 #include "classifier.h"
34 #include "command-line.h"
38 #include "dynamic-string.h"
41 #include "ofp-actions.h"
42 #include "ofp-errors.h"
43 #include "ofp-parse.h"
44 #include "ofp-print.h"
47 #include "ofproto/ofproto.h"
48 #include "openflow/nicira-ext.h"
49 #include "openflow/openflow.h"
51 #include "poll-loop.h"
53 #include "stream-ssl.h"
59 #include "meta-flow.h"
62 VLOG_DEFINE_THIS_MODULE(ofctl);
64 /* --strict: Use strict matching for flow mod commands? Additionally governs
65 * use of nx_pull_match() instead of nx_pull_match_loose() in parse-nx-match.
69 /* --readd: If true, on replace-flows, re-add even flows that have not changed
70 * (to reset flow counters). */
73 /* -F, --flow-format: Allowed protocols. By default, any protocol is
75 static enum ofputil_protocol allowed_protocols = OFPUTIL_P_ANY;
77 /* -P, --packet-in-format: Packet IN format to use in monitor and snoop
78 * commands. Either one of NXPIF_* to force a particular packet_in format, or
79 * -1 to let ovs-ofctl choose the default. */
80 static int preferred_packet_in_format = -1;
82 /* -m, --more: Additional verbosity for ofp-print functions. */
85 /* --timestamp: Print a timestamp before each received packet on "monitor" and
87 static bool timestamp;
89 /* --sort, --rsort: Sort order. */
90 enum sort_order { SORT_ASC, SORT_DESC };
91 struct sort_criterion {
92 const struct mf_field *field; /* NULL means to sort by priority. */
93 enum sort_order order;
95 static struct sort_criterion *criteria;
96 static size_t n_criteria, allocated_criteria;
98 static const struct command all_commands[];
100 static void usage(void) NO_RETURN;
101 static void parse_options(int argc, char *argv[]);
103 static bool recv_flow_stats_reply(struct vconn *, ovs_be32 send_xid,
104 struct ofpbuf **replyp,
105 struct ofputil_flow_stats *,
106 struct ofpbuf *ofpacts);
108 main(int argc, char *argv[])
110 set_program_name(argv[0]);
111 parse_options(argc, argv);
112 signal(SIGPIPE, SIG_IGN);
113 run_command(argc - optind, argv + optind, all_commands);
118 add_sort_criterion(enum sort_order order, const char *field)
120 struct sort_criterion *sc;
122 if (n_criteria >= allocated_criteria) {
123 criteria = x2nrealloc(criteria, &allocated_criteria, sizeof *criteria);
126 sc = &criteria[n_criteria++];
127 if (!field || !strcasecmp(field, "priority")) {
130 sc->field = mf_from_name(field);
132 ovs_fatal(0, "%s: unknown field name", field);
139 parse_options(int argc, char *argv[])
142 OPT_STRICT = UCHAR_MAX + 1,
150 static struct option long_options[] = {
151 {"timeout", required_argument, NULL, 't'},
152 {"strict", no_argument, NULL, OPT_STRICT},
153 {"readd", no_argument, NULL, OPT_READD},
154 {"flow-format", required_argument, NULL, 'F'},
155 {"packet-in-format", required_argument, NULL, 'P'},
156 {"more", no_argument, NULL, 'm'},
157 {"timestamp", no_argument, NULL, OPT_TIMESTAMP},
158 {"sort", optional_argument, NULL, OPT_SORT},
159 {"rsort", optional_argument, NULL, OPT_RSORT},
160 {"help", no_argument, NULL, 'h'},
161 {"version", no_argument, NULL, 'V'},
164 STREAM_SSL_LONG_OPTIONS,
167 char *short_options = long_options_to_short_options(long_options);
170 unsigned long int timeout;
173 c = getopt_long(argc, argv, short_options, long_options, NULL);
180 timeout = strtoul(optarg, NULL, 10);
182 ovs_fatal(0, "value %s on -t or --timeout is not at least 1",
190 allowed_protocols = ofputil_protocols_from_string(optarg);
191 if (!allowed_protocols) {
192 ovs_fatal(0, "%s: invalid flow format(s)", optarg);
197 preferred_packet_in_format =
198 ofputil_packet_in_format_from_string(optarg);
199 if (preferred_packet_in_format < 0) {
200 ovs_fatal(0, "unknown packet-in format `%s'", optarg);
212 ovs_print_version(OFP10_VERSION, OFP10_VERSION);
228 add_sort_criterion(SORT_ASC, optarg);
232 add_sort_criterion(SORT_DESC, optarg);
235 DAEMON_OPTION_HANDLERS
237 STREAM_SSL_OPTION_HANDLERS
248 /* Always do a final sort pass based on priority. */
249 add_sort_criterion(SORT_DESC, "priority");
258 printf("%s: OpenFlow switch management utility\n"
259 "usage: %s [OPTIONS] COMMAND [ARG...]\n"
260 "\nFor OpenFlow switches:\n"
261 " show SWITCH show OpenFlow information\n"
262 " dump-desc SWITCH print switch description\n"
263 " dump-tables SWITCH print table stats\n"
264 " mod-port SWITCH IFACE ACT modify port behavior\n"
265 " get-frags SWITCH print fragment handling behavior\n"
266 " set-frags SWITCH FRAG_MODE set fragment handling behavior\n"
267 " dump-ports SWITCH [PORT] print port statistics\n"
268 " dump-ports-desc SWITCH print port descriptions\n"
269 " dump-flows SWITCH print all flow entries\n"
270 " dump-flows SWITCH FLOW print matching FLOWs\n"
271 " dump-aggregate SWITCH print aggregate flow statistics\n"
272 " dump-aggregate SWITCH FLOW print aggregate stats for FLOWs\n"
273 " queue-stats SWITCH [PORT [QUEUE]] dump queue stats\n"
274 " add-flow SWITCH FLOW add flow described by FLOW\n"
275 " add-flows SWITCH FILE add flows from FILE\n"
276 " mod-flows SWITCH FLOW modify actions of matching FLOWs\n"
277 " del-flows SWITCH [FLOW] delete matching FLOWs\n"
278 " replace-flows SWITCH FILE replace flows with those in FILE\n"
279 " diff-flows SOURCE1 SOURCE2 compare flows from two sources\n"
280 " packet-out SWITCH IN_PORT ACTIONS PACKET...\n"
281 " execute ACTIONS on PACKET\n"
282 " monitor SWITCH [MISSLEN] [invalid_ttl] [watch:[...]]\n"
283 " print packets received from SWITCH\n"
284 " snoop SWITCH snoop on SWITCH and its controller\n"
285 "\nFor OpenFlow switches and controllers:\n"
286 " probe TARGET probe whether TARGET is up\n"
287 " ping TARGET [N] latency of N-byte echos\n"
288 " benchmark TARGET N COUNT bandwidth of COUNT N-byte echos\n"
289 "where SWITCH or TARGET is an active OpenFlow connection method.\n",
290 program_name, program_name);
291 vconn_usage(true, false, false);
294 printf("\nOther options:\n"
295 " --strict use strict match for flow commands\n"
296 " --readd replace flows that haven't changed\n"
297 " -F, --flow-format=FORMAT force particular flow format\n"
298 " -P, --packet-in-format=FRMT force particular packet in format\n"
299 " -m, --more be more verbose printing OpenFlow\n"
300 " --timestamp (monitor, snoop) print timestamps\n"
301 " -t, --timeout=SECS give up after SECS seconds\n"
302 " --sort[=field] sort in ascending order\n"
303 " --rsort[=field] sort in descending order\n"
304 " -h, --help display this help message\n"
305 " -V, --version display version information\n");
310 ofctl_exit(struct unixctl_conn *conn, int argc OVS_UNUSED,
311 const char *argv[] OVS_UNUSED, void *exiting_)
313 bool *exiting = exiting_;
315 unixctl_command_reply(conn, NULL);
318 static void run(int retval, const char *message, ...)
321 static void run(int retval, const char *message, ...)
326 va_start(args, message);
327 ovs_fatal_valist(retval, message, args);
331 /* Generic commands. */
334 open_vconn_socket(const char *name, struct vconn **vconnp)
336 char *vconn_name = xasprintf("unix:%s", name);
337 VLOG_DBG("connecting to %s", vconn_name);
338 run(vconn_open_block(vconn_name, OFP10_VERSION, vconnp),
339 "connecting to %s", vconn_name);
343 static enum ofputil_protocol
344 open_vconn__(const char *name, const char *default_suffix,
345 struct vconn **vconnp)
347 char *datapath_name, *datapath_type, *socket_name;
348 enum ofputil_protocol protocol;
353 bridge_path = xasprintf("%s/%s.%s", ovs_rundir(), name, default_suffix);
355 ofproto_parse_name(name, &datapath_name, &datapath_type);
356 socket_name = xasprintf("%s/%s.%s",
357 ovs_rundir(), datapath_name, default_suffix);
361 if (strchr(name, ':')) {
362 run(vconn_open_block(name, OFP10_VERSION, vconnp),
363 "connecting to %s", name);
364 } else if (!stat(name, &s) && S_ISSOCK(s.st_mode)) {
365 open_vconn_socket(name, vconnp);
366 } else if (!stat(bridge_path, &s) && S_ISSOCK(s.st_mode)) {
367 open_vconn_socket(bridge_path, vconnp);
368 } else if (!stat(socket_name, &s)) {
369 if (!S_ISSOCK(s.st_mode)) {
370 ovs_fatal(0, "cannot connect to %s: %s is not a socket",
373 open_vconn_socket(socket_name, vconnp);
375 ovs_fatal(0, "%s is not a bridge or a socket", name);
381 ofp_version = vconn_get_version(*vconnp);
382 protocol = ofputil_protocol_from_ofp_version(ofp_version);
384 ovs_fatal(0, "%s: unsupported OpenFlow version 0x%02x",
390 static enum ofputil_protocol
391 open_vconn(const char *name, struct vconn **vconnp)
393 return open_vconn__(name, "mgmt", vconnp);
397 alloc_stats_request(size_t rq_len, uint16_t type, struct ofpbuf **bufferp)
399 struct ofp_stats_msg *rq;
401 rq = make_openflow(rq_len, OFPT10_STATS_REQUEST, bufferp);
402 rq->type = htons(type);
403 rq->flags = htons(0);
408 send_openflow_buffer(struct vconn *vconn, struct ofpbuf *buffer)
410 update_openflow_length(buffer);
411 run(vconn_send_block(vconn, buffer), "failed to send packet to switch");
415 dump_transaction(const char *vconn_name, struct ofpbuf *request)
418 struct ofpbuf *reply;
420 update_openflow_length(request);
421 open_vconn(vconn_name, &vconn);
422 run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
423 ofp_print(stdout, reply->data, reply->size, verbosity + 1);
424 ofpbuf_delete(reply);
429 dump_trivial_transaction(const char *vconn_name, uint8_t request_type)
431 struct ofpbuf *request;
432 make_openflow(sizeof(struct ofp_header), request_type, &request);
433 dump_transaction(vconn_name, request);
437 dump_stats_transaction__(struct vconn *vconn, struct ofpbuf *request)
439 ovs_be32 send_xid = ((struct ofp_header *) request->data)->xid;
440 ovs_be16 stats_type = ((struct ofp_stats_msg *) request->data)->type;
443 send_openflow_buffer(vconn, request);
446 struct ofpbuf *reply;
448 run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
449 recv_xid = ((struct ofp_header *) reply->data)->xid;
450 if (send_xid == recv_xid) {
451 const struct ofp_stats_msg *osm = reply->data;
452 const struct ofp_header *oh = reply->data;
454 ofp_print(stdout, reply->data, reply->size, verbosity + 1);
456 if (oh->type == OFPT_ERROR) {
458 } else if (oh->type == OFPT10_STATS_REPLY
459 && osm->type == stats_type) {
460 done = !(ntohs(osm->flags) & OFPSF_REPLY_MORE);
462 ovs_fatal(0, "received bad reply: %s",
463 ofp_to_string(reply->data, reply->size,
467 VLOG_DBG("received reply with xid %08"PRIx32" "
468 "!= expected %08"PRIx32, recv_xid, send_xid);
470 ofpbuf_delete(reply);
475 dump_stats_transaction(const char *vconn_name, struct ofpbuf *request)
479 open_vconn(vconn_name, &vconn);
480 dump_stats_transaction__(vconn, request);
485 dump_trivial_stats_transaction(const char *vconn_name, uint8_t stats_type)
487 struct ofpbuf *request;
488 alloc_stats_request(sizeof(struct ofp_stats_msg), stats_type, &request);
489 dump_stats_transaction(vconn_name, request);
492 /* Sends 'request', which should be a request that only has a reply if an error
493 * occurs, and waits for it to succeed or fail. If an error does occur, prints
494 * it and exits with an error.
496 * Destroys all of the 'requests'. */
498 transact_multiple_noreply(struct vconn *vconn, struct list *requests)
500 struct ofpbuf *request, *reply;
502 LIST_FOR_EACH (request, list_node, requests) {
503 update_openflow_length(request);
506 run(vconn_transact_multiple_noreply(vconn, requests, &reply),
507 "talking to %s", vconn_get_name(vconn));
509 ofp_print(stderr, reply->data, reply->size, verbosity + 2);
512 ofpbuf_delete(reply);
515 /* Sends 'request', which should be a request that only has a reply if an error
516 * occurs, and waits for it to succeed or fail. If an error does occur, prints
517 * it and exits with an error.
519 * Destroys 'request'. */
521 transact_noreply(struct vconn *vconn, struct ofpbuf *request)
523 struct list requests;
525 list_init(&requests);
526 list_push_back(&requests, &request->list_node);
527 transact_multiple_noreply(vconn, &requests);
531 fetch_switch_config(struct vconn *vconn, struct ofp_switch_config *config_)
533 struct ofp_switch_config *config;
534 struct ofp_header *header;
535 struct ofpbuf *request;
536 struct ofpbuf *reply;
538 make_openflow(sizeof(struct ofp_header), OFPT_GET_CONFIG_REQUEST,
540 run(vconn_transact(vconn, request, &reply),
541 "talking to %s", vconn_get_name(vconn));
543 header = reply->data;
544 if (header->type != OFPT_GET_CONFIG_REPLY ||
545 header->length != htons(sizeof *config)) {
546 ovs_fatal(0, "%s: bad reply to config request", vconn_get_name(vconn));
549 config = reply->data;
552 ofpbuf_delete(reply);
556 set_switch_config(struct vconn *vconn, struct ofp_switch_config *config_)
558 struct ofp_switch_config *config;
559 struct ofp_header save_header;
560 struct ofpbuf *request;
562 config = make_openflow(sizeof *config, OFPT_SET_CONFIG, &request);
563 save_header = config->header;
565 config->header = save_header;
567 transact_noreply(vconn, request);
571 ofctl_show(int argc OVS_UNUSED, char *argv[])
573 const char *vconn_name = argv[1];
575 struct ofpbuf *request;
576 struct ofpbuf *reply;
579 make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST,
581 open_vconn(vconn_name, &vconn);
582 run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
584 trunc = ofputil_switch_features_ports_trunc(reply);
585 ofp_print(stdout, reply->data, reply->size, verbosity + 1);
587 ofpbuf_delete(reply);
591 /* The Features Reply may not contain all the ports, so send a
592 * Port Description stats request, which doesn't have size
594 dump_trivial_stats_transaction(vconn_name, OFPST_PORT_DESC);
596 dump_trivial_transaction(vconn_name, OFPT_GET_CONFIG_REQUEST);
600 ofctl_dump_desc(int argc OVS_UNUSED, char *argv[])
602 dump_trivial_stats_transaction(argv[1], OFPST_DESC);
606 ofctl_dump_tables(int argc OVS_UNUSED, char *argv[])
608 dump_trivial_stats_transaction(argv[1], OFPST_TABLE);
612 fetch_port_by_features(const char *vconn_name,
613 const char *port_name, unsigned int port_no,
614 struct ofputil_phy_port *pp, bool *trunc)
616 struct ofputil_switch_features features;
617 const struct ofp_switch_features *osf;
618 struct ofpbuf *request, *reply;
624 /* Fetch the switch's ofp_switch_features. */
625 make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST, &request);
626 open_vconn(vconn_name, &vconn);
627 run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
631 if (reply->size < sizeof *osf) {
632 ovs_fatal(0, "%s: received too-short features reply (only %zu bytes)",
633 vconn_name, reply->size);
637 if (ofputil_switch_features_ports_trunc(reply)) {
642 error = ofputil_decode_switch_features(osf, &features, &b);
644 ovs_fatal(0, "%s: failed to decode features reply (%s)",
645 vconn_name, ofperr_to_string(error));
648 while (!ofputil_pull_phy_port(osf->header.version, &b, pp)) {
649 if (port_no != UINT_MAX
650 ? port_no == pp->port_no
651 : !strcmp(pp->name, port_name)) {
658 ofpbuf_delete(reply);
663 fetch_port_by_stats(const char *vconn_name,
664 const char *port_name, unsigned int port_no,
665 struct ofputil_phy_port *pp)
667 struct ofpbuf *request;
674 alloc_stats_request(sizeof(struct ofp_stats_msg), OFPST_PORT_DESC,
676 send_xid = ((struct ofp_header *) request->data)->xid;
678 open_vconn(vconn_name, &vconn);
679 send_openflow_buffer(vconn, request);
682 struct ofpbuf *reply;
684 run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
685 recv_xid = ((struct ofp_header *) reply->data)->xid;
686 if (send_xid == recv_xid) {
687 const struct ofputil_msg_type *type;
688 struct ofp_stats_msg *osm;
690 ofputil_decode_msg_type(reply->data, &type);
691 if (ofputil_msg_type_code(type) != OFPUTIL_OFPST_PORT_DESC_REPLY) {
692 ovs_fatal(0, "received bad reply: %s",
693 ofp_to_string(reply->data, reply->size,
697 osm = ofpbuf_at_assert(reply, 0, sizeof *osm);
698 done = !(ntohs(osm->flags) & OFPSF_REPLY_MORE);
701 /* We've already found the port, but we need to drain
702 * the queue of any other replies for this request. */
706 ofpbuf_use_const(&b, &osm->header, ntohs(osm->header.length));
707 ofpbuf_pull(&b, sizeof(struct ofp_stats_msg));
709 while (!ofputil_pull_phy_port(osm->header.version, &b, pp)) {
710 if (port_no != UINT_MAX ? port_no == pp->port_no
711 : !strcmp(pp->name, port_name)) {
717 VLOG_DBG("received reply with xid %08"PRIx32" "
718 "!= expected %08"PRIx32, recv_xid, send_xid);
720 ofpbuf_delete(reply);
728 /* Opens a connection to 'vconn_name', fetches the port structure for
729 * 'port_name' (which may be a port name or number), and copies it into
732 fetch_ofputil_phy_port(const char *vconn_name, const char *port_name,
733 struct ofputil_phy_port *pp)
735 unsigned int port_no;
739 /* Try to interpret the argument as a port number. */
740 if (!str_to_uint(port_name, 10, &port_no)) {
744 /* Try to find the port based on the Features Reply. If it looks
745 * like the results may be truncated, then use the Port Description
746 * stats message introduced in OVS 1.7. */
747 found = fetch_port_by_features(vconn_name, port_name, port_no, pp,
750 found = fetch_port_by_stats(vconn_name, port_name, port_no, pp);
754 ovs_fatal(0, "%s: couldn't find port `%s'", vconn_name, port_name);
758 /* Returns the port number corresponding to 'port_name' (which may be a port
759 * name or number) within the switch 'vconn_name'. */
761 str_to_port_no(const char *vconn_name, const char *port_name)
763 unsigned int port_no;
765 if (str_to_uint(port_name, 10, &port_no)) {
768 struct ofputil_phy_port pp;
770 fetch_ofputil_phy_port(vconn_name, port_name, &pp);
776 try_set_protocol(struct vconn *vconn, enum ofputil_protocol want,
777 enum ofputil_protocol *cur)
780 struct ofpbuf *request, *reply;
781 enum ofputil_protocol next;
783 request = ofputil_encode_set_protocol(*cur, want, &next);
788 run(vconn_transact_noreply(vconn, request, &reply),
789 "talking to %s", vconn_get_name(vconn));
791 char *s = ofp_to_string(reply->data, reply->size, 2);
792 VLOG_DBG("%s: failed to set protocol, switch replied: %s",
793 vconn_get_name(vconn), s);
795 ofpbuf_delete(reply);
803 static enum ofputil_protocol
804 set_protocol_for_flow_dump(struct vconn *vconn,
805 enum ofputil_protocol cur_protocol,
806 enum ofputil_protocol usable_protocols)
811 for (i = 0; i < ofputil_n_flow_dump_protocols; i++) {
812 enum ofputil_protocol f = ofputil_flow_dump_protocols[i];
813 if (f & usable_protocols & allowed_protocols
814 && try_set_protocol(vconn, f, &cur_protocol)) {
819 usable_s = ofputil_protocols_to_string(usable_protocols);
820 if (usable_protocols & allowed_protocols) {
821 ovs_fatal(0, "switch does not support any of the usable flow "
822 "formats (%s)", usable_s);
824 char *allowed_s = ofputil_protocols_to_string(allowed_protocols);
825 ovs_fatal(0, "none of the usable flow formats (%s) is among the "
826 "allowed flow formats (%s)", usable_s, allowed_s);
830 static struct vconn *
831 prepare_dump_flows(int argc, char *argv[], bool aggregate,
832 struct ofpbuf **requestp)
834 enum ofputil_protocol usable_protocols, protocol;
835 struct ofputil_flow_stats_request fsr;
838 parse_ofp_flow_stats_request_str(&fsr, aggregate, argc > 2 ? argv[2] : "");
839 usable_protocols = ofputil_flow_stats_request_usable_protocols(&fsr);
841 protocol = open_vconn(argv[1], &vconn);
842 protocol = set_protocol_for_flow_dump(vconn, protocol, usable_protocols);
843 *requestp = ofputil_encode_flow_stats_request(&fsr, protocol);
848 ofctl_dump_flows__(int argc, char *argv[], bool aggregate)
850 struct ofpbuf *request;
853 vconn = prepare_dump_flows(argc, argv, aggregate, &request);
854 dump_stats_transaction__(vconn, request);
859 compare_flows(const void *afs_, const void *bfs_)
861 const struct ofputil_flow_stats *afs = afs_;
862 const struct ofputil_flow_stats *bfs = bfs_;
863 const struct cls_rule *a = &afs->rule;
864 const struct cls_rule *b = &bfs->rule;
865 const struct sort_criterion *sc;
867 for (sc = criteria; sc < &criteria[n_criteria]; sc++) {
868 const struct mf_field *f = sc->field;
872 ret = a->priority < b->priority ? -1 : a->priority > b->priority;
876 ina = mf_are_prereqs_ok(f, &a->flow) && !mf_is_all_wild(f, &a->wc);
877 inb = mf_are_prereqs_ok(f, &b->flow) && !mf_is_all_wild(f, &b->wc);
879 /* Skip the test for sc->order, so that missing fields always
880 * sort to the end whether we're sorting in ascending or
881 * descending order. */
884 union mf_value aval, bval;
886 mf_get_value(f, &a->flow, &aval);
887 mf_get_value(f, &b->flow, &bval);
888 ret = memcmp(&aval, &bval, f->n_bytes);
893 return sc->order == SORT_ASC ? ret : -ret;
901 ofctl_dump_flows(int argc, char *argv[])
904 return ofctl_dump_flows__(argc, argv, false);
906 struct ofputil_flow_stats *fses;
907 size_t n_fses, allocated_fses;
908 struct ofpbuf *request;
909 struct ofpbuf ofpacts;
910 struct ofpbuf *reply;
916 vconn = prepare_dump_flows(argc, argv, false, &request);
917 send_xid = ((struct ofp_header *) request->data)->xid;
918 send_openflow_buffer(vconn, request);
921 n_fses = allocated_fses = 0;
923 ofpbuf_init(&ofpacts, 0);
925 struct ofputil_flow_stats *fs;
927 if (n_fses >= allocated_fses) {
928 fses = x2nrealloc(fses, &allocated_fses, sizeof *fses);
932 if (!recv_flow_stats_reply(vconn, send_xid, &reply, fs,
936 fs->ofpacts = xmemdup(fs->ofpacts, fs->ofpacts_len);
939 ofpbuf_uninit(&ofpacts);
941 qsort(fses, n_fses, sizeof *fses, compare_flows);
944 for (i = 0; i < n_fses; i++) {
946 ofp_print_flow_stats(&s, &fses[i]);
951 for (i = 0; i < n_fses; i++) {
952 free(fses[i].ofpacts);
961 ofctl_dump_aggregate(int argc, char *argv[])
963 return ofctl_dump_flows__(argc, argv, true);
967 ofctl_queue_stats(int argc, char *argv[])
969 struct ofp_queue_stats_request *req;
970 struct ofpbuf *request;
972 req = alloc_stats_request(sizeof *req, OFPST_QUEUE, &request);
974 if (argc > 2 && argv[2][0] && strcasecmp(argv[2], "all")) {
975 req->port_no = htons(str_to_port_no(argv[1], argv[2]));
977 req->port_no = htons(OFPP_ALL);
979 if (argc > 3 && argv[3][0] && strcasecmp(argv[3], "all")) {
980 req->queue_id = htonl(atoi(argv[3]));
982 req->queue_id = htonl(OFPQ_ALL);
985 memset(req->pad, 0, sizeof req->pad);
987 dump_stats_transaction(argv[1], request);
990 static enum ofputil_protocol
991 open_vconn_for_flow_mod(const char *remote,
992 const struct ofputil_flow_mod *fms, size_t n_fms,
993 struct vconn **vconnp)
995 enum ofputil_protocol usable_protocols;
996 enum ofputil_protocol cur_protocol;
1000 /* Figure out what flow formats will work. */
1001 usable_protocols = ofputil_flow_mod_usable_protocols(fms, n_fms);
1002 if (!(usable_protocols & allowed_protocols)) {
1003 char *allowed_s = ofputil_protocols_to_string(allowed_protocols);
1004 usable_s = ofputil_protocols_to_string(usable_protocols);
1005 ovs_fatal(0, "none of the usable flow formats (%s) is among the "
1006 "allowed flow formats (%s)", usable_s, allowed_s);
1009 /* If the initial flow format is allowed and usable, keep it. */
1010 cur_protocol = open_vconn(remote, vconnp);
1011 if (usable_protocols & allowed_protocols & cur_protocol) {
1012 return cur_protocol;
1015 /* Otherwise try each flow format in turn. */
1016 for (i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) {
1017 enum ofputil_protocol f = 1 << i;
1019 if (f != cur_protocol
1020 && f & usable_protocols & allowed_protocols
1021 && try_set_protocol(*vconnp, f, &cur_protocol)) {
1026 usable_s = ofputil_protocols_to_string(usable_protocols);
1027 ovs_fatal(0, "switch does not support any of the usable flow "
1028 "formats (%s)", usable_s);
1032 ofctl_flow_mod__(const char *remote, struct ofputil_flow_mod *fms,
1035 enum ofputil_protocol protocol;
1036 struct vconn *vconn;
1039 protocol = open_vconn_for_flow_mod(remote, fms, n_fms, &vconn);
1041 for (i = 0; i < n_fms; i++) {
1042 struct ofputil_flow_mod *fm = &fms[i];
1044 transact_noreply(vconn, ofputil_encode_flow_mod(fm, protocol));
1051 ofctl_flow_mod_file(int argc OVS_UNUSED, char *argv[], uint16_t command)
1053 struct ofputil_flow_mod *fms = NULL;
1056 parse_ofp_flow_mod_file(argv[2], command, &fms, &n_fms);
1057 ofctl_flow_mod__(argv[1], fms, n_fms);
1062 ofctl_flow_mod(int argc, char *argv[], uint16_t command)
1064 if (argc > 2 && !strcmp(argv[2], "-")) {
1065 ofctl_flow_mod_file(argc, argv, command);
1067 struct ofputil_flow_mod fm;
1068 parse_ofp_flow_mod_str(&fm, argc > 2 ? argv[2] : "", command, false);
1069 ofctl_flow_mod__(argv[1], &fm, 1);
1074 ofctl_add_flow(int argc, char *argv[])
1076 ofctl_flow_mod(argc, argv, OFPFC_ADD);
1080 ofctl_add_flows(int argc, char *argv[])
1082 ofctl_flow_mod_file(argc, argv, OFPFC_ADD);
1086 ofctl_mod_flows(int argc, char *argv[])
1088 ofctl_flow_mod(argc, argv, strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY);
1092 ofctl_del_flows(int argc, char *argv[])
1094 ofctl_flow_mod(argc, argv, strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE);
1098 set_packet_in_format(struct vconn *vconn,
1099 enum nx_packet_in_format packet_in_format)
1101 struct ofpbuf *spif = ofputil_make_set_packet_in_format(packet_in_format);
1102 transact_noreply(vconn, spif);
1103 VLOG_DBG("%s: using user-specified packet in format %s",
1104 vconn_get_name(vconn),
1105 ofputil_packet_in_format_to_string(packet_in_format));
1109 monitor_set_invalid_ttl_to_controller(struct vconn *vconn)
1111 struct ofp_switch_config config;
1112 enum ofp_config_flags flags;
1114 fetch_switch_config(vconn, &config);
1115 flags = ntohs(config.flags);
1116 if (!(flags & OFPC_INVALID_TTL_TO_CONTROLLER)) {
1117 /* Set the invalid ttl config. */
1118 flags |= OFPC_INVALID_TTL_TO_CONTROLLER;
1120 config.flags = htons(flags);
1121 set_switch_config(vconn, &config);
1123 /* Then retrieve the configuration to see if it really took. OpenFlow
1124 * doesn't define error reporting for bad modes, so this is all we can
1126 fetch_switch_config(vconn, &config);
1127 flags = ntohs(config.flags);
1128 if (!(flags & OFPC_INVALID_TTL_TO_CONTROLLER)) {
1129 ovs_fatal(0, "setting invalid_ttl_to_controller failed (this "
1130 "switch probably doesn't support mode)");
1137 /* Converts hex digits in 'hex' to an OpenFlow message in '*msgp'. The
1138 * caller must free '*msgp'. On success, returns NULL. On failure, returns
1139 * an error message and stores NULL in '*msgp'. */
1141 openflow_from_hex(const char *hex, struct ofpbuf **msgp)
1143 struct ofp_header *oh;
1146 msg = ofpbuf_new(strlen(hex) / 2);
1149 if (ofpbuf_put_hex(msg, hex, NULL)[0] != '\0') {
1151 return "Trailing garbage in hex data";
1154 if (msg->size < sizeof(struct ofp_header)) {
1156 return "Message too short for OpenFlow";
1160 if (msg->size != ntohs(oh->length)) {
1162 return "Message size does not match length in OpenFlow header";
1170 ofctl_send(struct unixctl_conn *conn, int argc,
1171 const char *argv[], void *vconn_)
1173 struct vconn *vconn = vconn_;
1180 for (i = 1; i < argc; i++) {
1181 const char *error_msg;
1185 error_msg = openflow_from_hex(argv[i], &msg);
1187 ds_put_format(&reply, "%s\n", error_msg);
1192 fprintf(stderr, "send: ");
1193 ofp_print(stderr, msg->data, msg->size, verbosity);
1195 error = vconn_send_block(vconn, msg);
1198 ds_put_format(&reply, "%s\n", strerror(error));
1201 ds_put_cstr(&reply, "sent\n");
1206 unixctl_command_reply(conn, ds_cstr(&reply));
1208 unixctl_command_reply_error(conn, ds_cstr(&reply));
1213 struct barrier_aux {
1214 struct vconn *vconn; /* OpenFlow connection for sending barrier. */
1215 struct unixctl_conn *conn; /* Connection waiting for barrier response. */
1219 ofctl_barrier(struct unixctl_conn *conn, int argc OVS_UNUSED,
1220 const char *argv[] OVS_UNUSED, void *aux_)
1222 struct barrier_aux *aux = aux_;
1227 unixctl_command_reply_error(conn, "already waiting for barrier reply");
1231 msg = ofputil_encode_barrier_request();
1232 error = vconn_send_block(aux->vconn, msg);
1235 unixctl_command_reply_error(conn, strerror(error));
1242 ofctl_set_output_file(struct unixctl_conn *conn, int argc OVS_UNUSED,
1243 const char *argv[], void *aux OVS_UNUSED)
1247 fd = open(argv[1], O_CREAT | O_TRUNC | O_WRONLY, 0666);
1249 unixctl_command_reply_error(conn, strerror(errno));
1254 dup2(fd, STDERR_FILENO);
1256 unixctl_command_reply(conn, NULL);
1260 struct vconn *vconn;
1261 struct unixctl_server *server;
1266 ofctl_block(struct unixctl_conn *conn, int argc OVS_UNUSED,
1267 const char *argv[] OVS_UNUSED, void *block_)
1269 struct block_aux *block = block_;
1271 if (block->blocked) {
1272 unixctl_command_reply(conn, "already blocking");
1276 block->blocked = true;
1277 unixctl_command_reply(conn, NULL);
1279 unixctl_server_run(block->server);
1280 if (!block->blocked) {
1283 vconn_run(block->vconn);
1285 unixctl_server_wait(block->server);
1286 vconn_run_wait(block->vconn);
1292 ofctl_unblock(struct unixctl_conn *conn, int argc OVS_UNUSED,
1293 const char *argv[] OVS_UNUSED, void *block_)
1295 struct block_aux *block = block_;
1297 if (!block->blocked) {
1298 unixctl_command_reply(conn, "not blocking");
1300 block->blocked = false;
1301 unixctl_command_reply(conn, NULL);
1306 monitor_vconn(struct vconn *vconn)
1308 struct barrier_aux barrier_aux = { vconn, NULL };
1309 struct block_aux block;
1310 struct unixctl_server *server;
1311 bool exiting = false;
1314 daemon_save_fd(STDERR_FILENO);
1316 error = unixctl_server_create(NULL, &server);
1318 ovs_fatal(error, "failed to create unixctl server");
1320 unixctl_command_register("exit", "", 0, 0, ofctl_exit, &exiting);
1321 unixctl_command_register("ofctl/send", "OFMSG...", 1, INT_MAX,
1323 unixctl_command_register("ofctl/barrier", "", 0, 0,
1324 ofctl_barrier, &barrier_aux);
1325 unixctl_command_register("ofctl/set-output-file", "FILE", 1, 1,
1326 ofctl_set_output_file, NULL);
1328 block.vconn = vconn;
1329 block.server = server;
1330 block.blocked = false;
1331 unixctl_command_register("ofctl/block", "", 0, 0, ofctl_block, &block);
1332 unixctl_command_register("ofctl/unblock", "", 0, 0, ofctl_unblock, &block);
1334 daemonize_complete();
1340 unixctl_server_run(server);
1345 retval = vconn_recv(vconn, &b);
1346 if (retval == EAGAIN) {
1349 run(retval, "vconn_recv");
1352 time_t now = time_wall();
1355 strftime(s, sizeof s, "%Y-%m-%d %H:%M:%S: ", gmtime(&now));
1359 msg_type = ((const struct ofp_header *) b->data)->type;
1360 ofp_print(stderr, b->data, b->size, verbosity + 2);
1363 if (barrier_aux.conn && msg_type == OFPT10_BARRIER_REPLY) {
1364 unixctl_command_reply(barrier_aux.conn, NULL);
1365 barrier_aux.conn = NULL;
1374 vconn_run_wait(vconn);
1375 vconn_recv_wait(vconn);
1376 unixctl_server_wait(server);
1380 unixctl_server_destroy(server);
1384 ofctl_monitor(int argc, char *argv[])
1386 struct vconn *vconn;
1389 open_vconn(argv[1], &vconn);
1390 for (i = 2; i < argc; i++) {
1391 const char *arg = argv[i];
1393 if (isdigit((unsigned char) *arg)) {
1394 struct ofp_switch_config config;
1396 fetch_switch_config(vconn, &config);
1397 config.miss_send_len = htons(atoi(arg));
1398 set_switch_config(vconn, &config);
1399 } else if (!strcmp(arg, "invalid_ttl")) {
1400 monitor_set_invalid_ttl_to_controller(vconn);
1401 } else if (!strncmp(arg, "watch:", 6)) {
1402 struct ofputil_flow_monitor_request fmr;
1405 parse_flow_monitor_request(&fmr, arg + 6);
1407 msg = ofpbuf_new(0);
1408 ofputil_append_flow_monitor_request(&fmr, msg);
1409 dump_stats_transaction__(vconn, msg);
1411 ovs_fatal(0, "%s: unsupported \"monitor\" argument", arg);
1415 if (preferred_packet_in_format >= 0) {
1416 set_packet_in_format(vconn, preferred_packet_in_format);
1418 struct ofpbuf *spif, *reply;
1420 spif = ofputil_make_set_packet_in_format(NXPIF_NXM);
1421 run(vconn_transact_noreply(vconn, spif, &reply),
1422 "talking to %s", vconn_get_name(vconn));
1424 char *s = ofp_to_string(reply->data, reply->size, 2);
1425 VLOG_DBG("%s: failed to set packet in format to nxm, controller"
1426 " replied: %s. Falling back to the switch default.",
1427 vconn_get_name(vconn), s);
1429 ofpbuf_delete(reply);
1433 monitor_vconn(vconn);
1437 ofctl_snoop(int argc OVS_UNUSED, char *argv[])
1439 struct vconn *vconn;
1441 open_vconn__(argv[1], "snoop", &vconn);
1442 monitor_vconn(vconn);
1446 ofctl_dump_ports(int argc, char *argv[])
1448 struct ofp_port_stats_request *req;
1449 struct ofpbuf *request;
1452 req = alloc_stats_request(sizeof *req, OFPST_PORT, &request);
1453 port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_NONE;
1454 req->port_no = htons(port);
1455 dump_stats_transaction(argv[1], request);
1459 ofctl_dump_ports_desc(int argc OVS_UNUSED, char *argv[])
1461 dump_trivial_stats_transaction(argv[1], OFPST_PORT_DESC);
1465 ofctl_probe(int argc OVS_UNUSED, char *argv[])
1467 struct ofpbuf *request;
1468 struct vconn *vconn;
1469 struct ofpbuf *reply;
1471 make_openflow(sizeof(struct ofp_header), OFPT_ECHO_REQUEST, &request);
1472 open_vconn(argv[1], &vconn);
1473 run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]);
1474 if (reply->size != sizeof(struct ofp_header)) {
1475 ovs_fatal(0, "reply does not match request");
1477 ofpbuf_delete(reply);
1482 ofctl_packet_out(int argc, char *argv[])
1484 struct ofputil_packet_out po;
1485 struct ofpbuf ofpacts;
1486 struct vconn *vconn;
1489 ofpbuf_init(&ofpacts, 64);
1490 parse_ofpacts(argv[3], &ofpacts);
1492 po.buffer_id = UINT32_MAX;
1493 po.in_port = (!strcasecmp(argv[2], "none") ? OFPP_NONE
1494 : !strcasecmp(argv[2], "local") ? OFPP_LOCAL
1495 : str_to_port_no(argv[1], argv[2]));
1496 po.ofpacts = ofpacts.data;
1497 po.ofpacts_len = ofpacts.size;
1499 open_vconn(argv[1], &vconn);
1500 for (i = 4; i < argc; i++) {
1501 struct ofpbuf *packet, *opo;
1502 const char *error_msg;
1504 error_msg = eth_from_hex(argv[i], &packet);
1506 ovs_fatal(0, "%s", error_msg);
1509 po.packet = packet->data;
1510 po.packet_len = packet->size;
1511 opo = ofputil_encode_packet_out(&po);
1512 transact_noreply(vconn, opo);
1513 ofpbuf_delete(packet);
1516 ofpbuf_uninit(&ofpacts);
1520 ofctl_mod_port(int argc OVS_UNUSED, char *argv[])
1522 struct ofp_config_flag {
1523 const char *name; /* The flag's name. */
1524 enum ofputil_port_config bit; /* Bit to turn on or off. */
1525 bool on; /* Value to set the bit to. */
1527 static const struct ofp_config_flag flags[] = {
1528 { "up", OFPUTIL_PC_PORT_DOWN, false },
1529 { "down", OFPUTIL_PC_PORT_DOWN, true },
1530 { "stp", OFPUTIL_PC_NO_STP, false },
1531 { "receive", OFPUTIL_PC_NO_RECV, false },
1532 { "receive-stp", OFPUTIL_PC_NO_RECV_STP, false },
1533 { "flood", OFPUTIL_PC_NO_FLOOD, false },
1534 { "forward", OFPUTIL_PC_NO_FWD, false },
1535 { "packet-in", OFPUTIL_PC_NO_PACKET_IN, false },
1538 const struct ofp_config_flag *flag;
1539 enum ofputil_protocol protocol;
1540 struct ofputil_port_mod pm;
1541 struct ofputil_phy_port pp;
1542 struct vconn *vconn;
1543 const char *command;
1546 fetch_ofputil_phy_port(argv[1], argv[2], &pp);
1548 pm.port_no = pp.port_no;
1549 memcpy(pm.hw_addr, pp.hw_addr, ETH_ADDR_LEN);
1554 if (!strncasecmp(argv[3], "no-", 3)) {
1555 command = argv[3] + 3;
1557 } else if (!strncasecmp(argv[3], "no", 2)) {
1558 command = argv[3] + 2;
1564 for (flag = flags; flag < &flags[ARRAY_SIZE(flags)]; flag++) {
1565 if (!strcasecmp(command, flag->name)) {
1566 pm.mask = flag->bit;
1567 pm.config = flag->on ^ not ? flag->bit : 0;
1571 ovs_fatal(0, "unknown mod-port command '%s'", argv[3]);
1574 protocol = open_vconn(argv[1], &vconn);
1575 transact_noreply(vconn, ofputil_encode_port_mod(&pm, protocol));
1580 ofctl_get_frags(int argc OVS_UNUSED, char *argv[])
1582 struct ofp_switch_config config;
1583 struct vconn *vconn;
1585 open_vconn(argv[1], &vconn);
1586 fetch_switch_config(vconn, &config);
1587 puts(ofputil_frag_handling_to_string(ntohs(config.flags)));
1592 ofctl_set_frags(int argc OVS_UNUSED, char *argv[])
1594 struct ofp_switch_config config;
1595 enum ofp_config_flags mode;
1596 struct vconn *vconn;
1599 if (!ofputil_frag_handling_from_string(argv[2], &mode)) {
1600 ovs_fatal(0, "%s: unknown fragment handling mode", argv[2]);
1603 open_vconn(argv[1], &vconn);
1604 fetch_switch_config(vconn, &config);
1605 flags = htons(mode) | (config.flags & htons(~OFPC_FRAG_MASK));
1606 if (flags != config.flags) {
1607 /* Set the configuration. */
1608 config.flags = flags;
1609 set_switch_config(vconn, &config);
1611 /* Then retrieve the configuration to see if it really took. OpenFlow
1612 * doesn't define error reporting for bad modes, so this is all we can
1614 fetch_switch_config(vconn, &config);
1615 if (flags != config.flags) {
1616 ovs_fatal(0, "%s: setting fragment handling mode failed (this "
1617 "switch probably doesn't support mode \"%s\")",
1618 argv[1], ofputil_frag_handling_to_string(mode));
1625 ofctl_ping(int argc, char *argv[])
1627 size_t max_payload = 65535 - sizeof(struct ofp_header);
1628 unsigned int payload;
1629 struct vconn *vconn;
1632 payload = argc > 2 ? atoi(argv[2]) : 64;
1633 if (payload > max_payload) {
1634 ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
1637 open_vconn(argv[1], &vconn);
1638 for (i = 0; i < 10; i++) {
1639 struct timeval start, end;
1640 struct ofpbuf *request, *reply;
1641 struct ofp_header *rq_hdr, *rpy_hdr;
1643 rq_hdr = make_openflow(sizeof(struct ofp_header) + payload,
1644 OFPT_ECHO_REQUEST, &request);
1645 random_bytes(rq_hdr + 1, payload);
1647 xgettimeofday(&start);
1648 run(vconn_transact(vconn, ofpbuf_clone(request), &reply), "transact");
1649 xgettimeofday(&end);
1651 rpy_hdr = reply->data;
1652 if (reply->size != request->size
1653 || memcmp(rpy_hdr + 1, rq_hdr + 1, payload)
1654 || rpy_hdr->xid != rq_hdr->xid
1655 || rpy_hdr->type != OFPT_ECHO_REPLY) {
1656 printf("Reply does not match request. Request:\n");
1657 ofp_print(stdout, request, request->size, verbosity + 2);
1659 ofp_print(stdout, reply, reply->size, verbosity + 2);
1661 printf("%zu bytes from %s: xid=%08"PRIx32" time=%.1f ms\n",
1662 reply->size - sizeof *rpy_hdr, argv[1], ntohl(rpy_hdr->xid),
1663 (1000*(double)(end.tv_sec - start.tv_sec))
1664 + (.001*(end.tv_usec - start.tv_usec)));
1665 ofpbuf_delete(request);
1666 ofpbuf_delete(reply);
1672 ofctl_benchmark(int argc OVS_UNUSED, char *argv[])
1674 size_t max_payload = 65535 - sizeof(struct ofp_header);
1675 struct timeval start, end;
1676 unsigned int payload_size, message_size;
1677 struct vconn *vconn;
1682 payload_size = atoi(argv[2]);
1683 if (payload_size > max_payload) {
1684 ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload);
1686 message_size = sizeof(struct ofp_header) + payload_size;
1688 count = atoi(argv[3]);
1690 printf("Sending %d packets * %u bytes (with header) = %u bytes total\n",
1691 count, message_size, count * message_size);
1693 open_vconn(argv[1], &vconn);
1694 xgettimeofday(&start);
1695 for (i = 0; i < count; i++) {
1696 struct ofpbuf *request, *reply;
1697 struct ofp_header *rq_hdr;
1699 rq_hdr = make_openflow(message_size, OFPT_ECHO_REQUEST, &request);
1700 memset(rq_hdr + 1, 0, payload_size);
1701 run(vconn_transact(vconn, request, &reply), "transact");
1702 ofpbuf_delete(reply);
1704 xgettimeofday(&end);
1707 duration = ((1000*(double)(end.tv_sec - start.tv_sec))
1708 + (.001*(end.tv_usec - start.tv_usec)));
1709 printf("Finished in %.1f ms (%.0f packets/s) (%.0f bytes/s)\n",
1710 duration, count / (duration / 1000.0),
1711 count * message_size / (duration / 1000.0));
1715 ofctl_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
1720 /* replace-flows and diff-flows commands. */
1722 /* A flow table entry, possibly with two different versions. */
1724 struct cls_rule rule; /* Within a "struct classifier". */
1725 struct fte_version *versions[2];
1728 /* One version of a Flow Table Entry. */
1729 struct fte_version {
1731 uint16_t idle_timeout;
1732 uint16_t hard_timeout;
1734 struct ofpact *ofpacts;
1738 /* Frees 'version' and the data that it owns. */
1740 fte_version_free(struct fte_version *version)
1743 free(version->ofpacts);
1748 /* Returns true if 'a' and 'b' are the same, false if they differ.
1750 * Ignores differences in 'flags' because there's no way to retrieve flags from
1751 * an OpenFlow switch. We have to assume that they are the same. */
1753 fte_version_equals(const struct fte_version *a, const struct fte_version *b)
1755 return (a->cookie == b->cookie
1756 && a->idle_timeout == b->idle_timeout
1757 && a->hard_timeout == b->hard_timeout
1758 && ofpacts_equal(a->ofpacts, a->ofpacts_len,
1759 b->ofpacts, b->ofpacts_len));
1762 /* Prints 'version' on stdout. Expects the caller to have printed the rule
1763 * associated with the version. */
1765 fte_version_print(const struct fte_version *version)
1769 if (version->cookie != htonll(0)) {
1770 printf(" cookie=0x%"PRIx64, ntohll(version->cookie));
1772 if (version->idle_timeout != OFP_FLOW_PERMANENT) {
1773 printf(" idle_timeout=%"PRIu16, version->idle_timeout);
1775 if (version->hard_timeout != OFP_FLOW_PERMANENT) {
1776 printf(" hard_timeout=%"PRIu16, version->hard_timeout);
1780 ofpacts_format(version->ofpacts, version->ofpacts_len, &s);
1781 printf(" %s\n", ds_cstr(&s));
1786 fte_from_cls_rule(const struct cls_rule *cls_rule)
1788 return cls_rule ? CONTAINER_OF(cls_rule, struct fte, rule) : NULL;
1791 /* Frees 'fte' and its versions. */
1793 fte_free(struct fte *fte)
1796 fte_version_free(fte->versions[0]);
1797 fte_version_free(fte->versions[1]);
1802 /* Frees all of the FTEs within 'cls'. */
1804 fte_free_all(struct classifier *cls)
1806 struct cls_cursor cursor;
1807 struct fte *fte, *next;
1809 cls_cursor_init(&cursor, cls, NULL);
1810 CLS_CURSOR_FOR_EACH_SAFE (fte, next, rule, &cursor) {
1811 classifier_remove(cls, &fte->rule);
1814 classifier_destroy(cls);
1817 /* Searches 'cls' for an FTE matching 'rule', inserting a new one if
1818 * necessary. Sets 'version' as the version of that rule with the given
1819 * 'index', replacing any existing version, if any.
1821 * Takes ownership of 'version'. */
1823 fte_insert(struct classifier *cls, const struct cls_rule *rule,
1824 struct fte_version *version, int index)
1826 struct fte *old, *fte;
1828 fte = xzalloc(sizeof *fte);
1830 fte->versions[index] = version;
1832 old = fte_from_cls_rule(classifier_replace(cls, &fte->rule));
1834 fte_version_free(old->versions[index]);
1835 fte->versions[!index] = old->versions[!index];
1840 /* Reads the flows in 'filename' as flow table entries in 'cls' for the version
1841 * with the specified 'index'. Returns the flow formats able to represent the
1842 * flows that were read. */
1843 static enum ofputil_protocol
1844 read_flows_from_file(const char *filename, struct classifier *cls, int index)
1846 enum ofputil_protocol usable_protocols;
1850 file = !strcmp(filename, "-") ? stdin : fopen(filename, "r");
1852 ovs_fatal(errno, "%s: open", filename);
1856 usable_protocols = OFPUTIL_P_ANY;
1857 while (!ds_get_preprocessed_line(&s, file)) {
1858 struct fte_version *version;
1859 struct ofputil_flow_mod fm;
1861 parse_ofp_str(&fm, OFPFC_ADD, ds_cstr(&s), true);
1863 version = xmalloc(sizeof *version);
1864 version->cookie = fm.new_cookie;
1865 version->idle_timeout = fm.idle_timeout;
1866 version->hard_timeout = fm.hard_timeout;
1867 version->flags = fm.flags & (OFPFF_SEND_FLOW_REM | OFPFF_EMERG);
1868 version->ofpacts = fm.ofpacts;
1869 version->ofpacts_len = fm.ofpacts_len;
1871 usable_protocols &= ofputil_usable_protocols(&fm.cr);
1873 fte_insert(cls, &fm.cr, version, index);
1877 if (file != stdin) {
1881 return usable_protocols;
1885 recv_flow_stats_reply(struct vconn *vconn, ovs_be32 send_xid,
1886 struct ofpbuf **replyp,
1887 struct ofputil_flow_stats *fs, struct ofpbuf *ofpacts)
1889 struct ofpbuf *reply = *replyp;
1895 /* Get a flow stats reply message, if we don't already have one. */
1897 const struct ofputil_msg_type *type;
1898 enum ofputil_msg_code code;
1901 run(vconn_recv_block(vconn, &reply),
1902 "OpenFlow packet receive failed");
1903 } while (((struct ofp_header *) reply->data)->xid != send_xid);
1905 ofputil_decode_msg_type(reply->data, &type);
1906 code = ofputil_msg_type_code(type);
1907 if (code != OFPUTIL_OFPST_FLOW_REPLY &&
1908 code != OFPUTIL_NXST_FLOW_REPLY) {
1909 ovs_fatal(0, "received bad reply: %s",
1910 ofp_to_string(reply->data, reply->size,
1915 /* Pull an individual flow stats reply out of the message. */
1916 retval = ofputil_decode_flow_stats_reply(fs, reply, false, ofpacts);
1923 flags = ((const struct ofp_stats_msg *) reply->l2)->flags;
1924 ofpbuf_delete(reply);
1925 if (!(flags & htons(OFPSF_REPLY_MORE))) {
1932 ovs_fatal(0, "parse error in reply (%s)",
1933 ofperr_to_string(retval));
1938 /* Reads the OpenFlow flow table from 'vconn', which has currently active flow
1939 * format 'protocol', and adds them as flow table entries in 'cls' for the
1940 * version with the specified 'index'. */
1942 read_flows_from_switch(struct vconn *vconn,
1943 enum ofputil_protocol protocol,
1944 struct classifier *cls, int index)
1946 struct ofputil_flow_stats_request fsr;
1947 struct ofputil_flow_stats fs;
1948 struct ofpbuf *request;
1949 struct ofpbuf ofpacts;
1950 struct ofpbuf *reply;
1953 fsr.aggregate = false;
1954 cls_rule_init_catchall(&fsr.match, 0);
1955 fsr.out_port = OFPP_NONE;
1956 fsr.table_id = 0xff;
1957 fsr.cookie = fsr.cookie_mask = htonll(0);
1958 request = ofputil_encode_flow_stats_request(&fsr, protocol);
1959 send_xid = ((struct ofp_header *) request->data)->xid;
1960 send_openflow_buffer(vconn, request);
1963 ofpbuf_init(&ofpacts, 0);
1964 while (recv_flow_stats_reply(vconn, send_xid, &reply, &fs, &ofpacts)) {
1965 struct fte_version *version;
1967 version = xmalloc(sizeof *version);
1968 version->cookie = fs.cookie;
1969 version->idle_timeout = fs.idle_timeout;
1970 version->hard_timeout = fs.hard_timeout;
1972 version->ofpacts_len = fs.ofpacts_len;
1973 version->ofpacts = xmemdup(fs.ofpacts, fs.ofpacts_len);
1975 fte_insert(cls, &fs.rule, version, index);
1977 ofpbuf_uninit(&ofpacts);
1981 fte_make_flow_mod(const struct fte *fte, int index, uint16_t command,
1982 enum ofputil_protocol protocol, struct list *packets)
1984 const struct fte_version *version = fte->versions[index];
1985 struct ofputil_flow_mod fm;
1989 fm.cookie = htonll(0);
1990 fm.cookie_mask = htonll(0);
1991 fm.new_cookie = version->cookie;
1993 fm.command = command;
1994 fm.idle_timeout = version->idle_timeout;
1995 fm.hard_timeout = version->hard_timeout;
1996 fm.buffer_id = UINT32_MAX;
1997 fm.out_port = OFPP_NONE;
1998 fm.flags = version->flags;
1999 if (command == OFPFC_ADD || command == OFPFC_MODIFY ||
2000 command == OFPFC_MODIFY_STRICT) {
2001 fm.ofpacts = version->ofpacts;
2002 fm.ofpacts_len = version->ofpacts_len;
2008 ofm = ofputil_encode_flow_mod(&fm, protocol);
2009 list_push_back(packets, &ofm->list_node);
2013 ofctl_replace_flows(int argc OVS_UNUSED, char *argv[])
2015 enum { FILE_IDX = 0, SWITCH_IDX = 1 };
2016 enum ofputil_protocol usable_protocols, protocol;
2017 struct cls_cursor cursor;
2018 struct classifier cls;
2019 struct list requests;
2020 struct vconn *vconn;
2023 classifier_init(&cls);
2024 usable_protocols = read_flows_from_file(argv[2], &cls, FILE_IDX);
2026 protocol = open_vconn(argv[1], &vconn);
2027 protocol = set_protocol_for_flow_dump(vconn, protocol, usable_protocols);
2029 read_flows_from_switch(vconn, protocol, &cls, SWITCH_IDX);
2031 list_init(&requests);
2033 /* Delete flows that exist on the switch but not in the file. */
2034 cls_cursor_init(&cursor, &cls, NULL);
2035 CLS_CURSOR_FOR_EACH (fte, rule, &cursor) {
2036 struct fte_version *file_ver = fte->versions[FILE_IDX];
2037 struct fte_version *sw_ver = fte->versions[SWITCH_IDX];
2039 if (sw_ver && !file_ver) {
2040 fte_make_flow_mod(fte, SWITCH_IDX, OFPFC_DELETE_STRICT,
2041 protocol, &requests);
2045 /* Add flows that exist in the file but not on the switch.
2046 * Update flows that exist in both places but differ. */
2047 cls_cursor_init(&cursor, &cls, NULL);
2048 CLS_CURSOR_FOR_EACH (fte, rule, &cursor) {
2049 struct fte_version *file_ver = fte->versions[FILE_IDX];
2050 struct fte_version *sw_ver = fte->versions[SWITCH_IDX];
2053 && (readd || !sw_ver || !fte_version_equals(sw_ver, file_ver))) {
2054 fte_make_flow_mod(fte, FILE_IDX, OFPFC_ADD, protocol, &requests);
2057 transact_multiple_noreply(vconn, &requests);
2064 read_flows_from_source(const char *source, struct classifier *cls, int index)
2068 if (source[0] == '/' || source[0] == '.'
2069 || (!strchr(source, ':') && !stat(source, &s))) {
2070 read_flows_from_file(source, cls, index);
2072 enum ofputil_protocol protocol;
2073 struct vconn *vconn;
2075 protocol = open_vconn(source, &vconn);
2076 protocol = set_protocol_for_flow_dump(vconn, protocol, OFPUTIL_P_ANY);
2077 read_flows_from_switch(vconn, protocol, cls, index);
2083 ofctl_diff_flows(int argc OVS_UNUSED, char *argv[])
2085 bool differences = false;
2086 struct cls_cursor cursor;
2087 struct classifier cls;
2090 classifier_init(&cls);
2091 read_flows_from_source(argv[1], &cls, 0);
2092 read_flows_from_source(argv[2], &cls, 1);
2094 cls_cursor_init(&cursor, &cls, NULL);
2095 CLS_CURSOR_FOR_EACH (fte, rule, &cursor) {
2096 struct fte_version *a = fte->versions[0];
2097 struct fte_version *b = fte->versions[1];
2099 if (!a || !b || !fte_version_equals(a, b)) {
2100 char *rule_s = cls_rule_to_string(&fte->rule);
2102 printf("-%s", rule_s);
2103 fte_version_print(a);
2106 printf("+%s", rule_s);
2107 fte_version_print(b);
2122 /* Undocumented commands for unit testing. */
2125 ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms)
2127 enum ofputil_protocol usable_protocols;
2128 enum ofputil_protocol protocol = 0;
2132 usable_protocols = ofputil_flow_mod_usable_protocols(fms, n_fms);
2133 usable_s = ofputil_protocols_to_string(usable_protocols);
2134 printf("usable protocols: %s\n", usable_s);
2137 if (!(usable_protocols & allowed_protocols)) {
2138 ovs_fatal(0, "no usable protocol");
2140 for (i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) {
2142 if (protocol & usable_protocols & allowed_protocols) {
2146 assert(IS_POW2(protocol));
2148 printf("chosen protocol: %s\n", ofputil_protocol_to_string(protocol));
2150 for (i = 0; i < n_fms; i++) {
2151 struct ofputil_flow_mod *fm = &fms[i];
2154 msg = ofputil_encode_flow_mod(fm, protocol);
2155 ofp_print(stdout, msg->data, msg->size, verbosity);
2162 /* "parse-flow FLOW": parses the argument as a flow (like add-flow) and prints
2163 * it back to stdout. */
2165 ofctl_parse_flow(int argc OVS_UNUSED, char *argv[])
2167 struct ofputil_flow_mod fm;
2169 parse_ofp_flow_mod_str(&fm, argv[1], OFPFC_ADD, false);
2170 ofctl_parse_flows__(&fm, 1);
2173 /* "parse-flows FILENAME": reads the named file as a sequence of flows (like
2174 * add-flows) and prints each of the flows back to stdout. */
2176 ofctl_parse_flows(int argc OVS_UNUSED, char *argv[])
2178 struct ofputil_flow_mod *fms = NULL;
2181 parse_ofp_flow_mod_file(argv[1], OFPFC_ADD, &fms, &n_fms);
2182 ofctl_parse_flows__(fms, n_fms);
2187 ofctl_parse_nxm__(bool oxm)
2192 while (!ds_get_test_line(&in, stdin)) {
2193 struct ofpbuf nx_match;
2194 struct cls_rule rule;
2195 ovs_be64 cookie, cookie_mask;
2199 /* Convert string to nx_match. */
2200 ofpbuf_init(&nx_match, 0);
2201 match_len = nx_match_from_string(ds_cstr(&in), &nx_match);
2203 /* Convert nx_match to cls_rule. */
2205 error = nx_pull_match(&nx_match, match_len, 0, &rule,
2206 &cookie, &cookie_mask);
2208 error = nx_pull_match_loose(&nx_match, match_len, 0, &rule,
2209 &cookie, &cookie_mask);
2215 /* Convert cls_rule back to nx_match. */
2216 ofpbuf_uninit(&nx_match);
2217 ofpbuf_init(&nx_match, 0);
2218 match_len = nx_put_match(&nx_match, oxm, &rule,
2219 cookie, cookie_mask);
2221 /* Convert nx_match to string. */
2222 out = nx_match_to_string(nx_match.data, match_len);
2226 printf("nx_pull_match() returned error %s\n",
2227 ofperr_get_name(error));
2230 ofpbuf_uninit(&nx_match);
2235 /* "parse-nxm": reads a series of NXM nx_match specifications as strings from
2236 * stdin, does some internal fussing with them, and then prints them back as
2237 * strings on stdout. */
2239 ofctl_parse_nxm(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2241 return ofctl_parse_nxm__(false);
2244 /* "parse-oxm": reads a series of OXM nx_match specifications as strings from
2245 * stdin, does some internal fussing with them, and then prints them back as
2246 * strings on stdout. */
2248 ofctl_parse_oxm(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2250 return ofctl_parse_nxm__(true);
2254 print_differences(const void *a_, size_t a_len,
2255 const void *b_, size_t b_len)
2257 const uint8_t *a = a_;
2258 const uint8_t *b = b_;
2261 for (i = 0; i < MIN(a_len, b_len); i++) {
2263 printf("%2zu: %02"PRIx8" -> %02"PRIx8"\n", i, a[i], b[i]);
2266 for (i = a_len; i < b_len; i++) {
2267 printf("%2zu: (none) -> %02"PRIx8"\n", i, b[i]);
2269 for (i = b_len; i < a_len; i++) {
2270 printf("%2zu: %02"PRIx8" -> (none)\n", i, a[i]);
2274 /* "parse-ofp10-actions": reads a series of OpenFlow 1.0 action specifications
2275 * as hex bytes from stdin, converts them to ofpacts, prints them as strings
2276 * on stdout, and then converts them back to hex bytes and prints any
2277 * differences from the input. */
2279 ofctl_parse_ofp10_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2284 while (!ds_get_preprocessed_line(&in, stdin)) {
2285 struct ofpbuf of10_out;
2286 struct ofpbuf of10_in;
2287 struct ofpbuf ofpacts;
2292 /* Parse hex bytes. */
2293 ofpbuf_init(&of10_in, 0);
2294 if (ofpbuf_put_hex(&of10_in, ds_cstr(&in), NULL)[0] != '\0') {
2295 ovs_fatal(0, "Trailing garbage in hex data");
2298 /* Convert to ofpacts. */
2299 ofpbuf_init(&ofpacts, 0);
2300 size = of10_in.size;
2301 error = ofpacts_pull_openflow10(&of10_in, of10_in.size, &ofpacts);
2303 printf("bad OF1.1 actions: %s\n\n", ofperr_get_name(error));
2304 ofpbuf_uninit(&ofpacts);
2305 ofpbuf_uninit(&of10_in);
2308 ofpbuf_push_uninit(&of10_in, size);
2310 /* Print cls_rule. */
2312 ofpacts_format(ofpacts.data, ofpacts.size, &s);
2316 /* Convert back to ofp10 actions and print differences from input. */
2317 ofpbuf_init(&of10_out, 0);
2318 ofpacts_put_openflow10(ofpacts.data, ofpacts.size, &of10_out);
2320 print_differences(of10_in.data, of10_in.size,
2321 of10_out.data, of10_out.size);
2324 ofpbuf_uninit(&ofpacts);
2325 ofpbuf_uninit(&of10_in);
2326 ofpbuf_uninit(&of10_out);
2331 /* "parse-ofp11-match": reads a series of ofp11_match specifications as hex
2332 * bytes from stdin, converts them to cls_rules, prints them as strings on
2333 * stdout, and then converts them back to hex bytes and prints any differences
2334 * from the input. */
2336 ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2341 while (!ds_get_preprocessed_line(&in, stdin)) {
2342 struct ofpbuf match_in;
2343 struct ofp11_match match_out;
2344 struct cls_rule rule;
2347 /* Parse hex bytes. */
2348 ofpbuf_init(&match_in, 0);
2349 if (ofpbuf_put_hex(&match_in, ds_cstr(&in), NULL)[0] != '\0') {
2350 ovs_fatal(0, "Trailing garbage in hex data");
2352 if (match_in.size != sizeof(struct ofp11_match)) {
2353 ovs_fatal(0, "Input is %zu bytes, expected %zu",
2354 match_in.size, sizeof(struct ofp11_match));
2357 /* Convert to cls_rule. */
2358 error = ofputil_cls_rule_from_ofp11_match(match_in.data,
2359 OFP_DEFAULT_PRIORITY, &rule);
2361 printf("bad ofp11_match: %s\n\n", ofperr_get_name(error));
2362 ofpbuf_uninit(&match_in);
2366 /* Print cls_rule. */
2367 cls_rule_print(&rule);
2369 /* Convert back to ofp11_match and print differences from input. */
2370 ofputil_cls_rule_to_ofp11_match(&rule, &match_out);
2372 print_differences(match_in.data, match_in.size,
2373 &match_out, sizeof match_out);
2376 ofpbuf_uninit(&match_in);
2381 /* "parse-ofp11-actions": reads a series of OpenFlow 1.1 action specifications
2382 * as hex bytes from stdin, converts them to ofpacts, prints them as strings
2383 * on stdout, and then converts them back to hex bytes and prints any
2384 * differences from the input. */
2386 ofctl_parse_ofp11_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2391 while (!ds_get_preprocessed_line(&in, stdin)) {
2392 struct ofpbuf of11_out;
2393 struct ofpbuf of11_in;
2394 struct ofpbuf ofpacts;
2399 /* Parse hex bytes. */
2400 ofpbuf_init(&of11_in, 0);
2401 if (ofpbuf_put_hex(&of11_in, ds_cstr(&in), NULL)[0] != '\0') {
2402 ovs_fatal(0, "Trailing garbage in hex data");
2405 /* Convert to ofpacts. */
2406 ofpbuf_init(&ofpacts, 0);
2407 size = of11_in.size;
2408 error = ofpacts_pull_openflow11_actions(&of11_in, of11_in.size,
2411 printf("bad OF1.1 actions: %s\n\n", ofperr_get_name(error));
2412 ofpbuf_uninit(&ofpacts);
2413 ofpbuf_uninit(&of11_in);
2416 ofpbuf_push_uninit(&of11_in, size);
2418 /* Print cls_rule. */
2420 ofpacts_format(ofpacts.data, ofpacts.size, &s);
2424 /* Convert back to ofp11 actions and print differences from input. */
2425 ofpbuf_init(&of11_out, 0);
2426 ofpacts_put_openflow11_actions(ofpacts.data, ofpacts.size, &of11_out);
2428 print_differences(of11_in.data, of11_in.size,
2429 of11_out.data, of11_out.size);
2432 ofpbuf_uninit(&ofpacts);
2433 ofpbuf_uninit(&of11_in);
2434 ofpbuf_uninit(&of11_out);
2439 /* "parse-ofp11-instructions": reads a series of OpenFlow 1.1 instruction
2440 * specifications as hex bytes from stdin, converts them to ofpacts, prints
2441 * them as strings on stdout, and then converts them back to hex bytes and
2442 * prints any differences from the input. */
2444 ofctl_parse_ofp11_instructions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
2449 while (!ds_get_preprocessed_line(&in, stdin)) {
2450 struct ofpbuf of11_out;
2451 struct ofpbuf of11_in;
2452 struct ofpbuf ofpacts;
2457 /* Parse hex bytes. */
2458 ofpbuf_init(&of11_in, 0);
2459 if (ofpbuf_put_hex(&of11_in, ds_cstr(&in), NULL)[0] != '\0') {
2460 ovs_fatal(0, "Trailing garbage in hex data");
2463 /* Convert to ofpacts. */
2464 ofpbuf_init(&ofpacts, 0);
2465 size = of11_in.size;
2466 error = ofpacts_pull_openflow11_instructions(&of11_in, of11_in.size,
2469 printf("bad OF1.1 instructions: %s\n\n", ofperr_get_name(error));
2470 ofpbuf_uninit(&ofpacts);
2471 ofpbuf_uninit(&of11_in);
2474 ofpbuf_push_uninit(&of11_in, size);
2476 /* Print cls_rule. */
2478 ofpacts_format(ofpacts.data, ofpacts.size, &s);
2482 /* Convert back to ofp11 instructions and print differences from
2484 ofpbuf_init(&of11_out, 0);
2485 ofpacts_put_openflow11_instructions(ofpacts.data, ofpacts.size,
2488 print_differences(of11_in.data, of11_in.size,
2489 of11_out.data, of11_out.size);
2492 ofpbuf_uninit(&ofpacts);
2493 ofpbuf_uninit(&of11_in);
2494 ofpbuf_uninit(&of11_out);
2499 /* "print-error ENUM": Prints the type and code of ENUM for every OpenFlow
2502 ofctl_print_error(int argc OVS_UNUSED, char *argv[])
2507 error = ofperr_from_name(argv[1]);
2509 ovs_fatal(0, "unknown error \"%s\"", argv[1]);
2512 for (version = 0; version <= UINT8_MAX; version++) {
2513 const struct ofperr_domain *domain;
2515 domain = ofperr_domain_from_version(version);
2520 printf("%s: %d,%d\n",
2521 ofperr_domain_get_name(domain),
2522 ofperr_get_type(error, domain),
2523 ofperr_get_code(error, domain));
2527 /* "ofp-print HEXSTRING [VERBOSITY]": Converts the hex digits in HEXSTRING into
2528 * binary data, interpreting them as an OpenFlow message, and prints the
2529 * OpenFlow message on stdout, at VERBOSITY (level 2 by default). */
2531 ofctl_ofp_print(int argc, char *argv[])
2533 struct ofpbuf packet;
2535 ofpbuf_init(&packet, strlen(argv[1]) / 2);
2536 if (ofpbuf_put_hex(&packet, argv[1], NULL)[0] != '\0') {
2537 ovs_fatal(0, "trailing garbage following hex bytes");
2539 ofp_print(stdout, packet.data, packet.size, argc > 2 ? atoi(argv[2]) : 2);
2540 ofpbuf_uninit(&packet);
2543 static const struct command all_commands[] = {
2544 { "show", 1, 1, ofctl_show },
2545 { "monitor", 1, 3, ofctl_monitor },
2546 { "snoop", 1, 1, ofctl_snoop },
2547 { "dump-desc", 1, 1, ofctl_dump_desc },
2548 { "dump-tables", 1, 1, ofctl_dump_tables },
2549 { "dump-flows", 1, 2, ofctl_dump_flows },
2550 { "dump-aggregate", 1, 2, ofctl_dump_aggregate },
2551 { "queue-stats", 1, 3, ofctl_queue_stats },
2552 { "add-flow", 2, 2, ofctl_add_flow },
2553 { "add-flows", 2, 2, ofctl_add_flows },
2554 { "mod-flows", 2, 2, ofctl_mod_flows },
2555 { "del-flows", 1, 2, ofctl_del_flows },
2556 { "replace-flows", 2, 2, ofctl_replace_flows },
2557 { "diff-flows", 2, 2, ofctl_diff_flows },
2558 { "packet-out", 4, INT_MAX, ofctl_packet_out },
2559 { "dump-ports", 1, 2, ofctl_dump_ports },
2560 { "dump-ports-desc", 1, 1, ofctl_dump_ports_desc },
2561 { "mod-port", 3, 3, ofctl_mod_port },
2562 { "get-frags", 1, 1, ofctl_get_frags },
2563 { "set-frags", 2, 2, ofctl_set_frags },
2564 { "probe", 1, 1, ofctl_probe },
2565 { "ping", 1, 2, ofctl_ping },
2566 { "benchmark", 3, 3, ofctl_benchmark },
2567 { "help", 0, INT_MAX, ofctl_help },
2569 /* Undocumented commands for testing. */
2570 { "parse-flow", 1, 1, ofctl_parse_flow },
2571 { "parse-flows", 1, 1, ofctl_parse_flows },
2572 { "parse-nx-match", 0, 0, ofctl_parse_nxm },
2573 { "parse-nxm", 0, 0, ofctl_parse_nxm },
2574 { "parse-oxm", 0, 0, ofctl_parse_oxm },
2575 { "parse-ofp10-actions", 0, 0, ofctl_parse_ofp10_actions },
2576 { "parse-ofp11-match", 0, 0, ofctl_parse_ofp11_match },
2577 { "parse-ofp11-actions", 0, 0, ofctl_parse_ofp11_actions },
2578 { "parse-ofp11-instructions", 0, 0, ofctl_parse_ofp11_instructions },
2579 { "print-error", 1, 1, ofctl_print_error },
2580 { "ofp-print", 1, 2, ofctl_ofp_print },
2582 { NULL, 0, 0, NULL },