X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=utilities%2Fovs-ofctl.c;h=6ef70702b92bc8916ba412a7ea13dc98689dd89a;hb=35303d715b1f0db46e6a27146815061a60385dc6;hp=9ef11b0d8e38bb939f406d5bdfd6e9f4fea06310;hpb=0fb88c18fb26dcbe353501d346ac03295d552b36;p=cascardo%2Fovs.git diff --git a/utilities/ovs-ofctl.c b/utilities/ovs-ofctl.c index 9ef11b0d8..6ef70702b 100644 --- a/utilities/ovs-ofctl.c +++ b/utilities/ovs-ofctl.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,7 +25,7 @@ #include #include #include -#include +#include #include #include @@ -36,6 +36,7 @@ #include "compiler.h" #include "dirs.h" #include "dynamic-string.h" +#include "fatal-signal.h" #include "nx-match.h" #include "odp-util.h" #include "ofp-actions.h" @@ -49,7 +50,9 @@ #include "ofproto/ofproto.h" #include "openflow/nicira-ext.h" #include "openflow/openflow.h" +#include "dp-packet.h" #include "packets.h" +#include "pcap-file.h" #include "poll-loop.h" #include "random.h" #include "stream-ssl.h" @@ -57,13 +60,19 @@ #include "timeval.h" #include "unixctl.h" #include "util.h" -#include "vconn.h" -#include "vlog.h" +#include "openvswitch/vconn.h" +#include "openvswitch/vlog.h" #include "meta-flow.h" #include "sort.h" VLOG_DEFINE_THIS_MODULE(ofctl); +/* --bundle: Use OpenFlow 1.4 bundle for making the flow table change atomic. + * NOTE: Also the flow mod will use OpenFlow 1.4, so the semantics may be + * different (see the comment in parse_options() for details). + */ +static bool bundle = false; + /* --strict: Use strict matching for flow mod commands? Additionally governs * use of nx_pull_match() instead of nx_pull_match_loose() in parse-nx-match. */ @@ -89,6 +98,10 @@ static int verbosity; * "snoop" command? */ static bool timestamp; +/* --unixctl-path: Path to use for unixctl server, for "monitor" and "snoop" + commands. */ +static char *unixctl_path; + /* --sort, --rsort: Sort order. */ enum sort_order { SORT_ASC, SORT_DESC }; struct sort_criterion { @@ -98,9 +111,9 @@ struct sort_criterion { static struct sort_criterion *criteria; static size_t n_criteria, allocated_criteria; -static const struct command *get_all_commands(void); +static const struct ovs_cmdl_command *get_all_commands(void); -static void usage(void) NO_RETURN; +OVS_NO_RETURN static void usage(void); static void parse_options(int argc, char *argv[]); static bool recv_flow_stats_reply(struct vconn *, ovs_be32 send_xid, @@ -110,10 +123,14 @@ static bool recv_flow_stats_reply(struct vconn *, ovs_be32 send_xid, int main(int argc, char *argv[]) { + struct ovs_cmdl_context ctx = { .argc = 0, }; set_program_name(argv[0]); + service_start(&argc, &argv); parse_options(argc, argv); - signal(SIGPIPE, SIG_IGN); - run_command(argc - optind, argv + optind, get_all_commands()); + fatal_ignore_sigpipe(); + ctx.argc = argc - optind; + ctx.argv = argv + optind; + ovs_cmdl_run_command(&ctx, get_all_commands()); return 0; } @@ -147,6 +164,8 @@ parse_options(int argc, char *argv[]) OPT_TIMESTAMP, OPT_SORT, OPT_RSORT, + OPT_UNIXCTL, + OPT_BUNDLE, DAEMON_OPTION_ENUMS, OFP_VERSION_OPTION_ENUMS, VLOG_OPTION_ENUMS @@ -161,17 +180,37 @@ parse_options(int argc, char *argv[]) {"timestamp", no_argument, NULL, OPT_TIMESTAMP}, {"sort", optional_argument, NULL, OPT_SORT}, {"rsort", optional_argument, NULL, OPT_RSORT}, + {"unixctl", required_argument, NULL, OPT_UNIXCTL}, {"help", no_argument, NULL, 'h'}, + {"option", no_argument, NULL, 'o'}, + {"bundle", no_argument, NULL, OPT_BUNDLE}, DAEMON_LONG_OPTIONS, OFP_VERSION_LONG_OPTIONS, VLOG_LONG_OPTIONS, STREAM_SSL_LONG_OPTIONS, {NULL, 0, NULL, 0}, }; - char *short_options = long_options_to_short_options(long_options); + char *short_options = ovs_cmdl_long_options_to_short_options(long_options); uint32_t versions; enum ofputil_protocol version_protocols; + /* For now, ovs-ofctl only enables OpenFlow 1.0 by default. This is + * because ovs-ofctl implements command such as "add-flow" as raw OpenFlow + * requests, but those requests have subtly different semantics in + * different OpenFlow versions. For example: + * + * - In OpenFlow 1.0, a "mod-flow" operation that does not find any + * existing flow to modify adds a new flow. + * + * - In OpenFlow 1.1, a "mod-flow" operation that does not find any + * existing flow to modify adds a new flow, but only if the mod-flow + * did not match on the flow cookie. + * + * - In OpenFlow 1.2 and a later, a "mod-flow" operation never adds a + * new flow. + */ + set_allowed_ofp_versions("OpenFlow10"); + for (;;) { unsigned long int timeout; int c; @@ -214,6 +253,14 @@ parse_options(int argc, char *argv[]) case 'h': usage(); + case 'o': + ovs_cmdl_print_options(long_options); + exit(EXIT_SUCCESS); + + case OPT_BUNDLE: + bundle = true; + break; + case OPT_STRICT: strict = true; break; @@ -234,6 +281,10 @@ parse_options(int argc, char *argv[]) add_sort_criterion(SORT_DESC, optarg); break; + case OPT_UNIXCTL: + unixctl_path = optarg; + break; + DAEMON_OPTION_HANDLERS OFP_VERSION_OPTION_HANDLERS VLOG_OPTION_HANDLERS @@ -254,6 +305,12 @@ parse_options(int argc, char *argv[]) free(short_options); + /* Implicit OpenFlow 1.4 with the '--bundle' option. */ + if (bundle) { + /* Add implicit allowance for OpenFlow 1.4. */ + add_allowed_ofp_versions(ofputil_protocols_to_version_bitmap( + OFPUTIL_P_OF14_OXM)); + } versions = get_allowed_ofp_versions(); version_protocols = ofputil_protocols_from_version_bitmap(versions); if (!(allowed_protocols & version_protocols)) { @@ -280,11 +337,13 @@ usage(void) " show SWITCH show OpenFlow information\n" " dump-desc SWITCH print switch description\n" " dump-tables SWITCH print table stats\n" + " dump-table-features SWITCH print table features\n" " mod-port SWITCH IFACE ACT modify port behavior\n" + " mod-table SWITCH MOD modify flow table behavior\n" " get-frags SWITCH print fragment handling behavior\n" " set-frags SWITCH FRAG_MODE set fragment handling behavior\n" " dump-ports SWITCH [PORT] print port statistics\n" - " dump-ports-desc SWITCH print port descriptions\n" + " dump-ports-desc SWITCH [PORT] print port descriptions\n" " dump-flows SWITCH print all flow entries\n" " dump-flows SWITCH FLOW print matching FLOWs\n" " dump-aggregate SWITCH print aggregate flow statistics\n" @@ -301,13 +360,35 @@ usage(void) " monitor SWITCH [MISSLEN] [invalid_ttl] [watch:[...]]\n" " print packets received from SWITCH\n" " snoop SWITCH snoop on SWITCH and its controller\n" + " add-group SWITCH GROUP add group described by GROUP\n" + " add-groups SWITCH FILE add group from FILE\n" + " mod-group SWITCH GROUP modify specific group\n" + " del-groups SWITCH [GROUP] delete matching GROUPs\n" + " insert-buckets SWITCH [GROUP] add buckets to GROUP\n" + " remove-buckets SWITCH [GROUP] remove buckets from GROUP\n" + " dump-group-features SWITCH print group features\n" + " dump-groups SWITCH [GROUP] print group description\n" + " dump-group-stats SWITCH [GROUP] print group statistics\n" + " queue-get-config SWITCH PORT print queue information for port\n" + " add-meter SWITCH METER add meter described by METER\n" + " mod-meter SWITCH METER modify specific METER\n" + " del-meter SWITCH METER delete METER\n" + " del-meters SWITCH delete all meters\n" + " dump-meter SWITCH METER print METER configuration\n" + " dump-meters SWITCH print all meter configuration\n" + " meter-stats SWITCH [METER] print meter statistics\n" + " meter-features SWITCH print meter features\n" + " add-geneve-map SWITCH MAP add Geneve option MAPpings\n" + " del-geneve-map SWITCH [MAP] delete Geneve option MAPpings\n" + " dump-geneve-map SWITCH print Geneve option mappings\n" "\nFor OpenFlow switches and controllers:\n" " probe TARGET probe whether TARGET is up\n" " ping TARGET [N] latency of N-byte echos\n" " benchmark TARGET N COUNT bandwidth of COUNT N-byte echos\n" "SWITCH or TARGET is an active OpenFlow connection method.\n" "\nOther commands:\n" - " ofp-parse FILE print messages read from FILE\n", + " ofp-parse FILE print messages read from FILE\n" + " ofp-parse-pcap PCAP print OpenFlow read from PCAP\n", program_name, program_name); vconn_usage(true, false, false); daemon_usage(); @@ -323,6 +404,7 @@ usage(void) " -t, --timeout=SECS give up after SECS seconds\n" " --sort[=field] sort in ascending order\n" " --rsort[=field] sort in descending order\n" + " --unixctl=SOCKET set control socket name\n" " -h, --help display this help message\n" " -V, --version display version information\n"); exit(EXIT_SUCCESS); @@ -338,7 +420,7 @@ ofctl_exit(struct unixctl_conn *conn, int argc OVS_UNUSED, } static void run(int retval, const char *message, ...) - PRINTF_FORMAT(2, 3); + OVS_PRINTF_FORMAT(2, 3); static void run(int retval, const char *message, ...) @@ -435,7 +517,6 @@ open_vconn(const char *name, struct vconn **vconnp) static void send_openflow_buffer(struct vconn *vconn, struct ofpbuf *buffer) { - ofpmsg_update_length(buffer); run(vconn_send_block(vconn, buffer), "failed to send packet to switch"); } @@ -444,7 +525,6 @@ dump_transaction(struct vconn *vconn, struct ofpbuf *request) { struct ofpbuf *reply; - ofpmsg_update_length(request); run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_get_name(vconn)); ofp_print(stdout, reply->data, reply->size, verbosity + 1); @@ -524,13 +604,9 @@ dump_trivial_stats_transaction(const char *vconn_name, enum ofpraw raw) * * Destroys all of the 'requests'. */ static void -transact_multiple_noreply(struct vconn *vconn, struct list *requests) +transact_multiple_noreply(struct vconn *vconn, struct ovs_list *requests) { - struct ofpbuf *request, *reply; - - LIST_FOR_EACH (request, list_node, requests) { - ofpmsg_update_length(request); - } + struct ofpbuf *reply; run(vconn_transact_multiple_noreply(vconn, requests, &reply), "talking to %s", vconn_get_name(vconn)); @@ -541,6 +617,20 @@ transact_multiple_noreply(struct vconn *vconn, struct list *requests) ofpbuf_delete(reply); } +static void +bundle_error_reporter(const struct ofp_header *oh) +{ + ofp_print(stderr, oh, ntohs(oh->length), verbosity + 1); + fflush(stderr); +} + +static void +bundle_transact(struct vconn *vconn, struct ovs_list *requests, uint16_t flags) +{ + run(vconn_bundle_transact(vconn, requests, flags, bundle_error_reporter), + "talking to %s", vconn_get_name(vconn)); +} + /* Sends 'request', which should be a request that only has a reply if an error * occurs, and waits for it to succeed or fail. If an error does occur, prints * it and exits with an error. @@ -549,7 +639,7 @@ transact_multiple_noreply(struct vconn *vconn, struct list *requests) static void transact_noreply(struct vconn *vconn, struct ofpbuf *request) { - struct list requests; + struct ovs_list requests; list_init(&requests); list_push_back(&requests, &request->list_node); @@ -591,84 +681,106 @@ set_switch_config(struct vconn *vconn, const struct ofp_switch_config *config) } static void -ofctl_show(int argc OVS_UNUSED, char *argv[]) +ofctl_show(struct ovs_cmdl_context *ctx) { - const char *vconn_name = argv[1]; + const char *vconn_name = ctx->argv[1]; + enum ofp_version version; struct vconn *vconn; struct ofpbuf *request; struct ofpbuf *reply; - bool trunc; + bool has_ports; open_vconn(vconn_name, &vconn); - request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, - vconn_get_version(vconn), 0); + version = vconn_get_version(vconn); + request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, version, 0); run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name); - trunc = ofputil_switch_features_ports_trunc(reply); + has_ports = ofputil_switch_features_has_ports(reply); ofp_print(stdout, reply->data, reply->size, verbosity + 1); - ofpbuf_delete(reply); - if (trunc) { - /* The Features Reply may not contain all the ports, so send a - * Port Description stats request, which doesn't have size - * constraints. */ - dump_trivial_stats_transaction(vconn_name, - OFPRAW_OFPST_PORT_DESC_REQUEST); + if (!has_ports) { + request = ofputil_encode_port_desc_stats_request(version, OFPP_ANY); + dump_stats_transaction(vconn, request); } dump_trivial_transaction(vconn_name, OFPRAW_OFPT_GET_CONFIG_REQUEST); vconn_close(vconn); } static void -ofctl_dump_desc(int argc OVS_UNUSED, char *argv[]) +ofctl_dump_desc(struct ovs_cmdl_context *ctx) +{ + dump_trivial_stats_transaction(ctx->argv[1], OFPRAW_OFPST_DESC_REQUEST); +} + +static void +ofctl_dump_tables(struct ovs_cmdl_context *ctx) { - dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_DESC_REQUEST); + dump_trivial_stats_transaction(ctx->argv[1], OFPRAW_OFPST_TABLE_REQUEST); } static void -ofctl_dump_tables(int argc OVS_UNUSED, char *argv[]) +ofctl_dump_table_features(struct ovs_cmdl_context *ctx) { - dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_TABLE_REQUEST); + struct ofpbuf *request; + struct vconn *vconn; + + open_vconn(ctx->argv[1], &vconn); + request = ofputil_encode_table_features_request(vconn_get_version(vconn)); + if (request) { + dump_stats_transaction(vconn, request); + } + + vconn_close(vconn); } +static bool fetch_port_by_stats(struct vconn *, + const char *port_name, ofp_port_t port_no, + struct ofputil_phy_port *); + +/* Uses OFPT_FEATURES_REQUEST to attempt to fetch information about the port + * named 'port_name' or numbered 'port_no' into '*pp'. Returns true if + * successful, false on failure. + * + * This is only appropriate for OpenFlow 1.0, 1.1, and 1.2, which include a + * list of ports in OFPT_FEATURES_REPLY. */ static bool -fetch_port_by_features(const char *vconn_name, +fetch_port_by_features(struct vconn *vconn, const char *port_name, ofp_port_t port_no, - struct ofputil_phy_port *pp, bool *trunc) + struct ofputil_phy_port *pp) { struct ofputil_switch_features features; const struct ofp_header *oh; struct ofpbuf *request, *reply; - struct vconn *vconn; enum ofperr error; enum ofptype type; struct ofpbuf b; bool found = false; /* Fetch the switch's ofp_switch_features. */ - open_vconn(vconn_name, &vconn); request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, vconn_get_version(vconn), 0); - run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name); - vconn_close(vconn); + run(vconn_transact(vconn, request, &reply), + "talking to %s", vconn_get_name(vconn)); oh = reply->data; if (ofptype_decode(&type, reply->data) || type != OFPTYPE_FEATURES_REPLY) { - ovs_fatal(0, "%s: received bad features reply", vconn_name); + ovs_fatal(0, "%s: received bad features reply", vconn_get_name(vconn)); } - - *trunc = false; - if (ofputil_switch_features_ports_trunc(reply)) { - *trunc = true; - goto exit; + if (!ofputil_switch_features_has_ports(reply)) { + /* The switch features reply does not contain a complete list of ports. + * Probably, there are more ports than will fit into a single 64 kB + * OpenFlow message. Use OFPST_PORT_DESC to get a complete list of + * ports. */ + ofpbuf_delete(reply); + return fetch_port_by_stats(vconn, port_name, port_no, pp); } error = ofputil_decode_switch_features(oh, &features, &b); if (error) { ovs_fatal(0, "%s: failed to decode features reply (%s)", - vconn_name, ofperr_to_string(error)); + vconn_get_name(vconn), ofperr_to_string(error)); } while (!ofputil_pull_phy_port(oh->version, &b, pp)) { @@ -676,30 +788,35 @@ fetch_port_by_features(const char *vconn_name, ? port_no == pp->port_no : !strcmp(pp->name, port_name)) { found = true; - goto exit; + break; } } - -exit: ofpbuf_delete(reply); return found; } +/* Uses a OFPST_PORT_DESC request to attempt to fetch information about the + * port named 'port_name' or numbered 'port_no' into '*pp'. Returns true if + * successful, false on failure. + * + * This is most appropriate for OpenFlow 1.3 and later. Open vSwitch 1.7 and + * later also implements OFPST_PORT_DESC, as an extension, for OpenFlow 1.0, + * 1.1, and 1.2, so this can be used as a fallback in those versions when there + * are too many ports than fit in an OFPT_FEATURES_REPLY. */ static bool -fetch_port_by_stats(const char *vconn_name, +fetch_port_by_stats(struct vconn *vconn, const char *port_name, ofp_port_t port_no, struct ofputil_phy_port *pp) { struct ofpbuf *request; - struct vconn *vconn; ovs_be32 send_xid; bool done = false; bool found = false; - request = ofpraw_alloc(OFPRAW_OFPST_PORT_DESC_REQUEST, OFP10_VERSION, 0); + request = ofputil_encode_port_desc_stats_request(vconn_get_version(vconn), + port_no); send_xid = ((struct ofp_header *) request->data)->xid; - open_vconn(vconn_name, &vconn); send_openflow_buffer(vconn, request); while (!done) { ovs_be32 recv_xid; @@ -743,7 +860,6 @@ fetch_port_by_stats(const char *vconn_name, } ofpbuf_delete(reply); } - vconn_close(vconn); return found; } @@ -766,23 +882,23 @@ static void fetch_ofputil_phy_port(const char *vconn_name, const char *port_name, struct ofputil_phy_port *pp) { + struct vconn *vconn; ofp_port_t port_no; bool found; - bool trunc; /* Try to interpret the argument as a port number. */ if (!str_to_ofp(port_name, &port_no)) { port_no = OFPP_NONE; } - /* Try to find the port based on the Features Reply. If it looks - * like the results may be truncated, then use the Port Description - * stats message introduced in OVS 1.7. */ - found = fetch_port_by_features(vconn_name, port_name, port_no, pp, - &trunc); - if (trunc) { - found = fetch_port_by_stats(vconn_name, port_name, port_no, pp); - } + /* OpenFlow 1.0, 1.1, and 1.2 put the list of ports in the + * OFPT_FEATURES_REPLY message. OpenFlow 1.3 and later versions put it + * into the OFPST_PORT_DESC reply. Try it the correct way. */ + open_vconn(vconn_name, &vconn); + found = (vconn_get_version(vconn) < OFP13_VERSION + ? fetch_port_by_features(vconn, port_name, port_no, pp) + : fetch_port_by_stats(vconn, port_name, port_no, pp)); + vconn_close(vconn); if (!found) { ovs_fatal(0, "%s: couldn't find port `%s'", vconn_name, port_name); @@ -871,13 +987,12 @@ prepare_dump_flows(int argc, char *argv[], bool aggregate, char *error; error = parse_ofp_flow_stats_request_str(&fsr, aggregate, - argc > 2 ? argv[2] : ""); + argc > 2 ? argv[2] : "", + &usable_protocols); if (error) { ovs_fatal(0, "%s", error); } - usable_protocols = ofputil_flow_stats_request_usable_protocols(&fsr); - protocol = open_vconn(argv[1], &vconn); protocol = set_protocol_for_flow_dump(vconn, protocol, usable_protocols); *requestp = ofputil_encode_flow_stats_request(&fsr, protocol); @@ -909,8 +1024,8 @@ compare_flows(const void *afs_, const void *bfs_) int ret; if (!f) { - unsigned int a_pri = afs->priority; - unsigned int b_pri = bfs->priority; + int a_pri = afs->priority; + int b_pri = bfs->priority; ret = a_pri < b_pri ? -1 : a_pri > b_pri; } else { bool ina, inb; @@ -940,10 +1055,11 @@ compare_flows(const void *afs_, const void *bfs_) } static void -ofctl_dump_flows(int argc, char *argv[]) +ofctl_dump_flows(struct ovs_cmdl_context *ctx) { if (!n_criteria) { - return ofctl_dump_flows__(argc, argv, false); + ofctl_dump_flows__(ctx->argc, ctx->argv, false); + return; } else { struct ofputil_flow_stats *fses; size_t n_fses, allocated_fses; @@ -955,7 +1071,7 @@ ofctl_dump_flows(int argc, char *argv[]) struct ds s; size_t i; - vconn = prepare_dump_flows(argc, argv, false, &request); + vconn = prepare_dump_flows(ctx->argc, ctx->argv, false, &request); send_xid = ((struct ofp_header *) request->data)->xid; send_openflow_buffer(vconn, request); @@ -991,7 +1107,7 @@ ofctl_dump_flows(int argc, char *argv[]) ds_destroy(&s); for (i = 0; i < n_fses; i++) { - free(fses[i].ofpacts); + free(CONST_CAST(struct ofpact *, fses[i].ofpacts)); } free(fses); @@ -1000,27 +1116,27 @@ ofctl_dump_flows(int argc, char *argv[]) } static void -ofctl_dump_aggregate(int argc, char *argv[]) +ofctl_dump_aggregate(struct ovs_cmdl_context *ctx) { - return ofctl_dump_flows__(argc, argv, true); + ofctl_dump_flows__(ctx->argc, ctx->argv, true); } static void -ofctl_queue_stats(int argc, char *argv[]) +ofctl_queue_stats(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; struct ofputil_queue_stats_request oqs; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); - if (argc > 2 && argv[2][0] && strcasecmp(argv[2], "all")) { - oqs.port_no = str_to_port_no(argv[1], argv[2]); + if (ctx->argc > 2 && ctx->argv[2][0] && strcasecmp(ctx->argv[2], "all")) { + oqs.port_no = str_to_port_no(ctx->argv[1], ctx->argv[2]); } else { oqs.port_no = OFPP_ANY; } - if (argc > 3 && argv[3][0] && strcasecmp(argv[3], "all")) { - oqs.queue_id = atoi(argv[3]); + if (ctx->argc > 3 && ctx->argv[3][0] && strcasecmp(ctx->argv[3], "all")) { + oqs.queue_id = atoi(ctx->argv[3]); } else { oqs.queue_id = OFPQ_ALL; } @@ -1030,18 +1146,34 @@ ofctl_queue_stats(int argc, char *argv[]) vconn_close(vconn); } +static void +ofctl_queue_get_config(struct ovs_cmdl_context *ctx) +{ + const char *vconn_name = ctx->argv[1]; + const char *port_name = ctx->argv[2]; + enum ofputil_protocol protocol; + enum ofp_version version; + struct ofpbuf *request; + struct vconn *vconn; + ofp_port_t port; + + port = str_to_port_no(vconn_name, port_name); + + protocol = open_vconn(vconn_name, &vconn); + version = ofputil_protocol_to_ofp_version(protocol); + request = ofputil_encode_queue_get_config_request(version, port); + dump_transaction(vconn, request); + vconn_close(vconn); +} + static enum ofputil_protocol -open_vconn_for_flow_mod(const char *remote, - const struct ofputil_flow_mod *fms, size_t n_fms, - struct vconn **vconnp) +open_vconn_for_flow_mod(const char *remote, struct vconn **vconnp, + enum ofputil_protocol usable_protocols) { - enum ofputil_protocol usable_protocols; enum ofputil_protocol cur_protocol; char *usable_s; int i; - /* Figure out what flow formats will work. */ - usable_protocols = ofputil_flow_mod_usable_protocols(fms, n_fms); if (!(usable_protocols & allowed_protocols)) { char *allowed_s = ofputil_protocols_to_string(allowed_protocols); usable_s = ofputil_protocols_to_string(usable_protocols); @@ -1071,37 +1203,77 @@ open_vconn_for_flow_mod(const char *remote, "formats (%s)", usable_s); } +static void +bundle_flow_mod__(const char *remote, struct ofputil_flow_mod *fms, + size_t n_fms, enum ofputil_protocol usable_protocols) +{ + enum ofputil_protocol protocol; + struct vconn *vconn; + struct ovs_list requests; + size_t i; + + list_init(&requests); + + /* Bundles need OpenFlow 1.4+. */ + usable_protocols &= OFPUTIL_P_OF14_UP; + protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols); + + for (i = 0; i < n_fms; i++) { + struct ofputil_flow_mod *fm = &fms[i]; + struct ofpbuf *request = ofputil_encode_flow_mod(fm, protocol); + + list_push_back(&requests, &request->list_node); + free(CONST_CAST(struct ofpact *, fm->ofpacts)); + } + + bundle_transact(vconn, &requests, OFPBF_ORDERED | OFPBF_ATOMIC); + vconn_close(vconn); +} + static void ofctl_flow_mod__(const char *remote, struct ofputil_flow_mod *fms, - size_t n_fms) + size_t n_fms, enum ofputil_protocol usable_protocols) { enum ofputil_protocol protocol; struct vconn *vconn; size_t i; - protocol = open_vconn_for_flow_mod(remote, fms, n_fms, &vconn); + if (bundle) { + bundle_flow_mod__(remote, fms, n_fms, usable_protocols); + return; + } + + protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols); for (i = 0; i < n_fms; i++) { struct ofputil_flow_mod *fm = &fms[i]; transact_noreply(vconn, ofputil_encode_flow_mod(fm, protocol)); - free(fm->ofpacts); + free(CONST_CAST(struct ofpact *, fm->ofpacts)); } vconn_close(vconn); } static void -ofctl_flow_mod_file(int argc OVS_UNUSED, char *argv[], uint16_t command) +ofctl_flow_mod_file(int argc OVS_UNUSED, char *argv[], int command) { + enum ofputil_protocol usable_protocols; struct ofputil_flow_mod *fms = NULL; size_t n_fms = 0; char *error; - error = parse_ofp_flow_mod_file(argv[2], command, &fms, &n_fms); + if (command == OFPFC_ADD) { + /* Allow the file to specify a mix of commands. If none specified at + * the beginning of any given line, then the default is OFPFC_ADD, so + * this is backwards compatible. */ + command = -2; + } + error = parse_ofp_flow_mod_file(argv[2], command, &fms, &n_fms, + &usable_protocols); if (error) { ovs_fatal(0, "%s", error); } - ofctl_flow_mod__(argv[1], fms, n_fms); + ofctl_flow_mod__(argv[1], fms, n_fms, usable_protocols); free(fms); } @@ -1113,37 +1285,39 @@ ofctl_flow_mod(int argc, char *argv[], uint16_t command) } else { struct ofputil_flow_mod fm; char *error; + enum ofputil_protocol usable_protocols; - error = parse_ofp_flow_mod_str(&fm, argc > 2 ? argv[2] : "", command); + error = parse_ofp_flow_mod_str(&fm, argc > 2 ? argv[2] : "", command, + &usable_protocols); if (error) { ovs_fatal(0, "%s", error); } - ofctl_flow_mod__(argv[1], &fm, 1); + ofctl_flow_mod__(argv[1], &fm, 1, usable_protocols); } } static void -ofctl_add_flow(int argc, char *argv[]) +ofctl_add_flow(struct ovs_cmdl_context *ctx) { - ofctl_flow_mod(argc, argv, OFPFC_ADD); + ofctl_flow_mod(ctx->argc, ctx->argv, OFPFC_ADD); } static void -ofctl_add_flows(int argc, char *argv[]) +ofctl_add_flows(struct ovs_cmdl_context *ctx) { - ofctl_flow_mod_file(argc, argv, OFPFC_ADD); + ofctl_flow_mod_file(ctx->argc, ctx->argv, OFPFC_ADD); } static void -ofctl_mod_flows(int argc, char *argv[]) +ofctl_mod_flows(struct ovs_cmdl_context *ctx) { - ofctl_flow_mod(argc, argv, strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY); + ofctl_flow_mod(ctx->argc, ctx->argv, strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY); } static void -ofctl_del_flows(int argc, char *argv[]) +ofctl_del_flows(struct ovs_cmdl_context *ctx) { - ofctl_flow_mod(argc, argv, strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE); + ofctl_flow_mod(ctx->argc, ctx->argv, strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE); } static void @@ -1354,7 +1528,7 @@ monitor_vconn(struct vconn *vconn, bool reply_to_echo_requests) daemon_save_fd(STDERR_FILENO); daemonize_start(); - error = unixctl_server_create(NULL, &server); + error = unixctl_server_create(unixctl_path, &server); if (error) { ovs_fatal(error, "failed to create unixctl server"); } @@ -1388,13 +1562,15 @@ monitor_vconn(struct vconn *vconn, bool reply_to_echo_requests) run(retval, "vconn_recv"); if (timestamp) { - char *s = xastrftime("%Y-%m-%d %H:%M:%S: ", time_wall(), true); + char *s = xastrftime_msec("%Y-%m-%d %H:%M:%S.###: ", + time_wall_msec(), true); fputs(s, stderr); free(s); } ofptype_decode(&type, b->data); ofp_print(stderr, b->data, b->size, verbosity + 2); + fflush(stderr); switch ((int) type) { case OFPTYPE_BARRIER_REPLY: @@ -1436,14 +1612,15 @@ monitor_vconn(struct vconn *vconn, bool reply_to_echo_requests) } static void -ofctl_monitor(int argc, char *argv[]) +ofctl_monitor(struct ovs_cmdl_context *ctx) { struct vconn *vconn; int i; + enum ofputil_protocol usable_protocols; - open_vconn(argv[1], &vconn); - for (i = 2; i < argc; i++) { - const char *arg = argv[i]; + open_vconn(ctx->argv[1], &vconn); + for (i = 2; i < ctx->argc; i++) { + const char *arg = ctx->argv[i]; if (isdigit((unsigned char) *arg)) { struct ofp_switch_config config; @@ -1458,7 +1635,8 @@ ofctl_monitor(int argc, char *argv[]) struct ofpbuf *msg; char *error; - error = parse_flow_monitor_request(&fmr, arg + 6); + error = parse_flow_monitor_request(&fmr, arg + 6, + &usable_protocols); if (error) { ovs_fatal(0, "%s", error); } @@ -1466,6 +1644,7 @@ ofctl_monitor(int argc, char *argv[]) msg = ofpbuf_new(0); ofputil_append_flow_monitor_request(&fmr, msg); dump_stats_transaction(vconn, msg); + fflush(stdout); } else { ovs_fatal(0, "%s: unsupported \"monitor\" argument", arg); } @@ -1497,9 +1676,11 @@ ofctl_monitor(int argc, char *argv[]) case OFP11_VERSION: case OFP12_VERSION: case OFP13_VERSION: + case OFP14_VERSION: + case OFP15_VERSION: break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -1507,44 +1688,53 @@ ofctl_monitor(int argc, char *argv[]) } static void -ofctl_snoop(int argc OVS_UNUSED, char *argv[]) +ofctl_snoop(struct ovs_cmdl_context *ctx) { struct vconn *vconn; - open_vconn__(argv[1], SNOOP, &vconn); + open_vconn__(ctx->argv[1], SNOOP, &vconn); monitor_vconn(vconn, false); } static void -ofctl_dump_ports(int argc, char *argv[]) +ofctl_dump_ports(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; ofp_port_t port; - open_vconn(argv[1], &vconn); - port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_ANY; + open_vconn(ctx->argv[1], &vconn); + port = ctx->argc > 2 ? str_to_port_no(ctx->argv[1], ctx->argv[2]) : OFPP_ANY; request = ofputil_encode_dump_ports_request(vconn_get_version(vconn), port); dump_stats_transaction(vconn, request); vconn_close(vconn); } static void -ofctl_dump_ports_desc(int argc OVS_UNUSED, char *argv[]) +ofctl_dump_ports_desc(struct ovs_cmdl_context *ctx) { - dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_PORT_DESC_REQUEST); + struct ofpbuf *request; + struct vconn *vconn; + ofp_port_t port; + + open_vconn(ctx->argv[1], &vconn); + port = ctx->argc > 2 ? str_to_port_no(ctx->argv[1], ctx->argv[2]) : OFPP_ANY; + request = ofputil_encode_port_desc_stats_request(vconn_get_version(vconn), + port); + dump_stats_transaction(vconn, request); + vconn_close(vconn); } static void -ofctl_probe(int argc OVS_UNUSED, char *argv[]) +ofctl_probe(struct ovs_cmdl_context *ctx) { struct ofpbuf *request; struct vconn *vconn; struct ofpbuf *reply; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); request = make_echo_request(vconn_get_version(vconn)); - run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]); + run(vconn_transact(vconn, request, &reply), "talking to %s", ctx->argv[1]); if (reply->size != sizeof(struct ofp_header)) { ovs_fatal(0, "reply does not match request"); } @@ -1553,7 +1743,7 @@ ofctl_probe(int argc OVS_UNUSED, char *argv[]) } static void -ofctl_packet_out(int argc, char *argv[]) +ofctl_packet_out(struct ovs_cmdl_context *ctx) { enum ofputil_protocol protocol; struct ofputil_packet_out po; @@ -1561,40 +1751,42 @@ ofctl_packet_out(int argc, char *argv[]) struct vconn *vconn; char *error; int i; + enum ofputil_protocol usable_protocols; /* XXX: Use in proto selection */ ofpbuf_init(&ofpacts, 64); - error = parse_ofpacts(argv[3], &ofpacts); + error = ofpacts_parse_actions(ctx->argv[3], &ofpacts, &usable_protocols); if (error) { ovs_fatal(0, "%s", error); } po.buffer_id = UINT32_MAX; - po.in_port = str_to_port_no(argv[1], argv[2]); + po.in_port = str_to_port_no(ctx->argv[1], ctx->argv[2]); po.ofpacts = ofpacts.data; po.ofpacts_len = ofpacts.size; - protocol = open_vconn(argv[1], &vconn); - for (i = 4; i < argc; i++) { - struct ofpbuf *packet, *opo; + protocol = open_vconn(ctx->argv[1], &vconn); + for (i = 4; i < ctx->argc; i++) { + struct dp_packet *packet; + struct ofpbuf *opo; const char *error_msg; - error_msg = eth_from_hex(argv[i], &packet); + error_msg = eth_from_hex(ctx->argv[i], &packet); if (error_msg) { ovs_fatal(0, "%s", error_msg); } - po.packet = packet->data; - po.packet_len = packet->size; + po.packet = dp_packet_data(packet); + po.packet_len = dp_packet_size(packet); opo = ofputil_encode_packet_out(&po, protocol); transact_noreply(vconn, opo); - ofpbuf_delete(packet); + dp_packet_delete(packet); } vconn_close(vconn); ofpbuf_uninit(&ofpacts); } static void -ofctl_mod_port(int argc OVS_UNUSED, char *argv[]) +ofctl_mod_port(struct ovs_cmdl_context *ctx) { struct ofp_config_flag { const char *name; /* The flag's name. */ @@ -1620,7 +1812,7 @@ ofctl_mod_port(int argc OVS_UNUSED, char *argv[]) const char *command; bool not; - fetch_ofputil_phy_port(argv[1], argv[2], &pp); + fetch_ofputil_phy_port(ctx->argv[1], ctx->argv[2], &pp); pm.port_no = pp.port_no; memcpy(pm.hw_addr, pp.hw_addr, ETH_ADDR_LEN); @@ -1628,14 +1820,14 @@ ofctl_mod_port(int argc OVS_UNUSED, char *argv[]) pm.mask = 0; pm.advertise = 0; - if (!strncasecmp(argv[3], "no-", 3)) { - command = argv[3] + 3; + if (!strncasecmp(ctx->argv[3], "no-", 3)) { + command = ctx->argv[3] + 3; not = true; - } else if (!strncasecmp(argv[3], "no", 2)) { - command = argv[3] + 2; + } else if (!strncasecmp(ctx->argv[3], "no", 2)) { + command = ctx->argv[3] + 2; not = true; } else { - command = argv[3]; + command = ctx->argv[3]; not = false; } for (flag = flags; flag < &flags[ARRAY_SIZE(flags)]; flag++) { @@ -1645,39 +1837,75 @@ ofctl_mod_port(int argc OVS_UNUSED, char *argv[]) goto found; } } - ovs_fatal(0, "unknown mod-port command '%s'", argv[3]); + ovs_fatal(0, "unknown mod-port command '%s'", ctx->argv[3]); found: - protocol = open_vconn(argv[1], &vconn); + protocol = open_vconn(ctx->argv[1], &vconn); transact_noreply(vconn, ofputil_encode_port_mod(&pm, protocol)); vconn_close(vconn); } static void -ofctl_get_frags(int argc OVS_UNUSED, char *argv[]) +ofctl_mod_table(struct ovs_cmdl_context *ctx) +{ + enum ofputil_protocol protocol, usable_protocols; + struct ofputil_table_mod tm; + struct vconn *vconn; + char *error; + int i; + + error = parse_ofp_table_mod(&tm, ctx->argv[2], ctx->argv[3], &usable_protocols); + if (error) { + ovs_fatal(0, "%s", error); + } + + protocol = open_vconn(ctx->argv[1], &vconn); + if (!(protocol & usable_protocols)) { + for (i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) { + enum ofputil_protocol f = 1 << i; + if (f != protocol + && f & usable_protocols + && try_set_protocol(vconn, f, &protocol)) { + protocol = f; + break; + } + } + } + + if (!(protocol & usable_protocols)) { + char *usable_s = ofputil_protocols_to_string(usable_protocols); + ovs_fatal(0, "Switch does not support table mod message(%s)", usable_s); + } + + transact_noreply(vconn, ofputil_encode_table_mod(&tm, protocol)); + vconn_close(vconn); +} + +static void +ofctl_get_frags(struct ovs_cmdl_context *ctx) { struct ofp_switch_config config; struct vconn *vconn; - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); fetch_switch_config(vconn, &config); puts(ofputil_frag_handling_to_string(ntohs(config.flags))); vconn_close(vconn); } static void -ofctl_set_frags(int argc OVS_UNUSED, char *argv[]) +ofctl_set_frags(struct ovs_cmdl_context *ctx) { struct ofp_switch_config config; enum ofp_config_flags mode; struct vconn *vconn; ovs_be16 flags; - if (!ofputil_frag_handling_from_string(argv[2], &mode)) { - ovs_fatal(0, "%s: unknown fragment handling mode", argv[2]); + if (!ofputil_frag_handling_from_string(ctx->argv[2], &mode)) { + ovs_fatal(0, "%s: unknown fragment handling mode", ctx->argv[2]); } - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); fetch_switch_config(vconn, &config); flags = htons(mode) | (config.flags & htons(~OFPC_FRAG_MASK)); if (flags != config.flags) { @@ -1692,16 +1920,16 @@ ofctl_set_frags(int argc OVS_UNUSED, char *argv[]) if (flags != config.flags) { ovs_fatal(0, "%s: setting fragment handling mode failed (this " "switch probably doesn't support mode \"%s\")", - argv[1], ofputil_frag_handling_to_string(mode)); + ctx->argv[1], ofputil_frag_handling_to_string(mode)); } } vconn_close(vconn); } static void -ofctl_ofp_parse(int argc OVS_UNUSED, char *argv[]) +ofctl_ofp_parse(struct ovs_cmdl_context *ctx) { - const char *filename = argv[1]; + const char *filename = ctx->argv[1]; struct ofpbuf b; FILE *file; @@ -1728,7 +1956,7 @@ ofctl_ofp_parse(int argc OVS_UNUSED, char *argv[]) length = ntohs(oh->length); if (length < sizeof *oh) { - ovs_fatal(0, "%s: %zu-byte message is too short for OpenFlow", + ovs_fatal(0, "%s: %"PRIuSIZE"-byte message is too short for OpenFlow", filename, length); } @@ -1748,20 +1976,108 @@ ofctl_ofp_parse(int argc OVS_UNUSED, char *argv[]) } } +static bool +is_openflow_port(ovs_be16 port_, char *ports[]) +{ + uint16_t port = ntohs(port_); + if (ports[0]) { + int i; + + for (i = 0; ports[i]; i++) { + if (port == atoi(ports[i])) { + return true; + } + } + return false; + } else { + return port == OFP_PORT || port == OFP_OLD_PORT; + } +} + +static void +ofctl_ofp_parse_pcap(struct ovs_cmdl_context *ctx) +{ + struct tcp_reader *reader; + FILE *file; + int error; + bool first; + + file = ovs_pcap_open(ctx->argv[1], "rb"); + if (!file) { + ovs_fatal(errno, "%s: open failed", ctx->argv[1]); + } + + reader = tcp_reader_open(); + first = true; + for (;;) { + struct dp_packet *packet; + long long int when; + struct flow flow; + + error = ovs_pcap_read(file, &packet, &when); + if (error) { + break; + } + pkt_metadata_init(&packet->md, ODPP_NONE); + flow_extract(packet, &flow); + if (flow.dl_type == htons(ETH_TYPE_IP) + && flow.nw_proto == IPPROTO_TCP + && (is_openflow_port(flow.tp_src, ctx->argv + 2) || + is_openflow_port(flow.tp_dst, ctx->argv + 2))) { + struct dp_packet *payload = tcp_reader_run(reader, &flow, packet); + if (payload) { + while (dp_packet_size(payload) >= sizeof(struct ofp_header)) { + const struct ofp_header *oh; + void *data = dp_packet_data(payload); + int length; + + /* Align OpenFlow on 8-byte boundary for safe access. */ + dp_packet_shift(payload, -((intptr_t) data & 7)); + + oh = dp_packet_data(payload); + length = ntohs(oh->length); + if (dp_packet_size(payload) < length) { + break; + } + + if (!first) { + putchar('\n'); + } + first = false; + + if (timestamp) { + char *s = xastrftime_msec("%H:%M:%S.### ", when, true); + fputs(s, stdout); + free(s); + } + + printf(IP_FMT".%"PRIu16" > "IP_FMT".%"PRIu16":\n", + IP_ARGS(flow.nw_src), ntohs(flow.tp_src), + IP_ARGS(flow.nw_dst), ntohs(flow.tp_dst)); + ofp_print(stdout, dp_packet_data(payload), length, verbosity + 1); + dp_packet_pull(payload, length); + } + } + } + dp_packet_delete(packet); + } + tcp_reader_close(reader); +} + static void -ofctl_ping(int argc, char *argv[]) +ofctl_ping(struct ovs_cmdl_context *ctx) { size_t max_payload = 65535 - sizeof(struct ofp_header); unsigned int payload; struct vconn *vconn; int i; - payload = argc > 2 ? atoi(argv[2]) : 64; + payload = ctx->argc > 2 ? atoi(ctx->argv[2]) : 64; if (payload > max_payload) { - ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload); + ovs_fatal(0, "payload must be between 0 and %"PRIuSIZE" bytes", max_payload); } - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); for (i = 0; i < 10; i++) { struct timeval start, end; struct ofpbuf *request, *reply; @@ -1780,14 +2096,14 @@ ofctl_ping(int argc, char *argv[]) if (ofptype_pull(&type, reply) || type != OFPTYPE_ECHO_REPLY || reply->size != payload - || memcmp(request->l3, reply->l3, payload)) { + || memcmp(request->msg, reply->msg, payload)) { printf("Reply does not match request. Request:\n"); ofp_print(stdout, request, request->size, verbosity + 2); printf("Reply:\n"); ofp_print(stdout, reply, reply->size, verbosity + 2); } - printf("%zu bytes from %s: xid=%08"PRIx32" time=%.1f ms\n", - reply->size, argv[1], ntohl(rpy_hdr->xid), + printf("%"PRIu32" bytes from %s: xid=%08"PRIx32" time=%.1f ms\n", + reply->size, ctx->argv[1], ntohl(rpy_hdr->xid), (1000*(double)(end.tv_sec - start.tv_sec)) + (.001*(end.tv_usec - start.tv_usec))); ofpbuf_delete(request); @@ -1797,7 +2113,7 @@ ofctl_ping(int argc, char *argv[]) } static void -ofctl_benchmark(int argc OVS_UNUSED, char *argv[]) +ofctl_benchmark(struct ovs_cmdl_context *ctx) { size_t max_payload = 65535 - sizeof(struct ofp_header); struct timeval start, end; @@ -1807,18 +2123,18 @@ ofctl_benchmark(int argc OVS_UNUSED, char *argv[]) int count; int i; - payload_size = atoi(argv[2]); + payload_size = atoi(ctx->argv[2]); if (payload_size > max_payload) { - ovs_fatal(0, "payload must be between 0 and %zu bytes", max_payload); + ovs_fatal(0, "payload must be between 0 and %"PRIuSIZE" bytes", max_payload); } message_size = sizeof(struct ofp_header) + payload_size; - count = atoi(argv[3]); + count = atoi(ctx->argv[3]); printf("Sending %d packets * %u bytes (with header) = %u bytes total\n", count, message_size, count * message_size); - open_vconn(argv[1], &vconn); + open_vconn(ctx->argv[1], &vconn); xgettimeofday(&start); for (i = 0; i < count; i++) { struct ofpbuf *request, *reply; @@ -1840,10 +2156,237 @@ ofctl_benchmark(int argc OVS_UNUSED, char *argv[]) } static void -ofctl_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_group_mod__(const char *remote, struct ofputil_group_mod *gms, + size_t n_gms, enum ofputil_protocol usable_protocols) +{ + enum ofputil_protocol protocol; + struct ofputil_group_mod *gm; + enum ofp_version version; + struct ofpbuf *request; + + struct vconn *vconn; + size_t i; + + protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols); + version = ofputil_protocol_to_ofp_version(protocol); + + for (i = 0; i < n_gms; i++) { + gm = &gms[i]; + request = ofputil_encode_group_mod(version, gm); + if (request) { + transact_noreply(vconn, request); + } + } + + vconn_close(vconn); + +} + + +static void +ofctl_group_mod_file(int argc OVS_UNUSED, char *argv[], uint16_t command) +{ + struct ofputil_group_mod *gms = NULL; + enum ofputil_protocol usable_protocols; + size_t n_gms = 0; + char *error; + int i; + + error = parse_ofp_group_mod_file(argv[2], command, &gms, &n_gms, + &usable_protocols); + if (error) { + ovs_fatal(0, "%s", error); + } + ofctl_group_mod__(argv[1], gms, n_gms, usable_protocols); + for (i = 0; i < n_gms; i++) { + ofputil_bucket_list_destroy(&gms[i].buckets); + } + free(gms); +} + +static void +ofctl_group_mod(int argc, char *argv[], uint16_t command) +{ + if (argc > 2 && !strcmp(argv[2], "-")) { + ofctl_group_mod_file(argc, argv, command); + } else { + enum ofputil_protocol usable_protocols; + struct ofputil_group_mod gm; + char *error; + + error = parse_ofp_group_mod_str(&gm, command, argc > 2 ? argv[2] : "", + &usable_protocols); + if (error) { + ovs_fatal(0, "%s", error); + } + ofctl_group_mod__(argv[1], &gm, 1, usable_protocols); + ofputil_bucket_list_destroy(&gm.buckets); + } +} + +static void +ofctl_add_group(struct ovs_cmdl_context *ctx) +{ + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC11_ADD); +} + +static void +ofctl_add_groups(struct ovs_cmdl_context *ctx) +{ + ofctl_group_mod_file(ctx->argc, ctx->argv, OFPGC11_ADD); +} + +static void +ofctl_mod_group(struct ovs_cmdl_context *ctx) +{ + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC11_MODIFY); +} + +static void +ofctl_del_groups(struct ovs_cmdl_context *ctx) +{ + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC11_DELETE); +} + +static void +ofctl_insert_bucket(struct ovs_cmdl_context *ctx) +{ + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC15_INSERT_BUCKET); +} + +static void +ofctl_remove_bucket(struct ovs_cmdl_context *ctx) +{ + ofctl_group_mod(ctx->argc, ctx->argv, OFPGC15_REMOVE_BUCKET); +} + +static void +ofctl_dump_group_stats(struct ovs_cmdl_context *ctx) +{ + enum ofputil_protocol usable_protocols; + struct ofputil_group_mod gm; + struct ofpbuf *request; + struct vconn *vconn; + uint32_t group_id; + char *error; + + memset(&gm, 0, sizeof gm); + + error = parse_ofp_group_mod_str(&gm, OFPGC11_DELETE, + ctx->argc > 2 ? ctx->argv[2] : "", + &usable_protocols); + if (error) { + ovs_fatal(0, "%s", error); + } + + group_id = gm.group_id; + + open_vconn(ctx->argv[1], &vconn); + request = ofputil_encode_group_stats_request(vconn_get_version(vconn), + group_id); + if (request) { + dump_stats_transaction(vconn, request); + } + + vconn_close(vconn); +} + +static void +ofctl_dump_group_desc(struct ovs_cmdl_context *ctx) +{ + struct ofpbuf *request; + struct vconn *vconn; + uint32_t group_id; + + open_vconn(ctx->argv[1], &vconn); + + if (ctx->argc < 3 || !ofputil_group_from_string(ctx->argv[2], &group_id)) { + group_id = OFPG11_ALL; + } + + request = ofputil_encode_group_desc_request(vconn_get_version(vconn), + group_id); + if (request) { + dump_stats_transaction(vconn, request); + } + + vconn_close(vconn); +} + +static void +ofctl_dump_group_features(struct ovs_cmdl_context *ctx) +{ + struct ofpbuf *request; + struct vconn *vconn; + + open_vconn(ctx->argv[1], &vconn); + request = ofputil_encode_group_features_request(vconn_get_version(vconn)); + if (request) { + dump_stats_transaction(vconn, request); + } + + vconn_close(vconn); +} + +static void +ofctl_geneve_mod(struct ovs_cmdl_context *ctx, uint16_t command) +{ + enum ofputil_protocol usable_protocols; + enum ofputil_protocol protocol; + struct ofputil_geneve_table_mod gtm; + char *error; + enum ofp_version version; + struct ofpbuf *request; + struct vconn *vconn; + + error = parse_ofp_geneve_table_mod_str(>m, command, ctx->argc > 2 ? + ctx->argv[2] : "", + &usable_protocols); + if (error) { + ovs_fatal(0, "%s", error); + } + + protocol = open_vconn_for_flow_mod(ctx->argv[1], &vconn, usable_protocols); + version = ofputil_protocol_to_ofp_version(protocol); + + request = ofputil_encode_geneve_table_mod(version, >m); + if (request) { + transact_noreply(vconn, request); + } + + vconn_close(vconn); + ofputil_uninit_geneve_table(>m.mappings); +} + +static void +ofctl_add_geneve_map(struct ovs_cmdl_context *ctx) +{ + ofctl_geneve_mod(ctx, NXGTMC_ADD); +} + +static void +ofctl_del_geneve_map(struct ovs_cmdl_context *ctx) +{ + ofctl_geneve_mod(ctx, ctx->argc > 2 ? NXGTMC_DELETE : NXGTMC_CLEAR); +} + +static void +ofctl_dump_geneve_map(struct ovs_cmdl_context *ctx) +{ + dump_trivial_transaction(ctx->argv[1], OFPRAW_NXT_GENEVE_TABLE_REQUEST); +} + +static void +ofctl_help(struct ovs_cmdl_context *ctx OVS_UNUSED) { usage(); } + +static void +ofctl_list_commands(struct ovs_cmdl_context *ctx OVS_UNUSED) +{ + ovs_cmdl_print_commands(get_all_commands()); +} /* replace-flows and diff-flows commands. */ @@ -1858,6 +2401,7 @@ struct fte_version { ovs_be64 cookie; uint16_t idle_timeout; uint16_t hard_timeout; + uint16_t importance; uint16_t flags; struct ofpact *ofpacts; size_t ofpacts_len; @@ -1868,7 +2412,7 @@ static void fte_version_free(struct fte_version *version) { if (version) { - free(version->ofpacts); + free(CONST_CAST(struct ofpact *, version->ofpacts)); free(version); } } @@ -1883,6 +2427,7 @@ fte_version_equals(const struct fte_version *a, const struct fte_version *b) return (a->cookie == b->cookie && a->idle_timeout == b->idle_timeout && a->hard_timeout == b->hard_timeout + && a->importance == b->importance && ofpacts_equal(a->ofpacts, a->ofpacts_len, b->ofpacts, b->ofpacts_len)); } @@ -1909,8 +2454,11 @@ fte_version_format(const struct fte *fte, int index, struct ds *s) if (version->hard_timeout != OFP_FLOW_PERMANENT) { ds_put_format(s, " hard_timeout=%"PRIu16, version->hard_timeout); } + if (version->importance != 0) { + ds_put_format(s, " importance=%"PRIu16, version->importance); + } - ds_put_char(s, ' '); + ds_put_cstr(s, " actions="); ofpacts_format(version->ofpacts, version->ofpacts_len, s); ds_put_char(s, '\n'); @@ -1938,16 +2486,13 @@ fte_free(struct fte *fte) static void fte_free_all(struct classifier *cls) { - struct cls_cursor cursor; - struct fte *fte, *next; + struct fte *fte; - ovs_rwlock_wrlock(&cls->rwlock); - cls_cursor_init(&cursor, cls, NULL); - CLS_CURSOR_FOR_EACH_SAFE (fte, next, rule, &cursor) { + classifier_defer(cls); + CLS_FOR_EACH (fte, rule, cls) { classifier_remove(cls, &fte->rule); - fte_free(fte); + ovsrcu_postpone(fte_free, fte); } - ovs_rwlock_unlock(&cls->rwlock); classifier_destroy(cls); } @@ -1958,22 +2503,20 @@ fte_free_all(struct classifier *cls) * Takes ownership of 'version'. */ static void fte_insert(struct classifier *cls, const struct match *match, - unsigned int priority, struct fte_version *version, int index) + int priority, struct fte_version *version, int index) { struct fte *old, *fte; fte = xzalloc(sizeof *fte); - cls_rule_init(&fte->rule, match, priority); + cls_rule_init(&fte->rule, match, priority, CLS_MIN_VERSION); fte->versions[index] = version; - ovs_rwlock_wrlock(&cls->rwlock); - old = fte_from_cls_rule(classifier_replace(cls, &fte->rule)); - ovs_rwlock_unlock(&cls->rwlock); + old = fte_from_cls_rule(classifier_replace(cls, &fte->rule, NULL, 0)); if (old) { - fte_version_free(old->versions[index]); fte->versions[!index] = old->versions[!index]; - cls_rule_destroy(&old->rule); - free(old); + old->versions[!index] = NULL; + + ovsrcu_postpone(fte_free, old); } } @@ -1996,29 +2539,32 @@ read_flows_from_file(const char *filename, struct classifier *cls, int index) ds_init(&s); usable_protocols = OFPUTIL_P_ANY; line_number = 0; + classifier_defer(cls); while (!ds_get_preprocessed_line(&s, file, &line_number)) { struct fte_version *version; struct ofputil_flow_mod fm; char *error; + enum ofputil_protocol usable; - error = parse_ofp_str(&fm, OFPFC_ADD, ds_cstr(&s)); + error = parse_ofp_str(&fm, OFPFC_ADD, ds_cstr(&s), &usable); if (error) { ovs_fatal(0, "%s:%d: %s", filename, line_number, error); } + usable_protocols &= usable; version = xmalloc(sizeof *version); version->cookie = fm.new_cookie; version->idle_timeout = fm.idle_timeout; version->hard_timeout = fm.hard_timeout; + version->importance = fm.importance; version->flags = fm.flags & (OFPUTIL_FF_SEND_FLOW_REM | OFPUTIL_FF_EMERG); version->ofpacts = fm.ofpacts; version->ofpacts_len = fm.ofpacts_len; - usable_protocols &= ofputil_usable_protocols(&fm.match); - fte_insert(cls, &fm.match, fm.priority, version, index); } + classifier_publish(cls); ds_destroy(&s); if (file != stdin) { @@ -2065,7 +2611,7 @@ recv_flow_stats_reply(struct vconn *vconn, ovs_be32 send_xid, return true; case EOF: - more = ofpmp_more(reply->l2); + more = ofpmp_more(reply->header); ofpbuf_delete(reply); reply = NULL; if (!more) { @@ -2107,6 +2653,7 @@ read_flows_from_switch(struct vconn *vconn, reply = NULL; ofpbuf_init(&ofpacts, 0); + classifier_defer(cls); while (recv_flow_stats_reply(vconn, send_xid, &reply, &fs, &ofpacts)) { struct fte_version *version; @@ -2114,18 +2661,20 @@ read_flows_from_switch(struct vconn *vconn, version->cookie = fs.cookie; version->idle_timeout = fs.idle_timeout; version->hard_timeout = fs.hard_timeout; + version->importance = fs.importance; version->flags = 0; version->ofpacts_len = fs.ofpacts_len; version->ofpacts = xmemdup(fs.ofpacts, fs.ofpacts_len); fte_insert(cls, &fs.match, fs.priority, version, index); } + classifier_publish(cls); ofpbuf_uninit(&ofpacts); } static void fte_make_flow_mod(const struct fte *fte, int index, uint16_t command, - enum ofputil_protocol protocol, struct list *packets) + enum ofputil_protocol protocol, struct ovs_list *packets) { const struct fte_version *version = fte->versions[index]; struct ofputil_flow_mod fm; @@ -2141,6 +2690,7 @@ fte_make_flow_mod(const struct fte *fte, int index, uint16_t command, fm.command = command; fm.idle_timeout = version->idle_timeout; fm.hard_timeout = version->hard_timeout; + fm.importance = version->importance; fm.buffer_id = UINT32_MAX; fm.out_port = OFPP_ANY; fm.flags = version->flags; @@ -2152,26 +2702,26 @@ fte_make_flow_mod(const struct fte *fte, int index, uint16_t command, fm.ofpacts = NULL; fm.ofpacts_len = 0; } + fm.delete_reason = OFPRR_DELETE; ofm = ofputil_encode_flow_mod(&fm, protocol); list_push_back(packets, &ofm->list_node); } static void -ofctl_replace_flows(int argc OVS_UNUSED, char *argv[]) +ofctl_replace_flows(struct ovs_cmdl_context *ctx) { enum { FILE_IDX = 0, SWITCH_IDX = 1 }; enum ofputil_protocol usable_protocols, protocol; - struct cls_cursor cursor; struct classifier cls; - struct list requests; + struct ovs_list requests; struct vconn *vconn; struct fte *fte; - classifier_init(&cls); - usable_protocols = read_flows_from_file(argv[2], &cls, FILE_IDX); + classifier_init(&cls, NULL); + usable_protocols = read_flows_from_file(ctx->argv[2], &cls, FILE_IDX); - protocol = open_vconn(argv[1], &vconn); + protocol = open_vconn(ctx->argv[1], &vconn); protocol = set_protocol_for_flow_dump(vconn, protocol, usable_protocols); read_flows_from_switch(vconn, protocol, &cls, SWITCH_IDX); @@ -2179,9 +2729,7 @@ ofctl_replace_flows(int argc OVS_UNUSED, char *argv[]) list_init(&requests); /* Delete flows that exist on the switch but not in the file. */ - ovs_rwlock_rdlock(&cls.rwlock); - cls_cursor_init(&cursor, &cls, NULL); - CLS_CURSOR_FOR_EACH (fte, rule, &cursor) { + CLS_FOR_EACH (fte, rule, &cls) { struct fte_version *file_ver = fte->versions[FILE_IDX]; struct fte_version *sw_ver = fte->versions[SWITCH_IDX]; @@ -2193,8 +2741,7 @@ ofctl_replace_flows(int argc OVS_UNUSED, char *argv[]) /* Add flows that exist in the file but not on the switch. * Update flows that exist in both places but differ. */ - cls_cursor_init(&cursor, &cls, NULL); - CLS_CURSOR_FOR_EACH (fte, rule, &cursor) { + CLS_FOR_EACH (fte, rule, &cls) { struct fte_version *file_ver = fte->versions[FILE_IDX]; struct fte_version *sw_ver = fte->versions[SWITCH_IDX]; @@ -2203,8 +2750,11 @@ ofctl_replace_flows(int argc OVS_UNUSED, char *argv[]) fte_make_flow_mod(fte, FILE_IDX, OFPFC_ADD, protocol, &requests); } } - ovs_rwlock_unlock(&cls.rwlock); - transact_multiple_noreply(vconn, &requests); + if (bundle) { + bundle_transact(vconn, &requests, OFPBF_ORDERED | OFPBF_ATOMIC); + } else { + transact_multiple_noreply(vconn, &requests); + } vconn_close(vconn); fte_free_all(&cls); @@ -2230,24 +2780,21 @@ read_flows_from_source(const char *source, struct classifier *cls, int index) } static void -ofctl_diff_flows(int argc OVS_UNUSED, char *argv[]) +ofctl_diff_flows(struct ovs_cmdl_context *ctx) { bool differences = false; - struct cls_cursor cursor; struct classifier cls; struct ds a_s, b_s; struct fte *fte; - classifier_init(&cls); - read_flows_from_source(argv[1], &cls, 0); - read_flows_from_source(argv[2], &cls, 1); + classifier_init(&cls, NULL); + read_flows_from_source(ctx->argv[1], &cls, 0); + read_flows_from_source(ctx->argv[2], &cls, 1); ds_init(&a_s); ds_init(&b_s); - ovs_rwlock_rdlock(&cls.rwlock); - cls_cursor_init(&cursor, &cls, NULL); - CLS_CURSOR_FOR_EACH (fte, rule, &cursor) { + CLS_FOR_EACH (fte, rule, &cls) { struct fte_version *a = fte->versions[0]; struct fte_version *b = fte->versions[1]; @@ -2265,7 +2812,6 @@ ofctl_diff_flows(int argc OVS_UNUSED, char *argv[]) } } } - ovs_rwlock_unlock(&cls.rwlock); ds_destroy(&a_s); ds_destroy(&b_s); @@ -2276,18 +2822,113 @@ ofctl_diff_flows(int argc OVS_UNUSED, char *argv[]) exit(2); } } + +static void +ofctl_meter_mod__(const char *bridge, const char *str, int command) +{ + struct ofputil_meter_mod mm; + struct vconn *vconn; + enum ofputil_protocol protocol; + enum ofputil_protocol usable_protocols; + enum ofp_version version; + + if (str) { + char *error; + error = parse_ofp_meter_mod_str(&mm, str, command, &usable_protocols); + if (error) { + ovs_fatal(0, "%s", error); + } + } else { + usable_protocols = OFPUTIL_P_OF13_UP; + mm.command = command; + mm.meter.meter_id = OFPM13_ALL; + } + + protocol = open_vconn_for_flow_mod(bridge, &vconn, usable_protocols); + version = ofputil_protocol_to_ofp_version(protocol); + transact_noreply(vconn, ofputil_encode_meter_mod(version, &mm)); + vconn_close(vconn); +} + +static void +ofctl_meter_request__(const char *bridge, const char *str, + enum ofputil_meter_request_type type) +{ + struct ofputil_meter_mod mm; + struct vconn *vconn; + enum ofputil_protocol usable_protocols; + enum ofputil_protocol protocol; + enum ofp_version version; + + if (str) { + char *error; + error = parse_ofp_meter_mod_str(&mm, str, -1, &usable_protocols); + if (error) { + ovs_fatal(0, "%s", error); + } + } else { + usable_protocols = OFPUTIL_P_OF13_UP; + mm.meter.meter_id = OFPM13_ALL; + } + + protocol = open_vconn_for_flow_mod(bridge, &vconn, usable_protocols); + version = ofputil_protocol_to_ofp_version(protocol); + transact_noreply(vconn, ofputil_encode_meter_request(version, + type, + mm.meter.meter_id)); + vconn_close(vconn); +} + + +static void +ofctl_add_meter(struct ovs_cmdl_context *ctx) +{ + ofctl_meter_mod__(ctx->argv[1], ctx->argv[2], OFPMC13_ADD); +} + +static void +ofctl_mod_meter(struct ovs_cmdl_context *ctx) +{ + ofctl_meter_mod__(ctx->argv[1], ctx->argv[2], OFPMC13_MODIFY); +} + +static void +ofctl_del_meters(struct ovs_cmdl_context *ctx) +{ + ofctl_meter_mod__(ctx->argv[1], ctx->argc > 2 ? ctx->argv[2] : NULL, OFPMC13_DELETE); +} + +static void +ofctl_dump_meters(struct ovs_cmdl_context *ctx) +{ + ofctl_meter_request__(ctx->argv[1], ctx->argc > 2 ? ctx->argv[2] : NULL, + OFPUTIL_METER_CONFIG); +} + +static void +ofctl_meter_stats(struct ovs_cmdl_context *ctx) +{ + ofctl_meter_request__(ctx->argv[1], ctx->argc > 2 ? ctx->argv[2] : NULL, + OFPUTIL_METER_STATS); +} + +static void +ofctl_meter_features(struct ovs_cmdl_context *ctx) +{ + ofctl_meter_request__(ctx->argv[1], NULL, OFPUTIL_METER_FEATURES); +} + /* Undocumented commands for unit testing. */ static void -ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms) +ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms, + enum ofputil_protocol usable_protocols) { - enum ofputil_protocol usable_protocols; enum ofputil_protocol protocol = 0; char *usable_s; size_t i; - usable_protocols = ofputil_flow_mod_usable_protocols(fms, n_fms); usable_s = ofputil_protocols_to_string(usable_protocols); printf("usable protocols: %s\n", usable_s); free(usable_s); @@ -2313,44 +2954,47 @@ ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms) ofp_print(stdout, msg->data, msg->size, verbosity); ofpbuf_delete(msg); - free(fm->ofpacts); + free(CONST_CAST(struct ofpact *, fm->ofpacts)); } } /* "parse-flow FLOW": parses the argument as a flow (like add-flow) and prints * it back to stdout. */ static void -ofctl_parse_flow(int argc OVS_UNUSED, char *argv[]) +ofctl_parse_flow(struct ovs_cmdl_context *ctx) { + enum ofputil_protocol usable_protocols; struct ofputil_flow_mod fm; char *error; - error = parse_ofp_flow_mod_str(&fm, argv[1], OFPFC_ADD); + error = parse_ofp_flow_mod_str(&fm, ctx->argv[1], OFPFC_ADD, &usable_protocols); if (error) { ovs_fatal(0, "%s", error); } - ofctl_parse_flows__(&fm, 1); + ofctl_parse_flows__(&fm, 1, usable_protocols); } /* "parse-flows FILENAME": reads the named file as a sequence of flows (like * add-flows) and prints each of the flows back to stdout. */ static void -ofctl_parse_flows(int argc OVS_UNUSED, char *argv[]) +ofctl_parse_flows(struct ovs_cmdl_context *ctx) { + enum ofputil_protocol usable_protocols; struct ofputil_flow_mod *fms = NULL; size_t n_fms = 0; char *error; - error = parse_ofp_flow_mod_file(argv[1], OFPFC_ADD, &fms, &n_fms); + error = parse_ofp_flow_mod_file(ctx->argv[1], OFPFC_ADD, &fms, &n_fms, + &usable_protocols); if (error) { ovs_fatal(0, "%s", error); } - ofctl_parse_flows__(fms, n_fms); + ofctl_parse_flows__(fms, n_fms, usable_protocols); free(fms); } static void -ofctl_parse_nxm__(bool oxm) +ofctl_parse_nxm__(bool oxm, enum ofp_version version) { struct ds in; @@ -2395,7 +3039,7 @@ ofctl_parse_nxm__(bool oxm) ofpbuf_uninit(&nx_match); ofpbuf_init(&nx_match, 0); if (oxm) { - match_len = oxm_put_match(&nx_match, &match); + match_len = oxm_put_match(&nx_match, &match, version); out = oxm_match_to_string(&nx_match, match_len); } else { match_len = nx_put_match(&nx_match, &match, @@ -2405,6 +3049,10 @@ ofctl_parse_nxm__(bool oxm) puts(out); free(out); + + if (verbosity > 0) { + ovs_hex_dump(stdout, nx_match.data, nx_match.size, 0, false); + } } else { printf("nx_pull_match() returned error %s\n", ofperr_get_name(error)); @@ -2419,18 +3067,24 @@ ofctl_parse_nxm__(bool oxm) * stdin, does some internal fussing with them, and then prints them back as * strings on stdout. */ static void -ofctl_parse_nxm(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_nxm(struct ovs_cmdl_context *ctx OVS_UNUSED) { - return ofctl_parse_nxm__(false); + ofctl_parse_nxm__(false, 0); } -/* "parse-oxm": reads a series of OXM nx_match specifications as strings from - * stdin, does some internal fussing with them, and then prints them back as - * strings on stdout. */ +/* "parse-oxm VERSION": reads a series of OXM nx_match specifications as + * strings from stdin, does some internal fussing with them, and then prints + * them back as strings on stdout. VERSION must specify an OpenFlow version, + * e.g. "OpenFlow12". */ static void -ofctl_parse_oxm(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_oxm(struct ovs_cmdl_context *ctx) { - return ofctl_parse_nxm__(true); + enum ofp_version version = ofputil_version_from_string(ctx->argv[1]); + if (version < OFP12_VERSION) { + ovs_fatal(0, "%s: not a valid version for OXM", ctx->argv[1]); + } + + ofctl_parse_nxm__(true, version); } static void @@ -2444,75 +3098,131 @@ print_differences(const char *prefix, for (i = 0; i < MIN(a_len, b_len); i++) { if (a[i] != b[i]) { - printf("%s%2zu: %02"PRIx8" -> %02"PRIx8"\n", + printf("%s%2"PRIuSIZE": %02"PRIx8" -> %02"PRIx8"\n", prefix, i, a[i], b[i]); } } for (i = a_len; i < b_len; i++) { - printf("%s%2zu: (none) -> %02"PRIx8"\n", prefix, i, b[i]); + printf("%s%2"PRIuSIZE": (none) -> %02"PRIx8"\n", prefix, i, b[i]); } for (i = b_len; i < a_len; i++) { - printf("%s%2zu: %02"PRIx8" -> (none)\n", prefix, i, a[i]); + printf("%s%2"PRIuSIZE": %02"PRIx8" -> (none)\n", prefix, i, a[i]); } } -/* "parse-ofp10-actions": reads a series of OpenFlow 1.0 action specifications - * as hex bytes from stdin, converts them to ofpacts, prints them as strings - * on stdout, and then converts them back to hex bytes and prints any - * differences from the input. */ static void -ofctl_parse_ofp10_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_actions__(const char *version_s, bool instructions) { + enum ofp_version version; struct ds in; + version = ofputil_version_from_string(version_s); + if (!version) { + ovs_fatal(0, "%s: not a valid OpenFlow version", version_s); + } + ds_init(&in); while (!ds_get_preprocessed_line(&in, stdin, NULL)) { - struct ofpbuf of10_out; - struct ofpbuf of10_in; + struct ofpbuf of_out; + struct ofpbuf of_in; struct ofpbuf ofpacts; + const char *table_id; + char *actions; enum ofperr error; size_t size; struct ds s; + /* Parse table_id separated with the follow-up actions by ",", if + * any. */ + actions = ds_cstr(&in); + table_id = NULL; + if (strstr(actions, ",")) { + table_id = strsep(&actions, ","); + } + /* Parse hex bytes. */ - ofpbuf_init(&of10_in, 0); - if (ofpbuf_put_hex(&of10_in, ds_cstr(&in), NULL)[0] != '\0') { + ofpbuf_init(&of_in, 0); + if (ofpbuf_put_hex(&of_in, actions, NULL)[0] != '\0') { ovs_fatal(0, "Trailing garbage in hex data"); } /* Convert to ofpacts. */ ofpbuf_init(&ofpacts, 0); - size = of10_in.size; - error = ofpacts_pull_openflow10(&of10_in, of10_in.size, &ofpacts); + size = of_in.size; + error = (instructions + ? ofpacts_pull_openflow_instructions + : ofpacts_pull_openflow_actions)( + &of_in, of_in.size, version, &ofpacts); + if (!error && instructions) { + /* Verify actions, enforce consistency. */ + enum ofputil_protocol protocol; + struct flow flow; + + memset(&flow, 0, sizeof flow); + protocol = ofputil_protocols_from_ofp_version(version); + error = ofpacts_check_consistency(ofpacts.data, ofpacts.size, + &flow, OFPP_MAX, + table_id ? atoi(table_id) : 0, + 255, protocol); + } if (error) { - printf("bad OF1.1 actions: %s\n\n", ofperr_get_name(error)); + printf("bad %s %s: %s\n\n", + version_s, instructions ? "instructions" : "actions", + ofperr_get_name(error)); ofpbuf_uninit(&ofpacts); - ofpbuf_uninit(&of10_in); + ofpbuf_uninit(&of_in); continue; } - ofpbuf_push_uninit(&of10_in, size); + ofpbuf_push_uninit(&of_in, size); /* Print cls_rule. */ ds_init(&s); + ds_put_cstr(&s, "actions="); ofpacts_format(ofpacts.data, ofpacts.size, &s); puts(ds_cstr(&s)); ds_destroy(&s); /* Convert back to ofp10 actions and print differences from input. */ - ofpbuf_init(&of10_out, 0); - ofpacts_put_openflow10(ofpacts.data, ofpacts.size, &of10_out); + ofpbuf_init(&of_out, 0); + if (instructions) { + ofpacts_put_openflow_instructions(ofpacts.data, ofpacts.size, + &of_out, version); + } else { + ofpacts_put_openflow_actions(ofpacts.data, ofpacts.size, + &of_out, version); + } - print_differences("", of10_in.data, of10_in.size, - of10_out.data, of10_out.size); + print_differences("", of_in.data, of_in.size, + of_out.data, of_out.size); putchar('\n'); ofpbuf_uninit(&ofpacts); - ofpbuf_uninit(&of10_in); - ofpbuf_uninit(&of10_out); + ofpbuf_uninit(&of_in); + ofpbuf_uninit(&of_out); } ds_destroy(&in); } +/* "parse-actions VERSION": reads a series of action specifications for the + * given OpenFlow VERSION as hex bytes from stdin, converts them to ofpacts, + * prints them as strings on stdout, and then converts them back to hex bytes + * and prints any differences from the input. */ +static void +ofctl_parse_actions(struct ovs_cmdl_context *ctx) +{ + ofctl_parse_actions__(ctx->argv[1], false); +} + +/* "parse-actions VERSION": reads a series of instruction specifications for + * the given OpenFlow VERSION as hex bytes from stdin, converts them to + * ofpacts, prints them as strings on stdout, and then converts them back to + * hex bytes and prints any differences from the input. */ +static void +ofctl_parse_instructions(struct ovs_cmdl_context *ctx) +{ + ofctl_parse_actions__(ctx->argv[1], true); +} + /* "parse-ofp10-match": reads a series of ofp10_match specifications as hex * bytes from stdin, converts them to cls_rules, prints them as strings on * stdout, and then converts them back to hex bytes and prints any differences @@ -2523,7 +3233,7 @@ ofctl_parse_ofp10_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) * them back to hex bytes. ovs-ofctl actually sets "x"s to random bits when * it does the conversion to hex, to ensure that in fact they are ignored. */ static void -ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_ofp10_match(struct ovs_cmdl_context *ctx OVS_UNUSED) { struct ds expout; struct ds in; @@ -2550,7 +3260,7 @@ ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) ovs_fatal(0, "Trailing garbage in hex data"); } if (match_expout.size != sizeof(struct ofp10_match)) { - ovs_fatal(0, "Input is %zu bytes, expected %zu", + ovs_fatal(0, "Input is %"PRIu32" bytes, expected %"PRIuSIZE, match_expout.size, sizeof(struct ofp10_match)); } @@ -2565,7 +3275,7 @@ ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) ovs_fatal(0, "Trailing garbage in hex data"); } if (match_in.size != sizeof(struct ofp10_match)) { - ovs_fatal(0, "Input is %zu bytes, expected %zu", + ovs_fatal(0, "Input is %"PRIu32" bytes, expected %"PRIuSIZE, match_in.size, sizeof(struct ofp10_match)); } @@ -2597,7 +3307,7 @@ ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) * on stdout, and then converts them back to hex bytes and prints any * differences from the input. */ static void -ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_ofp11_match(struct ovs_cmdl_context *ctx OVS_UNUSED) { struct ds in; @@ -2614,7 +3324,7 @@ ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) ovs_fatal(0, "Trailing garbage in hex data"); } if (match_in.size != sizeof(struct ofp11_match)) { - ovs_fatal(0, "Input is %zu bytes, expected %zu", + ovs_fatal(0, "Input is %"PRIu32" bytes, expected %"PRIuSIZE, match_in.size, sizeof(struct ofp11_match)); } @@ -2641,145 +3351,41 @@ ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) ds_destroy(&in); } -/* "parse-ofp11-actions": reads a series of OpenFlow 1.1 action specifications - * as hex bytes from stdin, converts them to ofpacts, prints them as strings - * on stdout, and then converts them back to hex bytes and prints any - * differences from the input. */ +/* "parse-pcap PCAP": read packets from PCAP and print their flows. */ static void -ofctl_parse_ofp11_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +ofctl_parse_pcap(struct ovs_cmdl_context *ctx) { - struct ds in; - - ds_init(&in); - while (!ds_get_preprocessed_line(&in, stdin, NULL)) { - struct ofpbuf of11_out; - struct ofpbuf of11_in; - struct ofpbuf ofpacts; - enum ofperr error; - size_t size; - struct ds s; - - /* Parse hex bytes. */ - ofpbuf_init(&of11_in, 0); - if (ofpbuf_put_hex(&of11_in, ds_cstr(&in), NULL)[0] != '\0') { - ovs_fatal(0, "Trailing garbage in hex data"); - } + FILE *pcap; - /* Convert to ofpacts. */ - ofpbuf_init(&ofpacts, 0); - size = of11_in.size; - error = ofpacts_pull_openflow11_actions(&of11_in, of11_in.size, - &ofpacts); - if (error) { - printf("bad OF1.1 actions: %s\n\n", ofperr_get_name(error)); - ofpbuf_uninit(&ofpacts); - ofpbuf_uninit(&of11_in); - continue; - } - ofpbuf_push_uninit(&of11_in, size); - - /* Print cls_rule. */ - ds_init(&s); - ofpacts_format(ofpacts.data, ofpacts.size, &s); - puts(ds_cstr(&s)); - ds_destroy(&s); - - /* Convert back to ofp11 actions and print differences from input. */ - ofpbuf_init(&of11_out, 0); - ofpacts_put_openflow11_actions(ofpacts.data, ofpacts.size, &of11_out); - - print_differences("", of11_in.data, of11_in.size, - of11_out.data, of11_out.size); - putchar('\n'); - - ofpbuf_uninit(&ofpacts); - ofpbuf_uninit(&of11_in); - ofpbuf_uninit(&of11_out); + pcap = ovs_pcap_open(ctx->argv[1], "rb"); + if (!pcap) { + ovs_fatal(errno, "%s: open failed", ctx->argv[1]); } - ds_destroy(&in); -} - -/* "parse-ofp11-instructions": reads a series of OpenFlow 1.1 instruction - * specifications as hex bytes from stdin, converts them to ofpacts, prints - * them as strings on stdout, and then converts them back to hex bytes and - * prints any differences from the input. */ -static void -ofctl_parse_ofp11_instructions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) -{ - struct ds in; - - ds_init(&in); - while (!ds_get_preprocessed_line(&in, stdin, NULL)) { - struct ofpbuf of11_out; - struct ofpbuf of11_in; - struct ofpbuf ofpacts; - enum ofperr error; - size_t size; - struct ds s; - const char *table_id; - char *instructions; - /* Parse table_id separated with the follow-up instructions by ",", if - * any. */ - instructions = ds_cstr(&in); - table_id = NULL; - if (strstr(instructions, ",")) { - table_id = strsep(&instructions, ","); - } - - /* Parse hex bytes. */ - ofpbuf_init(&of11_in, 0); - if (ofpbuf_put_hex(&of11_in, instructions, NULL)[0] != '\0') { - ovs_fatal(0, "Trailing garbage in hex data"); - } + for (;;) { + struct dp_packet *packet; + struct flow flow; + int error; - /* Convert to ofpacts. */ - ofpbuf_init(&ofpacts, 0); - size = of11_in.size; - error = ofpacts_pull_openflow11_instructions(&of11_in, of11_in.size, - &ofpacts); - if (!error) { - /* Verify actions. */ - struct flow flow; - memset(&flow, 0, sizeof flow); - error = ofpacts_check(ofpacts.data, ofpacts.size, &flow, OFPP_MAX, - table_id ? atoi(table_id) : 0); - } - if (error) { - printf("bad OF1.1 instructions: %s\n\n", ofperr_get_name(error)); - ofpbuf_uninit(&ofpacts); - ofpbuf_uninit(&of11_in); - continue; + error = ovs_pcap_read(pcap, &packet, NULL); + if (error == EOF) { + break; + } else if (error) { + ovs_fatal(error, "%s: read failed", ctx->argv[1]); } - ofpbuf_push_uninit(&of11_in, size); - /* Print cls_rule. */ - ds_init(&s); - ofpacts_format(ofpacts.data, ofpacts.size, &s); - puts(ds_cstr(&s)); - ds_destroy(&s); - - /* Convert back to ofp11 instructions and print differences from - * input. */ - ofpbuf_init(&of11_out, 0); - ofpacts_put_openflow11_instructions(ofpacts.data, ofpacts.size, - &of11_out); - - print_differences("", of11_in.data, of11_in.size, - of11_out.data, of11_out.size); + pkt_metadata_init(&packet->md, ODPP_NONE); + flow_extract(packet, &flow); + flow_print(stdout, &flow); putchar('\n'); - - ofpbuf_uninit(&ofpacts); - ofpbuf_uninit(&of11_in); - ofpbuf_uninit(&of11_out); + dp_packet_delete(packet); } - ds_destroy(&in); } /* "check-vlan VLAN_TCI VLAN_TCI_MASK": converts the specified vlan_tci and * mask values to and from various formats and prints the results. */ static void -ofctl_check_vlan(int argc OVS_UNUSED, char *argv[]) +ofctl_check_vlan(struct ovs_cmdl_context *ctx) { struct match match; @@ -2800,15 +3406,17 @@ ofctl_check_vlan(int argc OVS_UNUSED, char *argv[]) enum ofperr error; char *error_s; + enum ofputil_protocol usable_protocols; /* Unused for now. */ + match_init_catchall(&match); - match.flow.vlan_tci = htons(strtoul(argv[1], NULL, 16)); - match.wc.masks.vlan_tci = htons(strtoul(argv[2], NULL, 16)); + match.flow.vlan_tci = htons(strtoul(ctx->argv[1], NULL, 16)); + match.wc.masks.vlan_tci = htons(strtoul(ctx->argv[2], NULL, 16)); /* Convert to and from string. */ string_s = match_to_string(&match, OFP_DEFAULT_PRIORITY); printf("%s -> ", string_s); fflush(stdout); - error_s = parse_ofp_str(&fm, -1, string_s); + error_s = parse_ofp_str(&fm, -1, string_s, &usable_protocols); if (error_s) { ovs_fatal(0, "%s", error_s); } @@ -2835,7 +3443,7 @@ ofctl_check_vlan(int argc OVS_UNUSED, char *argv[]) /* Convert to and from OXM. */ ofpbuf_init(&nxm, 0); - nxm_match_len = oxm_put_match(&nxm, &match); + nxm_match_len = oxm_put_match(&nxm, &match, OFP12_VERSION); nxm_s = oxm_match_to_string(&nxm, nxm_match_len); error = oxm_pull_match(&nxm, &nxm_match); printf("OXM: %s -> ", nxm_s); @@ -2883,14 +3491,14 @@ ofctl_check_vlan(int argc OVS_UNUSED, char *argv[]) /* "print-error ENUM": Prints the type and code of ENUM for every OpenFlow * version. */ static void -ofctl_print_error(int argc OVS_UNUSED, char *argv[]) +ofctl_print_error(struct ovs_cmdl_context *ctx) { enum ofperr error; int version; - error = ofperr_from_name(argv[1]); + error = ofperr_from_name(ctx->argv[1]); if (!error) { - ovs_fatal(0, "unknown error \"%s\"", argv[1]); + ovs_fatal(0, "unknown error \"%s\"", ctx->argv[1]); } for (version = 0; version <= UINT8_MAX; version++) { @@ -2911,19 +3519,19 @@ ofctl_print_error(int argc OVS_UNUSED, char *argv[]) /* "encode-error-reply ENUM REQUEST": Encodes an error reply to REQUEST for the * error named ENUM and prints the error reply in hex. */ static void -ofctl_encode_error_reply(int argc OVS_UNUSED, char *argv[]) +ofctl_encode_error_reply(struct ovs_cmdl_context *ctx) { const struct ofp_header *oh; struct ofpbuf request, *reply; enum ofperr error; - error = ofperr_from_name(argv[1]); + error = ofperr_from_name(ctx->argv[1]); if (!error) { - ovs_fatal(0, "unknown error \"%s\"", argv[1]); + ovs_fatal(0, "unknown error \"%s\"", ctx->argv[1]); } ofpbuf_init(&request, 0); - if (ofpbuf_put_hex(&request, argv[2], NULL)[0] != '\0') { + if (ofpbuf_put_hex(&request, ctx->argv[2], NULL)[0] != '\0') { ovs_fatal(0, "Trailing garbage in hex data"); } if (request.size < sizeof(struct ofp_header)) { @@ -2944,26 +3552,49 @@ ofctl_encode_error_reply(int argc OVS_UNUSED, char *argv[]) /* "ofp-print HEXSTRING [VERBOSITY]": Converts the hex digits in HEXSTRING into * binary data, interpreting them as an OpenFlow message, and prints the - * OpenFlow message on stdout, at VERBOSITY (level 2 by default). */ + * OpenFlow message on stdout, at VERBOSITY (level 2 by default). + * + * Alternative usage: "ofp-print [VERBOSITY] - < HEXSTRING_FILE", where + * HEXSTRING_FILE contains the HEXSTRING. */ static void -ofctl_ofp_print(int argc, char *argv[]) +ofctl_ofp_print(struct ovs_cmdl_context *ctx) { struct ofpbuf packet; + char *buffer; + int verbosity = 2; + struct ds line; + + ds_init(&line); + + if (!strcmp(ctx->argv[ctx->argc-1], "-")) { + if (ds_get_line(&line, stdin)) { + VLOG_FATAL("Failed to read stdin"); + } + + buffer = line.string; + verbosity = ctx->argc > 2 ? atoi(ctx->argv[1]) : verbosity; + } else if (ctx->argc > 2) { + buffer = ctx->argv[1]; + verbosity = atoi(ctx->argv[2]); + } else { + buffer = ctx->argv[1]; + } - ofpbuf_init(&packet, strlen(argv[1]) / 2); - if (ofpbuf_put_hex(&packet, argv[1], NULL)[0] != '\0') { + ofpbuf_init(&packet, strlen(buffer) / 2); + if (ofpbuf_put_hex(&packet, buffer, NULL)[0] != '\0') { ovs_fatal(0, "trailing garbage following hex bytes"); } - ofp_print(stdout, packet.data, packet.size, argc > 2 ? atoi(argv[2]) : 2); + ofp_print(stdout, packet.data, packet.size, verbosity); ofpbuf_uninit(&packet); + ds_destroy(&line); } /* "encode-hello BITMAP...": Encodes each BITMAP as an OpenFlow hello message * and dumps each message in hex. */ static void -ofctl_encode_hello(int argc OVS_UNUSED, char *argv[]) +ofctl_encode_hello(struct ovs_cmdl_context *ctx) { - uint32_t bitmap = strtol(argv[1], NULL, 0); + uint32_t bitmap = strtol(ctx->argv[1], NULL, 0); struct ofpbuf *hello; hello = ofputil_encode_hello(bitmap); @@ -2972,54 +3603,129 @@ ofctl_encode_hello(int argc OVS_UNUSED, char *argv[]) ofpbuf_delete(hello); } -static const struct command all_commands[] = { - { "show", 1, 1, ofctl_show }, - { "monitor", 1, 3, ofctl_monitor }, - { "snoop", 1, 1, ofctl_snoop }, - { "dump-desc", 1, 1, ofctl_dump_desc }, - { "dump-tables", 1, 1, ofctl_dump_tables }, - { "dump-flows", 1, 2, ofctl_dump_flows }, - { "dump-aggregate", 1, 2, ofctl_dump_aggregate }, - { "queue-stats", 1, 3, ofctl_queue_stats }, - { "add-flow", 2, 2, ofctl_add_flow }, - { "add-flows", 2, 2, ofctl_add_flows }, - { "mod-flows", 2, 2, ofctl_mod_flows }, - { "del-flows", 1, 2, ofctl_del_flows }, - { "replace-flows", 2, 2, ofctl_replace_flows }, - { "diff-flows", 2, 2, ofctl_diff_flows }, - { "packet-out", 4, INT_MAX, ofctl_packet_out }, - { "dump-ports", 1, 2, ofctl_dump_ports }, - { "dump-ports-desc", 1, 1, ofctl_dump_ports_desc }, - { "mod-port", 3, 3, ofctl_mod_port }, - { "get-frags", 1, 1, ofctl_get_frags }, - { "set-frags", 2, 2, ofctl_set_frags }, - { "ofp-parse", 1, 1, ofctl_ofp_parse }, - { "probe", 1, 1, ofctl_probe }, - { "ping", 1, 2, ofctl_ping }, - { "benchmark", 3, 3, ofctl_benchmark }, - { "help", 0, INT_MAX, ofctl_help }, +static const struct ovs_cmdl_command all_commands[] = { + { "show", "switch", + 1, 1, ofctl_show }, + { "monitor", "switch [misslen] [invalid_ttl] [watch:[...]]", + 1, 3, ofctl_monitor }, + { "snoop", "switch", + 1, 1, ofctl_snoop }, + { "dump-desc", "switch", + 1, 1, ofctl_dump_desc }, + { "dump-tables", "switch", + 1, 1, ofctl_dump_tables }, + { "dump-table-features", "switch", + 1, 1, ofctl_dump_table_features }, + { "dump-flows", "switch", + 1, 2, ofctl_dump_flows }, + { "dump-aggregate", "switch", + 1, 2, ofctl_dump_aggregate }, + { "queue-stats", "switch [port [queue]]", + 1, 3, ofctl_queue_stats }, + { "queue-get-config", "switch port", + 2, 2, ofctl_queue_get_config }, + { "add-flow", "switch flow", + 2, 2, ofctl_add_flow }, + { "add-flows", "switch file", + 2, 2, ofctl_add_flows }, + { "mod-flows", "switch flow", + 2, 2, ofctl_mod_flows }, + { "del-flows", "switch [flow]", + 1, 2, ofctl_del_flows }, + { "replace-flows", "switch file", + 2, 2, ofctl_replace_flows }, + { "diff-flows", "source1 source2", + 2, 2, ofctl_diff_flows }, + { "add-meter", "switch meter", + 2, 2, ofctl_add_meter }, + { "mod-meter", "switch meter", + 2, 2, ofctl_mod_meter }, + { "del-meter", "switch meter", + 2, 2, ofctl_del_meters }, + { "del-meters", "switch", + 1, 1, ofctl_del_meters }, + { "dump-meter", "switch meter", + 2, 2, ofctl_dump_meters }, + { "dump-meters", "switch", + 1, 1, ofctl_dump_meters }, + { "meter-stats", "switch [meter]", + 1, 2, ofctl_meter_stats }, + { "meter-features", "switch", + 1, 1, ofctl_meter_features }, + { "packet-out", "switch in_port actions packet...", + 4, INT_MAX, ofctl_packet_out }, + { "dump-ports", "switch [port]", + 1, 2, ofctl_dump_ports }, + { "dump-ports-desc", "switch [port]", + 1, 2, ofctl_dump_ports_desc }, + { "mod-port", "switch iface act", + 3, 3, ofctl_mod_port }, + { "mod-table", "switch mod", + 3, 3, ofctl_mod_table }, + { "get-frags", "switch", + 1, 1, ofctl_get_frags }, + { "set-frags", "switch frag_mode", + 2, 2, ofctl_set_frags }, + { "probe", "target", + 1, 1, ofctl_probe }, + { "ping", "target [n]", + 1, 2, ofctl_ping }, + { "benchmark", "target n count", + 3, 3, ofctl_benchmark }, + + { "ofp-parse", "file", + 1, 1, ofctl_ofp_parse }, + { "ofp-parse-pcap", "pcap", + 1, INT_MAX, ofctl_ofp_parse_pcap }, + + { "add-group", "switch group", + 1, 2, ofctl_add_group }, + { "add-groups", "switch file", + 1, 2, ofctl_add_groups }, + { "mod-group", "switch group", + 1, 2, ofctl_mod_group }, + { "del-groups", "switch [group]", + 1, 2, ofctl_del_groups }, + { "insert-buckets", "switch [group]", + 1, 2, ofctl_insert_bucket }, + { "remove-buckets", "switch [group]", + 1, 2, ofctl_remove_bucket }, + { "dump-groups", "switch [group]", + 1, 2, ofctl_dump_group_desc }, + { "dump-group-stats", "switch [group]", + 1, 2, ofctl_dump_group_stats }, + { "dump-group-features", "switch", + 1, 1, ofctl_dump_group_features }, + { "add-geneve-map", "switch map", + 2, 2, ofctl_add_geneve_map }, + { "del-geneve-map", "switch [map]", + 1, 2, ofctl_del_geneve_map }, + { "dump-geneve-map", "switch", + 1, 1, ofctl_dump_geneve_map }, + { "help", NULL, 0, INT_MAX, ofctl_help }, + { "list-commands", NULL, 0, INT_MAX, ofctl_list_commands }, /* Undocumented commands for testing. */ - { "parse-flow", 1, 1, ofctl_parse_flow }, - { "parse-flows", 1, 1, ofctl_parse_flows }, - { "parse-nx-match", 0, 0, ofctl_parse_nxm }, - { "parse-nxm", 0, 0, ofctl_parse_nxm }, - { "parse-oxm", 0, 0, ofctl_parse_oxm }, - { "parse-ofp10-actions", 0, 0, ofctl_parse_ofp10_actions }, - { "parse-ofp10-match", 0, 0, ofctl_parse_ofp10_match }, - { "parse-ofp11-match", 0, 0, ofctl_parse_ofp11_match }, - { "parse-ofp11-actions", 0, 0, ofctl_parse_ofp11_actions }, - { "parse-ofp11-instructions", 0, 0, ofctl_parse_ofp11_instructions }, - { "check-vlan", 2, 2, ofctl_check_vlan }, - { "print-error", 1, 1, ofctl_print_error }, - { "encode-error-reply", 2, 2, ofctl_encode_error_reply }, - { "ofp-print", 1, 2, ofctl_ofp_print }, - { "encode-hello", 1, 1, ofctl_encode_hello }, - - { NULL, 0, 0, NULL }, + { "parse-flow", NULL, 1, 1, ofctl_parse_flow }, + { "parse-flows", NULL, 1, 1, ofctl_parse_flows }, + { "parse-nx-match", NULL, 0, 0, ofctl_parse_nxm }, + { "parse-nxm", NULL, 0, 0, ofctl_parse_nxm }, + { "parse-oxm", NULL, 1, 1, ofctl_parse_oxm }, + { "parse-actions", NULL, 1, 1, ofctl_parse_actions }, + { "parse-instructions", NULL, 1, 1, ofctl_parse_instructions }, + { "parse-ofp10-match", NULL, 0, 0, ofctl_parse_ofp10_match }, + { "parse-ofp11-match", NULL, 0, 0, ofctl_parse_ofp11_match }, + { "parse-pcap", NULL, 1, 1, ofctl_parse_pcap }, + { "check-vlan", NULL, 2, 2, ofctl_check_vlan }, + { "print-error", NULL, 1, 1, ofctl_print_error }, + { "encode-error-reply", NULL, 2, 2, ofctl_encode_error_reply }, + { "ofp-print", NULL, 1, 2, ofctl_ofp_print }, + { "encode-hello", NULL, 1, 1, ofctl_encode_hello }, + + { NULL, NULL, 0, 0, NULL }, }; -static const struct command *get_all_commands(void) +static const struct ovs_cmdl_command *get_all_commands(void) { return all_commands; }