X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=utilities%2Fovs-ofctl.c;h=ec775c7ddac7b722441a7acbff19625671a20e0f;hb=e892d5ffb5749c0534fecd903e3e6a76819f1346;hp=126c7204243eba18b8d31203f7dc6921886e6be5;hpb=26720e2449918b92be1fd0e3a7c57012c057c733;p=sliver-openvswitch.git diff --git a/utilities/ovs-ofctl.c b/utilities/ovs-ofctl.c index 126c72042..ec775c7dd 100644 --- a/utilities/ovs-ofctl.c +++ b/utilities/ovs-ofctl.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -44,6 +44,7 @@ #include "ofp-parse.h" #include "ofp-print.h" #include "ofp-util.h" +#include "ofp-version-opt.h" #include "ofpbuf.h" #include "ofproto/ofproto.h" #include "openflow/nicira-ext.h" @@ -52,6 +53,7 @@ #include "poll-loop.h" #include "random.h" #include "stream-ssl.h" +#include "socket-util.h" #include "timeval.h" #include "unixctl.h" #include "util.h" @@ -146,6 +148,7 @@ parse_options(int argc, char *argv[]) OPT_SORT, OPT_RSORT, DAEMON_OPTION_ENUMS, + OFP_VERSION_OPTION_ENUMS, VLOG_OPTION_ENUMS }; static struct option long_options[] = { @@ -159,13 +162,15 @@ parse_options(int argc, char *argv[]) {"sort", optional_argument, NULL, OPT_SORT}, {"rsort", optional_argument, NULL, OPT_RSORT}, {"help", no_argument, NULL, 'h'}, - {"version", no_argument, NULL, 'V'}, 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); + uint32_t versions; + enum ofputil_protocol version_protocols; for (;;) { unsigned long int timeout; @@ -209,10 +214,6 @@ parse_options(int argc, char *argv[]) case 'h': usage(); - case 'V': - ovs_print_version(OFP10_VERSION, OFP10_VERSION); - exit(EXIT_SUCCESS); - case OPT_STRICT: strict = true; break; @@ -234,6 +235,7 @@ parse_options(int argc, char *argv[]) break; DAEMON_OPTION_HANDLERS + OFP_VERSION_OPTION_HANDLERS VLOG_OPTION_HANDLERS STREAM_SSL_OPTION_HANDLERS @@ -251,6 +253,22 @@ parse_options(int argc, char *argv[]) } free(short_options); + + versions = get_allowed_ofp_versions(); + version_protocols = ofputil_protocols_from_version_bitmap(versions); + if (!(allowed_protocols & version_protocols)) { + char *protocols = ofputil_protocols_to_string(allowed_protocols); + struct ds version_s = DS_EMPTY_INITIALIZER; + + ofputil_format_version_bitmap_names(&version_s, versions); + ovs_fatal(0, "None of the enabled OpenFlow versions (%s) supports " + "any of the enabled flow formats (%s). (Use -O to enable " + "additional OpenFlow versions or -F to enable additional " + "flow formats.)", ds_cstr(&version_s), protocols); + } + allowed_protocols &= version_protocols; + mask_allowed_ofp_versions(ofputil_protocols_to_version_bitmap( + allowed_protocols)); } static void @@ -291,6 +309,7 @@ usage(void) program_name, program_name); vconn_usage(true, false, false); daemon_usage(); + ofp_version_usage(); vlog_usage(); printf("\nOther options:\n" " --strict use strict match for flow commands\n" @@ -319,7 +338,8 @@ ofctl_exit(struct unixctl_conn *conn, int argc OVS_UNUSED, static void run(int retval, const char *message, ...) PRINTF_FORMAT(2, 3); -static void run(int retval, const char *message, ...) +static void +run(int retval, const char *message, ...) { if (retval) { va_list args; @@ -331,54 +351,70 @@ static void run(int retval, const char *message, ...) /* Generic commands. */ -static void +static int open_vconn_socket(const char *name, struct vconn **vconnp) { char *vconn_name = xasprintf("unix:%s", name); - VLOG_DBG("connecting to %s", vconn_name); - run(vconn_open_block(vconn_name, OFP10_VERSION, vconnp), - "connecting to %s", vconn_name); + int error; + + error = vconn_open(vconn_name, get_allowed_ofp_versions(), DSCP_DEFAULT, + vconnp); + if (error && error != ENOENT) { + ovs_fatal(0, "%s: failed to open socket (%s)", name, + strerror(error)); + } free(vconn_name); + + return error; } +enum open_target { MGMT, SNOOP }; + static enum ofputil_protocol -open_vconn__(const char *name, const char *default_suffix, +open_vconn__(const char *name, enum open_target target, struct vconn **vconnp) { + const char *suffix = target == MGMT ? "mgmt" : "snoop"; char *datapath_name, *datapath_type, *socket_name; enum ofputil_protocol protocol; char *bridge_path; int ofp_version; - struct stat s; + int error; - bridge_path = xasprintf("%s/%s.%s", ovs_rundir(), name, default_suffix); + bridge_path = xasprintf("%s/%s.%s", ovs_rundir(), name, suffix); ofproto_parse_name(name, &datapath_name, &datapath_type); - socket_name = xasprintf("%s/%s.%s", - ovs_rundir(), datapath_name, default_suffix); + socket_name = xasprintf("%s/%s.%s", ovs_rundir(), datapath_name, suffix); free(datapath_name); free(datapath_type); if (strchr(name, ':')) { - run(vconn_open_block(name, OFP10_VERSION, vconnp), + run(vconn_open(name, get_allowed_ofp_versions(), DSCP_DEFAULT, vconnp), "connecting to %s", name); - } else if (!stat(name, &s) && S_ISSOCK(s.st_mode)) { - open_vconn_socket(name, vconnp); - } else if (!stat(bridge_path, &s) && S_ISSOCK(s.st_mode)) { - open_vconn_socket(bridge_path, vconnp); - } else if (!stat(socket_name, &s)) { - if (!S_ISSOCK(s.st_mode)) { - ovs_fatal(0, "cannot connect to %s: %s is not a socket", - name, socket_name); - } - open_vconn_socket(socket_name, vconnp); + } else if (!open_vconn_socket(name, vconnp)) { + /* Fall Through. */ + } else if (!open_vconn_socket(bridge_path, vconnp)) { + /* Fall Through. */ + } else if (!open_vconn_socket(socket_name, vconnp)) { + /* Fall Through. */ } else { ovs_fatal(0, "%s is not a bridge or a socket", name); } + if (target == SNOOP) { + vconn_set_recv_any_version(*vconnp); + } + free(bridge_path); free(socket_name); + VLOG_DBG("connecting to %s", vconn_get_name(*vconnp)); + error = vconn_connect_block(*vconnp); + if (error) { + ovs_fatal(0, "%s: failed to connect to socket (%s)", name, + strerror(error)); + } + ofp_version = vconn_get_version(*vconnp); protocol = ofputil_protocol_from_ofp_version(ofp_version); if (!protocol) { @@ -391,7 +427,7 @@ open_vconn__(const char *name, const char *default_suffix, static enum ofputil_protocol open_vconn(const char *name, struct vconn **vconnp) { - return open_vconn__(name, "mgmt", vconnp); + return open_vconn__(name, MGMT, vconnp); } static void @@ -402,25 +438,27 @@ send_openflow_buffer(struct vconn *vconn, struct ofpbuf *buffer) } static void -dump_transaction(const char *vconn_name, struct ofpbuf *request) +dump_transaction(struct vconn *vconn, struct ofpbuf *request) { - struct vconn *vconn; struct ofpbuf *reply; ofpmsg_update_length(request); - open_vconn(vconn_name, &vconn); - run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name); + run(vconn_transact(vconn, request, &reply), "talking to %s", + vconn_get_name(vconn)); ofp_print(stdout, reply->data, reply->size, verbosity + 1); ofpbuf_delete(reply); - vconn_close(vconn); } static void dump_trivial_transaction(const char *vconn_name, enum ofpraw raw) { struct ofpbuf *request; - request = ofpraw_alloc(raw, OFP10_VERSION, 0); - dump_transaction(vconn_name, request); + struct vconn *vconn; + + open_vconn(vconn_name, &vconn); + request = ofpraw_alloc(raw, vconn_get_version(vconn), 0); + dump_transaction(vconn, request); + vconn_close(vconn); } static void @@ -524,7 +562,8 @@ fetch_switch_config(struct vconn *vconn, struct ofp_switch_config *config_) struct ofpbuf *reply; enum ofptype type; - request = ofpraw_alloc(OFPRAW_OFPT_GET_CONFIG_REQUEST, OFP10_VERSION, 0); + request = ofpraw_alloc(OFPRAW_OFPT_GET_CONFIG_REQUEST, + vconn_get_version(vconn), 0); run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_get_name(vconn)); @@ -543,7 +582,7 @@ set_switch_config(struct vconn *vconn, const struct ofp_switch_config *config) { struct ofpbuf *request; - request = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, OFP10_VERSION, 0); + request = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, vconn_get_version(vconn), 0); ofpbuf_put(request, config, sizeof *config); transact_noreply(vconn, request); @@ -558,15 +597,15 @@ ofctl_show(int argc OVS_UNUSED, char *argv[]) struct ofpbuf *reply; bool trunc; - request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, OFP10_VERSION, 0); 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); trunc = ofputil_switch_features_ports_trunc(reply); ofp_print(stdout, reply->data, reply->size, verbosity + 1); ofpbuf_delete(reply); - vconn_close(vconn); if (trunc) { /* The Features Reply may not contain all the ports, so send a @@ -576,6 +615,7 @@ ofctl_show(int argc OVS_UNUSED, char *argv[]) OFPRAW_OFPST_PORT_DESC_REQUEST); } dump_trivial_transaction(vconn_name, OFPRAW_OFPT_GET_CONFIG_REQUEST); + vconn_close(vconn); } static void @@ -605,8 +645,9 @@ fetch_port_by_features(const char *vconn_name, bool found = false; /* Fetch the switch's ofp_switch_features. */ - request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, OFP10_VERSION, 0); 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); @@ -741,9 +782,9 @@ fetch_ofputil_phy_port(const char *vconn_name, const char *port_name, static uint16_t str_to_port_no(const char *vconn_name, const char *port_name) { - unsigned int port_no; + uint16_t port_no; - if (str_to_uint(port_name, 10, &port_no)) { + if (ofputil_port_from_string(port_name, &port_no)) { return port_no; } else { struct ofputil_phy_port pp; @@ -763,7 +804,7 @@ try_set_protocol(struct vconn *vconn, enum ofputil_protocol want, request = ofputil_encode_set_protocol(*cur, want, &next); if (!request) { - return true; + return *cur == want; } run(vconn_transact_noreply(vconn, request, &reply), @@ -841,8 +882,8 @@ compare_flows(const void *afs_, const void *bfs_) { const struct ofputil_flow_stats *afs = afs_; const struct ofputil_flow_stats *bfs = bfs_; - const struct cls_rule *a = &afs->rule; - const struct cls_rule *b = &bfs->rule; + const struct match *a = &afs->match; + const struct match *b = &bfs->match; const struct sort_criterion *sc; for (sc = criteria; sc < &criteria[n_criteria]; sc++) { @@ -850,7 +891,9 @@ compare_flows(const void *afs_, const void *bfs_) int ret; if (!f) { - ret = a->priority < b->priority ? -1 : a->priority > b->priority; + unsigned int a_pri = afs->priority; + unsigned int b_pri = bfs->priority; + ret = a_pri < b_pri ? -1 : a_pri > b_pri; } else { bool ina, inb; @@ -947,28 +990,24 @@ ofctl_dump_aggregate(int argc, char *argv[]) static void ofctl_queue_stats(int argc, char *argv[]) { - struct ofp10_queue_stats_request *req; struct ofpbuf *request; struct vconn *vconn; + struct ofputil_queue_stats_request oqs; open_vconn(argv[1], &vconn); - request = ofpraw_alloc(OFPRAW_OFPST_QUEUE_REQUEST, - vconn_get_version(vconn), 0); - req = ofpbuf_put_zeros(request, sizeof *req); if (argc > 2 && argv[2][0] && strcasecmp(argv[2], "all")) { - req->port_no = htons(str_to_port_no(argv[1], argv[2])); + oqs.port_no = str_to_port_no(argv[1], argv[2]); } else { - req->port_no = htons(OFPP_ALL); + oqs.port_no = OFPP_ANY; } if (argc > 3 && argv[3][0] && strcasecmp(argv[3], "all")) { - req->queue_id = htonl(atoi(argv[3])); + oqs.queue_id = atoi(argv[3]); } else { - req->queue_id = htonl(OFPQ_ALL); + oqs.queue_id = OFPQ_ALL; } - memset(req->pad, 0, sizeof req->pad); - + request = ofputil_encode_queue_stats_request(vconn_get_version(vconn), &oqs); dump_stats_transaction(vconn, request); vconn_close(vconn); } @@ -1084,7 +1123,10 @@ static void set_packet_in_format(struct vconn *vconn, enum nx_packet_in_format packet_in_format) { - struct ofpbuf *spif = ofputil_make_set_packet_in_format(packet_in_format); + struct ofpbuf *spif; + + spif = ofputil_make_set_packet_in_format(vconn_get_version(vconn), + packet_in_format); transact_noreply(vconn, spif); VLOG_DBG("%s: using user-specified packet in format %s", vconn_get_name(vconn), @@ -1383,18 +1425,32 @@ ofctl_monitor(int argc, char *argv[]) if (preferred_packet_in_format >= 0) { set_packet_in_format(vconn, preferred_packet_in_format); } else { - struct ofpbuf *spif, *reply; - - spif = ofputil_make_set_packet_in_format(NXPIF_NXM); - run(vconn_transact_noreply(vconn, spif, &reply), - "talking to %s", vconn_get_name(vconn)); - if (reply) { - char *s = ofp_to_string(reply->data, reply->size, 2); - VLOG_DBG("%s: failed to set packet in format to nxm, controller" - " replied: %s. Falling back to the switch default.", - vconn_get_name(vconn), s); - free(s); - ofpbuf_delete(reply); + enum ofp_version version = vconn_get_version(vconn); + + switch (version) { + case OFP10_VERSION: { + struct ofpbuf *spif, *reply; + + spif = ofputil_make_set_packet_in_format(vconn_get_version(vconn), + NXPIF_NXM); + run(vconn_transact_noreply(vconn, spif, &reply), + "talking to %s", vconn_get_name(vconn)); + if (reply) { + char *s = ofp_to_string(reply->data, reply->size, 2); + VLOG_DBG("%s: failed to set packet in format to nxm, controller" + " replied: %s. Falling back to the switch default.", + vconn_get_name(vconn), s); + free(s); + ofpbuf_delete(reply); + } + break; + } + case OFP11_VERSION: + case OFP12_VERSION: + case OFP13_VERSION: + break; + default: + NOT_REACHED(); } } @@ -1406,24 +1462,20 @@ ofctl_snoop(int argc OVS_UNUSED, char *argv[]) { struct vconn *vconn; - open_vconn__(argv[1], "snoop", &vconn); + open_vconn__(argv[1], SNOOP, &vconn); monitor_vconn(vconn); } static void ofctl_dump_ports(int argc, char *argv[]) { - struct ofp10_port_stats_request *req; struct ofpbuf *request; struct vconn *vconn; uint16_t port; open_vconn(argv[1], &vconn); - request = ofpraw_alloc(OFPRAW_OFPST_PORT_REQUEST, - vconn_get_version(vconn), 0); - req = ofpbuf_put_zeros(request, sizeof *req); - port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_NONE; - req->port_no = htons(port); + port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_ANY; + request = ofputil_encode_dump_ports_request(vconn_get_version(vconn), port); dump_stats_transaction(vconn, request); vconn_close(vconn); } @@ -1464,9 +1516,7 @@ ofctl_packet_out(int argc, char *argv[]) parse_ofpacts(argv[3], &ofpacts); po.buffer_id = UINT32_MAX; - po.in_port = (!strcasecmp(argv[2], "none") ? OFPP_NONE - : !strcasecmp(argv[2], "local") ? OFPP_LOCAL - : str_to_port_no(argv[1], argv[2])); + po.in_port = str_to_port_no(argv[1], argv[2]); po.ofpacts = ofpacts.data; po.ofpacts_len = ofpacts.size; @@ -1615,8 +1665,8 @@ ofctl_ping(int argc, char *argv[]) const struct ofp_header *rpy_hdr; enum ofptype type; - request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST, OFP10_VERSION, - payload); + request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST, + vconn_get_version(vconn), payload); random_bytes(ofpbuf_put_uninit(request, payload), payload); xgettimeofday(&start); @@ -1670,8 +1720,8 @@ ofctl_benchmark(int argc OVS_UNUSED, char *argv[]) for (i = 0; i < count; i++) { struct ofpbuf *request, *reply; - request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST, OFP10_VERSION, - payload_size); + request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST, + vconn_get_version(vconn), payload_size); ofpbuf_put_zeros(request, payload_size); run(vconn_transact(vconn, request, &reply), "transact"); ofpbuf_delete(reply); @@ -1776,6 +1826,7 @@ fte_free(struct fte *fte) if (fte) { fte_version_free(fte->versions[0]); fte_version_free(fte->versions[1]); + cls_rule_destroy(&fte->rule); free(fte); } } @@ -1801,19 +1852,20 @@ fte_free_all(struct classifier *cls) * * Takes ownership of 'version'. */ static void -fte_insert(struct classifier *cls, const struct cls_rule *rule, - struct fte_version *version, int index) +fte_insert(struct classifier *cls, const struct match *match, + unsigned int priority, struct fte_version *version, int index) { struct fte *old, *fte; fte = xzalloc(sizeof *fte); - fte->rule = *rule; + cls_rule_init(&fte->rule, match, priority); fte->versions[index] = version; old = fte_from_cls_rule(classifier_replace(cls, &fte->rule)); if (old) { fte_version_free(old->versions[index]); fte->versions[!index] = old->versions[!index]; + cls_rule_destroy(&old->rule); free(old); } } @@ -1849,9 +1901,9 @@ read_flows_from_file(const char *filename, struct classifier *cls, int index) version->ofpacts = fm.ofpacts; version->ofpacts_len = fm.ofpacts_len; - usable_protocols &= ofputil_usable_protocols(&fm.cr); + usable_protocols &= ofputil_usable_protocols(&fm.match); - fte_insert(cls, &fm.cr, version, index); + fte_insert(cls, &fm.match, fm.priority, version, index); } ds_destroy(&s); @@ -1931,8 +1983,8 @@ read_flows_from_switch(struct vconn *vconn, ovs_be32 send_xid; fsr.aggregate = false; - cls_rule_init_catchall(&fsr.match, 0); - fsr.out_port = OFPP_NONE; + match_init_catchall(&fsr.match); + fsr.out_port = OFPP_ANY; fsr.table_id = 0xff; fsr.cookie = fsr.cookie_mask = htonll(0); request = ofputil_encode_flow_stats_request(&fsr, protocol); @@ -1952,7 +2004,7 @@ read_flows_from_switch(struct vconn *vconn, version->ofpacts_len = fs.ofpacts_len; version->ofpacts = xmemdup(fs.ofpacts, fs.ofpacts_len); - fte_insert(cls, &fs.rule, version, index); + fte_insert(cls, &fs.match, fs.priority, version, index); } ofpbuf_uninit(&ofpacts); } @@ -1965,7 +2017,8 @@ fte_make_flow_mod(const struct fte *fte, int index, uint16_t command, struct ofputil_flow_mod fm; struct ofpbuf *ofm; - fm.cr = fte->rule; + minimatch_expand(&fte->rule.match, &fm.match); + fm.priority = fte->rule.priority; fm.cookie = htonll(0); fm.cookie_mask = htonll(0); fm.new_cookie = version->cookie; @@ -1974,7 +2027,7 @@ fte_make_flow_mod(const struct fte *fte, int index, uint16_t command, fm.idle_timeout = version->idle_timeout; fm.hard_timeout = version->hard_timeout; fm.buffer_id = UINT32_MAX; - fm.out_port = OFPP_NONE; + fm.out_port = OFPP_ANY; fm.flags = version->flags; if (command == OFPFC_ADD || command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT) { @@ -2129,7 +2182,7 @@ ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms) break; } } - assert(IS_POW2(protocol)); + ovs_assert(is_pow2(protocol)); printf("chosen protocol: %s\n", ofputil_protocol_to_string(protocol)); @@ -2177,7 +2230,7 @@ ofctl_parse_nxm__(bool oxm) ds_init(&in); while (!ds_get_test_line(&in, stdin)) { struct ofpbuf nx_match; - struct cls_rule rule; + struct match match; ovs_be64 cookie, cookie_mask; enum ofperr error; int match_len; @@ -2190,19 +2243,19 @@ ofctl_parse_nxm__(bool oxm) match_len = nx_match_from_string(ds_cstr(&in), &nx_match); } - /* Convert nx_match to cls_rule. */ + /* Convert nx_match to match. */ if (strict) { if (oxm) { - error = oxm_pull_match(&nx_match, 0, &rule); + error = oxm_pull_match(&nx_match, &match); } else { - error = nx_pull_match(&nx_match, match_len, 0, &rule, + error = nx_pull_match(&nx_match, match_len, &match, &cookie, &cookie_mask); } } else { if (oxm) { - error = oxm_pull_match_loose(&nx_match, 0, &rule); + error = oxm_pull_match_loose(&nx_match, &match); } else { - error = nx_pull_match_loose(&nx_match, match_len, 0, &rule, + error = nx_pull_match_loose(&nx_match, match_len, &match, &cookie, &cookie_mask); } } @@ -2211,14 +2264,14 @@ ofctl_parse_nxm__(bool oxm) if (!error) { char *out; - /* Convert cls_rule back to nx_match. */ + /* Convert match back to nx_match. */ ofpbuf_uninit(&nx_match); ofpbuf_init(&nx_match, 0); if (oxm) { - match_len = oxm_put_match(&nx_match, &rule); + match_len = oxm_put_match(&nx_match, &match); out = oxm_match_to_string(nx_match.data, match_len); } else { - match_len = nx_put_match(&nx_match, &rule, + match_len = nx_put_match(&nx_match, &match, cookie, cookie_mask); out = nx_match_to_string(nx_match.data, match_len); } @@ -2354,7 +2407,7 @@ ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) struct ofpbuf match_in, match_expout; struct ofp10_match match_out; struct ofp10_match match_normal; - struct cls_rule rule; + struct match match; char *p; /* Parse hex bytes to use for expected output. */ @@ -2390,18 +2443,17 @@ ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) } /* Convert to cls_rule and print. */ - ofputil_cls_rule_from_ofp10_match(match_in.data, OFP_DEFAULT_PRIORITY, - &rule); - cls_rule_print(&rule); + ofputil_match_from_ofp10_match(match_in.data, &match); + match_print(&match); /* Convert back to ofp10_match and print differences from input. */ - ofputil_cls_rule_to_ofp10_match(&rule, &match_out); + ofputil_match_to_ofp10_match(&match, &match_out); print_differences("", match_expout.data, match_expout.size, &match_out, sizeof match_out); /* Normalize, then convert and compare again. */ - ofputil_normalize_rule(&rule); - ofputil_cls_rule_to_ofp10_match(&rule, &match_normal); + ofputil_normalize_match(&match); + ofputil_match_to_ofp10_match(&match, &match_normal); print_differences("normal: ", &match_out, sizeof match_out, &match_normal, sizeof match_normal); putchar('\n'); @@ -2414,9 +2466,9 @@ ofctl_parse_ofp10_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) } /* "parse-ofp11-match": reads a series of ofp11_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 - * from the input. */ + * bytes from stdin, converts them to "struct match"es, 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_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) { @@ -2426,7 +2478,7 @@ ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) while (!ds_get_preprocessed_line(&in, stdin)) { struct ofpbuf match_in; struct ofp11_match match_out; - struct cls_rule rule; + struct match match; enum ofperr error; /* Parse hex bytes. */ @@ -2439,20 +2491,19 @@ ofctl_parse_ofp11_match(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) match_in.size, sizeof(struct ofp11_match)); } - /* Convert to cls_rule. */ - error = ofputil_cls_rule_from_ofp11_match(match_in.data, - OFP_DEFAULT_PRIORITY, &rule); + /* Convert to match. */ + error = ofputil_match_from_ofp11_match(match_in.data, &match); if (error) { printf("bad ofp11_match: %s\n\n", ofperr_get_name(error)); ofpbuf_uninit(&match_in); continue; } - /* Print cls_rule. */ - cls_rule_print(&rule); + /* Print match. */ + match_print(&match); /* Convert back to ofp11_match and print differences from input. */ - ofputil_cls_rule_to_ofp11_match(&rule, &match_out); + ofputil_match_to_ofp11_match(&match, &match_out); print_differences("", match_in.data, match_in.size, &match_out, sizeof match_out); @@ -2586,71 +2637,71 @@ ofctl_parse_ofp11_instructions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) static void ofctl_check_vlan(int argc OVS_UNUSED, char *argv[]) { - struct cls_rule rule; + struct match match; char *string_s; struct ofputil_flow_mod fm; struct ofpbuf nxm; - struct cls_rule nxm_rule; + struct match nxm_match; int nxm_match_len; char *nxm_s; - struct ofp10_match of10_match; - struct cls_rule of10_rule; + struct ofp10_match of10_raw; + struct match of10_match; - struct ofp11_match of11_match; - struct cls_rule of11_rule; + struct ofp11_match of11_raw; + struct match of11_match; enum ofperr error; - cls_rule_init_catchall(&rule, OFP_DEFAULT_PRIORITY); - rule.flow.vlan_tci = htons(strtoul(argv[1], NULL, 16)); - rule.wc.masks.vlan_tci = htons(strtoul(argv[2], NULL, 16)); + 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)); /* Convert to and from string. */ - string_s = cls_rule_to_string(&rule); + string_s = match_to_string(&match, OFP_DEFAULT_PRIORITY); printf("%s -> ", string_s); fflush(stdout); parse_ofp_str(&fm, -1, string_s, false); printf("%04"PRIx16"/%04"PRIx16"\n", - ntohs(fm.cr.flow.vlan_tci), - ntohs(fm.cr.wc.masks.vlan_tci)); + ntohs(fm.match.flow.vlan_tci), + ntohs(fm.match.wc.masks.vlan_tci)); free(string_s); /* Convert to and from NXM. */ ofpbuf_init(&nxm, 0); - nxm_match_len = nx_put_match(&nxm, &rule, htonll(0), htonll(0)); + nxm_match_len = nx_put_match(&nxm, &match, htonll(0), htonll(0)); nxm_s = nx_match_to_string(nxm.data, nxm_match_len); - error = nx_pull_match(&nxm, nxm_match_len, 0, &nxm_rule, NULL, NULL); + error = nx_pull_match(&nxm, nxm_match_len, &nxm_match, NULL, NULL); printf("NXM: %s -> ", nxm_s); if (error) { printf("%s\n", ofperr_to_string(error)); } else { printf("%04"PRIx16"/%04"PRIx16"\n", - ntohs(nxm_rule.flow.vlan_tci), - ntohs(nxm_rule.wc.masks.vlan_tci)); + ntohs(nxm_match.flow.vlan_tci), + ntohs(nxm_match.wc.masks.vlan_tci)); } free(nxm_s); ofpbuf_uninit(&nxm); /* Convert to and from OXM. */ ofpbuf_init(&nxm, 0); - nxm_match_len = oxm_put_match(&nxm, &rule); + nxm_match_len = oxm_put_match(&nxm, &match); nxm_s = oxm_match_to_string(nxm.data, nxm_match_len); - error = oxm_pull_match(&nxm, 0, &nxm_rule); + error = oxm_pull_match(&nxm, &nxm_match); printf("OXM: %s -> ", nxm_s); if (error) { printf("%s\n", ofperr_to_string(error)); } else { - uint16_t vid = ntohs(nxm_rule.flow.vlan_tci) & + uint16_t vid = ntohs(nxm_match.flow.vlan_tci) & (VLAN_VID_MASK | VLAN_CFI); - uint16_t mask = ntohs(nxm_rule.wc.masks.vlan_tci) & + uint16_t mask = ntohs(nxm_match.wc.masks.vlan_tci) & (VLAN_VID_MASK | VLAN_CFI); printf("%04"PRIx16"/%04"PRIx16",", vid, mask); - if (vid && vlan_tci_to_pcp(nxm_rule.wc.masks.vlan_tci)) { - printf("%02"PRIx8"\n", vlan_tci_to_pcp(nxm_rule.flow.vlan_tci)); + if (vid && vlan_tci_to_pcp(nxm_match.wc.masks.vlan_tci)) { + printf("%02"PRIx8"\n", vlan_tci_to_pcp(nxm_match.flow.vlan_tci)); } else { printf("--\n"); } @@ -2659,26 +2710,26 @@ ofctl_check_vlan(int argc OVS_UNUSED, char *argv[]) ofpbuf_uninit(&nxm); /* Convert to and from OpenFlow 1.0. */ - ofputil_cls_rule_to_ofp10_match(&rule, &of10_match); - ofputil_cls_rule_from_ofp10_match(&of10_match, 0, &of10_rule); + ofputil_match_to_ofp10_match(&match, &of10_raw); + ofputil_match_from_ofp10_match(&of10_raw, &of10_match); printf("OF1.0: %04"PRIx16"/%d,%02"PRIx8"/%d -> %04"PRIx16"/%04"PRIx16"\n", - ntohs(of10_match.dl_vlan), - (of10_match.wildcards & htonl(OFPFW10_DL_VLAN)) != 0, - of10_match.dl_vlan_pcp, - (of10_match.wildcards & htonl(OFPFW10_DL_VLAN_PCP)) != 0, - ntohs(of10_rule.flow.vlan_tci), - ntohs(of10_rule.wc.masks.vlan_tci)); + ntohs(of10_raw.dl_vlan), + (of10_raw.wildcards & htonl(OFPFW10_DL_VLAN)) != 0, + of10_raw.dl_vlan_pcp, + (of10_raw.wildcards & htonl(OFPFW10_DL_VLAN_PCP)) != 0, + ntohs(of10_match.flow.vlan_tci), + ntohs(of10_match.wc.masks.vlan_tci)); /* Convert to and from OpenFlow 1.1. */ - ofputil_cls_rule_to_ofp11_match(&rule, &of11_match); - ofputil_cls_rule_from_ofp11_match(&of11_match, 0, &of11_rule); + ofputil_match_to_ofp11_match(&match, &of11_raw); + ofputil_match_from_ofp11_match(&of11_raw, &of11_match); printf("OF1.1: %04"PRIx16"/%d,%02"PRIx8"/%d -> %04"PRIx16"/%04"PRIx16"\n", - ntohs(of11_match.dl_vlan), - (of11_match.wildcards & htonl(OFPFW11_DL_VLAN)) != 0, - of11_match.dl_vlan_pcp, - (of11_match.wildcards & htonl(OFPFW11_DL_VLAN_PCP)) != 0, - ntohs(of11_rule.flow.vlan_tci), - ntohs(of11_rule.wc.masks.vlan_tci)); + ntohs(of11_raw.dl_vlan), + (of11_raw.wildcards & htonl(OFPFW11_DL_VLAN)) != 0, + of11_raw.dl_vlan_pcp, + (of11_raw.wildcards & htonl(OFPFW11_DL_VLAN_PCP)) != 0, + ntohs(of11_match.flow.vlan_tci), + ntohs(of11_match.wc.masks.vlan_tci)); } /* "print-error ENUM": Prints the type and code of ENUM for every OpenFlow @@ -2706,6 +2757,40 @@ 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[]) +{ + const struct ofp_header *oh; + struct ofpbuf request, *reply; + enum ofperr error; + + error = ofperr_from_name(argv[1]); + if (!error) { + ovs_fatal(0, "unknown error \"%s\"", argv[1]); + } + + ofpbuf_init(&request, 0); + if (ofpbuf_put_hex(&request, argv[2], NULL)[0] != '\0') { + ovs_fatal(0, "Trailing garbage in hex data"); + } + if (request.size < sizeof(struct ofp_header)) { + ovs_fatal(0, "Request too short"); + } + + oh = request.data; + if (request.size != ntohs(oh->length)) { + ovs_fatal(0, "Request size inconsistent"); + } + + reply = ofperr_encode_reply(error, request.data); + ofpbuf_uninit(&request); + + ovs_hex_dump(stdout, reply->data, reply->size, 0, false); + ofpbuf_delete(reply); +} + /* "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). */ @@ -2722,6 +2807,20 @@ ofctl_ofp_print(int argc, char *argv[]) ofpbuf_uninit(&packet); } +/* "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[]) +{ + uint32_t bitmap = strtol(argv[1], NULL, 0); + struct ofpbuf *hello; + + hello = ofputil_encode_hello(bitmap); + ovs_hex_dump(stdout, hello->data, hello->size, 0, false); + ofp_print(stdout, hello->data, hello->size, verbosity); + ofpbuf_delete(hello); +} + static const struct command all_commands[] = { { "show", 1, 1, ofctl_show }, { "monitor", 1, 3, ofctl_monitor }, @@ -2761,7 +2860,9 @@ static const struct command all_commands[] = { { "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 }, };