X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=utilities%2Fovs-ofctl.c;h=363c0a3a3d44ad18be52c96a3c655216b585563d;hb=c3f2538933e2a7663283158a8bf806bf66ac1a23;hp=e5c52555536e7e2ceae5634785aa9d5fcd4ef539;hpb=df778240e1e311f7eba9dfda4f5f8bf0f915ae5f;p=openvswitch diff --git a/utilities/ovs-ofctl.c b/utilities/ovs-ofctl.c index e5c52555..363c0a3a 100644 --- a/utilities/ovs-ofctl.c +++ b/utilities/ovs-ofctl.c @@ -40,6 +40,7 @@ #include "odp-util.h" #include "ofp-actions.h" #include "ofp-errors.h" +#include "ofp-msgs.h" #include "ofp-parse.h" #include "ofp-print.h" #include "ofp-util.h" @@ -51,6 +52,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" @@ -318,7 +320,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; @@ -330,14 +333,20 @@ 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, 0, vconnp, DSCP_DEFAULT); + if (error && error != ENOENT) { + ovs_fatal(0, "%s: failed to open socket (%s)", name, + strerror(error)); + } free(vconn_name); + + return error; } static enum ofputil_protocol @@ -348,7 +357,7 @@ open_vconn__(const char *name, const char *default_suffix, 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); @@ -359,18 +368,13 @@ open_vconn__(const char *name, const char *default_suffix, free(datapath_type); if (strchr(name, ':')) { - run(vconn_open_block(name, OFP10_VERSION, 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); + run(vconn_open_block(name, 0, vconnp), "connecting to %s", name); + } 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); } @@ -378,6 +382,13 @@ open_vconn__(const char *name, const char *default_suffix, 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) { @@ -393,21 +404,10 @@ open_vconn(const char *name, struct vconn **vconnp) return open_vconn__(name, "mgmt", vconnp); } -static void * -alloc_stats_request(size_t rq_len, uint16_t type, struct ofpbuf **bufferp) -{ - struct ofp_stats_msg *rq; - - rq = make_openflow(rq_len, OFPT10_STATS_REQUEST, bufferp); - rq->type = htons(type); - rq->flags = htons(0); - return rq; -} - static void send_openflow_buffer(struct vconn *vconn, struct ofpbuf *buffer) { - update_openflow_length(buffer); + ofpmsg_update_length(buffer); run(vconn_send_block(vconn, buffer), "failed to send packet to switch"); } @@ -417,7 +417,7 @@ dump_transaction(const char *vconn_name, struct ofpbuf *request) struct vconn *vconn; struct ofpbuf *reply; - update_openflow_length(request); + ofpmsg_update_length(request); open_vconn(vconn_name, &vconn); run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name); ofp_print(stdout, reply->data, reply->size, verbosity + 1); @@ -426,20 +426,26 @@ dump_transaction(const char *vconn_name, struct ofpbuf *request) } static void -dump_trivial_transaction(const char *vconn_name, uint8_t request_type) +dump_trivial_transaction(const char *vconn_name, enum ofpraw raw) { struct ofpbuf *request; - make_openflow(sizeof(struct ofp_header), request_type, &request); + request = ofpraw_alloc(raw, OFP10_VERSION, 0); dump_transaction(vconn_name, request); } static void -dump_stats_transaction__(struct vconn *vconn, struct ofpbuf *request) +dump_stats_transaction(struct vconn *vconn, struct ofpbuf *request) { - ovs_be32 send_xid = ((struct ofp_header *) request->data)->xid; - ovs_be16 stats_type = ((struct ofp_stats_msg *) request->data)->type; + const struct ofp_header *request_oh = request->data; + ovs_be32 send_xid = request_oh->xid; + enum ofpraw request_raw; + enum ofpraw reply_raw; bool done = false; + ofpraw_decode_partial(&request_raw, request->data, request->size); + reply_raw = ofpraw_stats_request_to_reply(request_raw, + request_oh->version); + send_openflow_buffer(vconn, request); while (!done) { ovs_be32 recv_xid; @@ -448,16 +454,15 @@ dump_stats_transaction__(struct vconn *vconn, struct ofpbuf *request) run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed"); recv_xid = ((struct ofp_header *) reply->data)->xid; if (send_xid == recv_xid) { - const struct ofp_stats_msg *osm = reply->data; - const struct ofp_header *oh = reply->data; + enum ofpraw raw; ofp_print(stdout, reply->data, reply->size, verbosity + 1); - if (oh->type == OFPT_ERROR) { + ofpraw_decode(&raw, reply->data); + if (ofptype_from_ofpraw(raw) == OFPTYPE_ERROR) { done = true; - } else if (oh->type == OFPT10_STATS_REPLY - && osm->type == stats_type) { - done = !(ntohs(osm->flags) & OFPSF_REPLY_MORE); + } else if (raw == reply_raw) { + done = !ofpmp_more(reply->data); } else { ovs_fatal(0, "received bad reply: %s", ofp_to_string(reply->data, reply->size, @@ -472,23 +477,17 @@ dump_stats_transaction__(struct vconn *vconn, struct ofpbuf *request) } static void -dump_stats_transaction(const char *vconn_name, struct ofpbuf *request) +dump_trivial_stats_transaction(const char *vconn_name, enum ofpraw raw) { + struct ofpbuf *request; struct vconn *vconn; open_vconn(vconn_name, &vconn); - dump_stats_transaction__(vconn, request); + request = ofpraw_alloc(raw, vconn_get_version(vconn), 0); + dump_stats_transaction(vconn, request); vconn_close(vconn); } -static void -dump_trivial_stats_transaction(const char *vconn_name, uint8_t stats_type) -{ - struct ofpbuf *request; - alloc_stats_request(sizeof(struct ofp_stats_msg), stats_type, &request); - dump_stats_transaction(vconn_name, request); -} - /* 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. @@ -500,7 +499,7 @@ transact_multiple_noreply(struct vconn *vconn, struct list *requests) struct ofpbuf *request, *reply; LIST_FOR_EACH (request, list_node, requests) { - update_openflow_length(request); + ofpmsg_update_length(request); } run(vconn_transact_multiple_noreply(vconn, requests, &reply), @@ -531,38 +530,31 @@ static void fetch_switch_config(struct vconn *vconn, struct ofp_switch_config *config_) { struct ofp_switch_config *config; - struct ofp_header *header; struct ofpbuf *request; struct ofpbuf *reply; + enum ofptype type; - make_openflow(sizeof(struct ofp_header), OFPT_GET_CONFIG_REQUEST, - &request); + request = ofpraw_alloc(OFPRAW_OFPT_GET_CONFIG_REQUEST, OFP10_VERSION, 0); run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_get_name(vconn)); - header = reply->data; - if (header->type != OFPT_GET_CONFIG_REPLY || - header->length != htons(sizeof *config)) { + if (ofptype_pull(&type, reply) || type != OFPTYPE_GET_CONFIG_REPLY) { ovs_fatal(0, "%s: bad reply to config request", vconn_get_name(vconn)); } - config = reply->data; + config = ofpbuf_pull(reply, sizeof *config); *config_ = *config; ofpbuf_delete(reply); } static void -set_switch_config(struct vconn *vconn, struct ofp_switch_config *config_) +set_switch_config(struct vconn *vconn, const struct ofp_switch_config *config) { - struct ofp_switch_config *config; - struct ofp_header save_header; struct ofpbuf *request; - config = make_openflow(sizeof *config, OFPT_SET_CONFIG, &request); - save_header = config->header; - *config = *config_; - config->header = save_header; + request = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, OFP10_VERSION, 0); + ofpbuf_put(request, config, sizeof *config); transact_noreply(vconn, request); } @@ -576,8 +568,7 @@ ofctl_show(int argc OVS_UNUSED, char *argv[]) struct ofpbuf *reply; bool trunc; - make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST, - &request); + request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, OFP10_VERSION, 0); open_vconn(vconn_name, &vconn); run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name); @@ -591,21 +582,22 @@ ofctl_show(int argc OVS_UNUSED, char *argv[]) /* 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, OFPST_PORT_DESC); + dump_trivial_stats_transaction(vconn_name, + OFPRAW_OFPST_PORT_DESC_REQUEST); } - dump_trivial_transaction(vconn_name, OFPT_GET_CONFIG_REQUEST); + dump_trivial_transaction(vconn_name, OFPRAW_OFPT_GET_CONFIG_REQUEST); } static void ofctl_dump_desc(int argc OVS_UNUSED, char *argv[]) { - dump_trivial_stats_transaction(argv[1], OFPST_DESC); + dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_DESC_REQUEST); } static void ofctl_dump_tables(int argc OVS_UNUSED, char *argv[]) { - dump_trivial_stats_transaction(argv[1], OFPST_TABLE); + dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_TABLE_REQUEST); } static bool @@ -614,23 +606,24 @@ fetch_port_by_features(const char *vconn_name, struct ofputil_phy_port *pp, bool *trunc) { struct ofputil_switch_features features; - const struct ofp_switch_features *osf; + 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. */ - make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST, &request); + request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, OFP10_VERSION, 0); open_vconn(vconn_name, &vconn); run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name); vconn_close(vconn); - osf = reply->data; - if (reply->size < sizeof *osf) { - ovs_fatal(0, "%s: received too-short features reply (only %zu bytes)", - vconn_name, reply->size); + oh = reply->data; + if (ofptype_decode(&type, reply->data) + || type != OFPTYPE_FEATURES_REPLY) { + ovs_fatal(0, "%s: received bad features reply", vconn_name); } *trunc = false; @@ -639,13 +632,13 @@ fetch_port_by_features(const char *vconn_name, goto exit; } - error = ofputil_decode_switch_features(osf, &features, &b); + 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)); } - while (!ofputil_pull_phy_port(osf->header.version, &b, pp)) { + while (!ofputil_pull_phy_port(oh->version, &b, pp)) { if (port_no != UINT_MAX ? port_no == pp->port_no : !strcmp(pp->name, port_name)) { @@ -667,12 +660,10 @@ fetch_port_by_stats(const char *vconn_name, struct ofpbuf *request; struct vconn *vconn; ovs_be32 send_xid; - struct ofpbuf b; bool done = false; bool found = false; - alloc_stats_request(sizeof(struct ofp_stats_msg), OFPST_PORT_DESC, - &request); + request = ofpraw_alloc(OFPRAW_OFPST_PORT_DESC_REQUEST, OFP10_VERSION, 0); send_xid = ((struct ofp_header *) request->data)->xid; open_vconn(vconn_name, &vconn); @@ -684,18 +675,21 @@ fetch_port_by_stats(const char *vconn_name, run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed"); recv_xid = ((struct ofp_header *) reply->data)->xid; if (send_xid == recv_xid) { - const struct ofputil_msg_type *type; - struct ofp_stats_msg *osm; - - ofputil_decode_msg_type(reply->data, &type); - if (ofputil_msg_type_code(type) != OFPUTIL_OFPST_PORT_DESC_REPLY) { + struct ofp_header *oh = reply->data; + enum ofptype type; + struct ofpbuf b; + uint16_t flags; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + if (ofptype_pull(&type, &b) + || type != OFPTYPE_PORT_DESC_STATS_REPLY) { ovs_fatal(0, "received bad reply: %s", ofp_to_string(reply->data, reply->size, verbosity + 1)); } - osm = ofpbuf_at_assert(reply, 0, sizeof *osm); - done = !(ntohs(osm->flags) & OFPSF_REPLY_MORE); + flags = ofpmp_flags(oh); + done = !(flags & OFPSF_REPLY_MORE); if (found) { /* We've already found the port, but we need to drain @@ -703,10 +697,7 @@ fetch_port_by_stats(const char *vconn_name, continue; } - ofpbuf_use_const(&b, &osm->header, ntohs(osm->header.length)); - ofpbuf_pull(&b, sizeof(struct ofp_stats_msg)); - - while (!ofputil_pull_phy_port(osm->header.version, &b, pp)) { + while (!ofputil_pull_phy_port(oh->version, &b, pp)) { if (port_no != UINT_MAX ? port_no == pp->port_no : !strcmp(pp->name, port_name)) { found = true; @@ -760,9 +751,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; @@ -782,7 +773,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), @@ -851,7 +842,7 @@ ofctl_dump_flows__(int argc, char *argv[], bool aggregate) struct vconn *vconn; vconn = prepare_dump_flows(argc, argv, aggregate, &request); - dump_stats_transaction__(vconn, request); + dump_stats_transaction(vconn, request); vconn_close(vconn); } @@ -860,8 +851,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++) { @@ -869,7 +860,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; @@ -966,25 +959,26 @@ ofctl_dump_aggregate(int argc, char *argv[]) static void ofctl_queue_stats(int argc, char *argv[]) { - struct ofp_queue_stats_request *req; struct ofpbuf *request; + struct vconn *vconn; + struct ofputil_queue_stats_request oqs; - req = alloc_stats_request(sizeof *req, OFPST_QUEUE, &request); + open_vconn(argv[1], &vconn); 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_ALL; } 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); - - dump_stats_transaction(argv[1], request); + request = ofputil_encode_queue_stats_request(vconn_get_version(vconn), &oqs); + dump_stats_transaction(vconn, request); + vconn_close(vconn); } static enum ofputil_protocol @@ -1098,7 +1092,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), @@ -1228,7 +1225,7 @@ ofctl_barrier(struct unixctl_conn *conn, int argc OVS_UNUSED, return; } - msg = ofputil_encode_barrier_request(); + msg = ofputil_encode_barrier_request(vconn_get_version(aux->vconn)); error = vconn_send_block(aux->vconn, msg); if (error) { ofpbuf_delete(msg); @@ -1318,8 +1315,9 @@ monitor_vconn(struct vconn *vconn) int retval; unixctl_server_run(server); + while (!blocked) { - uint8_t msg_type; + enum ofptype type; retval = vconn_recv(vconn, &b); if (retval == EAGAIN) { @@ -1335,11 +1333,11 @@ monitor_vconn(struct vconn *vconn) fputs(s, stderr); } - msg_type = ((const struct ofp_header *) b->data)->type; + ofptype_decode(&type, b->data); ofp_print(stderr, b->data, b->size, verbosity + 2); ofpbuf_delete(b); - if (barrier_aux.conn && msg_type == OFPT10_BARRIER_REPLY) { + if (barrier_aux.conn && type == OFPTYPE_BARRIER_REPLY) { unixctl_command_reply(barrier_aux.conn, NULL); barrier_aux.conn = NULL; } @@ -1387,7 +1385,7 @@ ofctl_monitor(int argc, char *argv[]) msg = ofpbuf_new(0); ofputil_append_flow_monitor_request(&fmr, msg); - dump_stats_transaction__(vconn, msg); + dump_stats_transaction(vconn, msg); } else { ovs_fatal(0, "%s: unsupported \"monitor\" argument", arg); } @@ -1398,7 +1396,8 @@ ofctl_monitor(int argc, char *argv[]) } else { struct ofpbuf *spif, *reply; - spif = ofputil_make_set_packet_in_format(NXPIF_NXM); + 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) { @@ -1426,20 +1425,21 @@ ofctl_snoop(int argc OVS_UNUSED, char *argv[]) static void ofctl_dump_ports(int argc, char *argv[]) { - struct ofp_port_stats_request *req; struct ofpbuf *request; + struct vconn *vconn; uint16_t port; - req = alloc_stats_request(sizeof *req, OFPST_PORT, &request); + open_vconn(argv[1], &vconn); port = argc > 2 ? str_to_port_no(argv[1], argv[2]) : OFPP_NONE; - req->port_no = htons(port); - dump_stats_transaction(argv[1], request); + 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[]) { - dump_trivial_stats_transaction(argv[1], OFPST_PORT_DESC); + dump_trivial_stats_transaction(argv[1], OFPRAW_OFPST_PORT_DESC_REQUEST); } static void @@ -1449,8 +1449,8 @@ ofctl_probe(int argc OVS_UNUSED, char *argv[]) struct vconn *vconn; struct ofpbuf *reply; - make_openflow(sizeof(struct ofp_header), OFPT_ECHO_REQUEST, &request); open_vconn(argv[1], &vconn); + request = make_echo_request(vconn_get_version(vconn)); run(vconn_transact(vconn, request, &reply), "talking to %s", argv[1]); if (reply->size != sizeof(struct ofp_header)) { ovs_fatal(0, "reply does not match request"); @@ -1462,6 +1462,7 @@ ofctl_probe(int argc OVS_UNUSED, char *argv[]) static void ofctl_packet_out(int argc, char *argv[]) { + enum ofputil_protocol protocol; struct ofputil_packet_out po; struct ofpbuf ofpacts; struct vconn *vconn; @@ -1471,13 +1472,11 @@ 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; - open_vconn(argv[1], &vconn); + protocol = open_vconn(argv[1], &vconn); for (i = 4; i < argc; i++) { struct ofpbuf *packet, *opo; const char *error_msg; @@ -1489,7 +1488,7 @@ ofctl_packet_out(int argc, char *argv[]) po.packet = packet->data; po.packet_len = packet->size; - opo = ofputil_encode_packet_out(&po); + opo = ofputil_encode_packet_out(&po, protocol); transact_noreply(vconn, opo); ofpbuf_delete(packet); } @@ -1619,28 +1618,29 @@ ofctl_ping(int argc, char *argv[]) for (i = 0; i < 10; i++) { struct timeval start, end; struct ofpbuf *request, *reply; - struct ofp_header *rq_hdr, *rpy_hdr; + const struct ofp_header *rpy_hdr; + enum ofptype type; - rq_hdr = make_openflow(sizeof(struct ofp_header) + payload, - OFPT_ECHO_REQUEST, &request); - random_bytes(rq_hdr + 1, payload); + request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST, OFP10_VERSION, + payload); + random_bytes(ofpbuf_put_uninit(request, payload), payload); xgettimeofday(&start); run(vconn_transact(vconn, ofpbuf_clone(request), &reply), "transact"); xgettimeofday(&end); rpy_hdr = reply->data; - if (reply->size != request->size - || memcmp(rpy_hdr + 1, rq_hdr + 1, payload) - || rpy_hdr->xid != rq_hdr->xid - || rpy_hdr->type != OFPT_ECHO_REPLY) { + if (ofptype_pull(&type, reply) + || type != OFPTYPE_ECHO_REPLY + || reply->size != payload + || memcmp(request->l3, reply->l3, 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 - sizeof *rpy_hdr, argv[1], ntohl(rpy_hdr->xid), + reply->size, argv[1], ntohl(rpy_hdr->xid), (1000*(double)(end.tv_sec - start.tv_sec)) + (.001*(end.tv_usec - start.tv_usec))); ofpbuf_delete(request); @@ -1675,10 +1675,10 @@ ofctl_benchmark(int argc OVS_UNUSED, char *argv[]) xgettimeofday(&start); for (i = 0; i < count; i++) { struct ofpbuf *request, *reply; - struct ofp_header *rq_hdr; - rq_hdr = make_openflow(message_size, OFPT_ECHO_REQUEST, &request); - memset(rq_hdr + 1, 0, payload_size); + request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST, OFP10_VERSION, + payload_size); + ofpbuf_put_zeros(request, payload_size); run(vconn_transact(vconn, request, &reply), "transact"); ofpbuf_delete(reply); } @@ -1740,27 +1740,33 @@ fte_version_equals(const struct fte_version *a, const struct fte_version *b) b->ofpacts, b->ofpacts_len)); } -/* Prints 'version' on stdout. Expects the caller to have printed the rule - * associated with the version. */ +/* Clears 's', then if 's' has a version 'index', formats 'fte' and version + * 'index' into 's', followed by a new-line. */ static void -fte_version_print(const struct fte_version *version) +fte_version_format(const struct fte *fte, int index, struct ds *s) { - struct ds s; + const struct fte_version *version = fte->versions[index]; + + ds_clear(s); + if (!version) { + return; + } + cls_rule_format(&fte->rule, s); if (version->cookie != htonll(0)) { - printf(" cookie=0x%"PRIx64, ntohll(version->cookie)); + ds_put_format(s, " cookie=0x%"PRIx64, ntohll(version->cookie)); } if (version->idle_timeout != OFP_FLOW_PERMANENT) { - printf(" idle_timeout=%"PRIu16, version->idle_timeout); + ds_put_format(s, " idle_timeout=%"PRIu16, version->idle_timeout); } if (version->hard_timeout != OFP_FLOW_PERMANENT) { - printf(" hard_timeout=%"PRIu16, version->hard_timeout); + ds_put_format(s, " hard_timeout=%"PRIu16, version->hard_timeout); } - ds_init(&s); - ofpacts_format(version->ofpacts, version->ofpacts_len, &s); - printf(" %s\n", ds_cstr(&s)); - ds_destroy(&s); + ds_put_char(s, ' '); + ofpacts_format(version->ofpacts, version->ofpacts_len, s); + + ds_put_char(s, '\n'); } static struct fte * @@ -1776,6 +1782,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 +1808,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); } } @@ -1845,13 +1853,13 @@ read_flows_from_file(const char *filename, struct classifier *cls, int index) version->cookie = fm.new_cookie; version->idle_timeout = fm.idle_timeout; version->hard_timeout = fm.hard_timeout; - version->flags = fm.flags & (OFPFF_SEND_FLOW_REM | OFPFF_EMERG); + version->flags = fm.flags & (OFPFF_SEND_FLOW_REM | OFPFF10_EMERG); 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); @@ -1870,23 +1878,21 @@ recv_flow_stats_reply(struct vconn *vconn, ovs_be32 send_xid, struct ofpbuf *reply = *replyp; for (;;) { - ovs_be16 flags; int retval; + bool more; /* Get a flow stats reply message, if we don't already have one. */ if (!reply) { - const struct ofputil_msg_type *type; - enum ofputil_msg_code code; + enum ofptype type; + enum ofperr error; do { run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed"); } while (((struct ofp_header *) reply->data)->xid != send_xid); - ofputil_decode_msg_type(reply->data, &type); - code = ofputil_msg_type_code(type); - if (code != OFPUTIL_OFPST_FLOW_REPLY && - code != OFPUTIL_NXST_FLOW_REPLY) { + error = ofptype_decode(&type, reply->data); + if (error || type != OFPTYPE_FLOW_STATS_REPLY) { ovs_fatal(0, "received bad reply: %s", ofp_to_string(reply->data, reply->size, verbosity + 1)); @@ -1901,10 +1907,10 @@ recv_flow_stats_reply(struct vconn *vconn, ovs_be32 send_xid, return true; case EOF: - flags = ((const struct ofp_stats_msg *) reply->l2)->flags; + more = ofpmp_more(reply->l2); ofpbuf_delete(reply); reply = NULL; - if (!(flags & htons(OFPSF_REPLY_MORE))) { + if (!more) { *replyp = NULL; return false; } @@ -1933,7 +1939,7 @@ read_flows_from_switch(struct vconn *vconn, ovs_be32 send_xid; fsr.aggregate = false; - cls_rule_init_catchall(&fsr.match, 0); + match_init_catchall(&fsr.match); fsr.out_port = OFPP_NONE; fsr.table_id = 0xff; fsr.cookie = fsr.cookie_mask = htonll(0); @@ -1954,7 +1960,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); } @@ -1967,7 +1973,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; @@ -2067,33 +2074,39 @@ ofctl_diff_flows(int argc OVS_UNUSED, char *argv[]) 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); + ds_init(&a_s); + ds_init(&b_s); + cls_cursor_init(&cursor, &cls, NULL); CLS_CURSOR_FOR_EACH (fte, rule, &cursor) { struct fte_version *a = fte->versions[0]; struct fte_version *b = fte->versions[1]; if (!a || !b || !fte_version_equals(a, b)) { - char *rule_s = cls_rule_to_string(&fte->rule); - if (a) { - printf("-%s", rule_s); - fte_version_print(a); - } - if (b) { - printf("+%s", rule_s); - fte_version_print(b); + fte_version_format(fte, 0, &a_s); + fte_version_format(fte, 1, &b_s); + if (strcmp(ds_cstr(&a_s), ds_cstr(&b_s))) { + if (a_s.length) { + printf("-%s", ds_cstr(&a_s)); + } + if (b_s.length) { + printf("+%s", ds_cstr(&b_s)); + } + differences = true; } - free(rule_s); - - differences = true; } } + ds_destroy(&a_s); + ds_destroy(&b_s); + fte_free_all(&cls); if (differences) { @@ -2173,35 +2186,52 @@ 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; /* Convert string to nx_match. */ ofpbuf_init(&nx_match, 0); - match_len = nx_match_from_string(ds_cstr(&in), &nx_match); + if (oxm) { + match_len = oxm_match_from_string(ds_cstr(&in), &nx_match); + } else { + match_len = nx_match_from_string(ds_cstr(&in), &nx_match); + } - /* Convert nx_match to cls_rule. */ + /* Convert nx_match to match. */ if (strict) { - error = nx_pull_match(&nx_match, match_len, 0, &rule, - &cookie, &cookie_mask); + if (oxm) { + error = oxm_pull_match(&nx_match, &match); + } else { + error = nx_pull_match(&nx_match, match_len, &match, + &cookie, &cookie_mask); + } } else { - error = nx_pull_match_loose(&nx_match, match_len, 0, &rule, - &cookie, &cookie_mask); + if (oxm) { + error = oxm_pull_match_loose(&nx_match, &match); + } else { + error = nx_pull_match_loose(&nx_match, match_len, &match, + &cookie, &cookie_mask); + } } + 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); - match_len = nx_put_match(&nx_match, oxm, &rule, - cookie, cookie_mask); + if (oxm) { + 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, &match, + cookie, cookie_mask); + out = nx_match_to_string(nx_match.data, match_len); + } - /* Convert nx_match to string. */ - out = nx_match_to_string(nx_match.data, match_len); puts(out); free(out); } else { @@ -2315,20 +2345,50 @@ ofctl_parse_ofp10_actions(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) /* "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 - * from the input. */ + * from the input. + * + * The input hex bytes may contain "x"s to represent "don't-cares", bytes whose + * values are ignored in the input and will be set to zero when OVS converts + * 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) { + struct ds expout; struct ds in; ds_init(&in); + ds_init(&expout); while (!ds_get_preprocessed_line(&in, stdin)) { - struct ofpbuf match_in; + 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. */ + ds_clear(&expout); + ds_put_cstr(&expout, ds_cstr(&in)); + for (p = ds_cstr(&expout); *p; p++) { + if (*p == 'x') { + *p = '0'; + } + } + ofpbuf_init(&match_expout, 0); + if (ofpbuf_put_hex(&match_expout, ds_cstr(&expout), NULL)[0] != '\0') { + 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", + match_expout.size, sizeof(struct ofp10_match)); + } - /* Parse hex bytes. */ + /* Parse hex bytes for input. */ + for (p = ds_cstr(&in); *p; p++) { + if (*p == 'x') { + *p = "0123456789abcdef"[random_uint32() & 0xf]; + } + } ofpbuf_init(&match_in, 0); if (ofpbuf_put_hex(&match_in, ds_cstr(&in), NULL)[0] != '\0') { ovs_fatal(0, "Trailing garbage in hex data"); @@ -2339,31 +2399,32 @@ 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); - print_differences("", match_in.data, match_in.size, + 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'); ofpbuf_uninit(&match_in); + ofpbuf_uninit(&match_expout); } ds_destroy(&in); + ds_destroy(&expout); } /* "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) { @@ -2373,7 +2434,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. */ @@ -2386,20 +2447,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); @@ -2533,74 +2593,99 @@ 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.vlan_tci_mask = 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.vlan_tci_mask)); + 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, false, &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.vlan_tci_mask)); + 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, &match); + nxm_s = oxm_match_to_string(nxm.data, nxm_match_len); + 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_match.flow.vlan_tci) & + (VLAN_VID_MASK | VLAN_CFI); + 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_match.wc.masks.vlan_tci)) { + printf("%02"PRIx8"\n", vlan_tci_to_pcp(nxm_match.flow.vlan_tci)); + } else { + printf("--\n"); + } } free(nxm_s); 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.vlan_tci_mask)); + 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.vlan_tci_mask)); + 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 @@ -2617,17 +2702,14 @@ ofctl_print_error(int argc OVS_UNUSED, char *argv[]) } for (version = 0; version <= UINT8_MAX; version++) { - const struct ofperr_domain *domain; - - domain = ofperr_domain_from_version(version); - if (!domain) { + const char *name = ofperr_domain_get_name(version); + if (!name) { continue; } - printf("%s: %d,%d\n", - ofperr_domain_get_name(domain), - ofperr_get_type(error, domain), - ofperr_get_code(error, domain)); + ofperr_domain_get_name(version), + ofperr_get_type(error, version), + ofperr_get_code(error, version)); } } @@ -2647,6 +2729,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 }, @@ -2687,6 +2783,7 @@ static const struct command all_commands[] = { { "check-vlan", 2, 2, ofctl_check_vlan }, { "print-error", 1, 1, ofctl_print_error }, { "ofp-print", 1, 2, ofctl_ofp_print }, + { "encode-hello", 1, 1, ofctl_encode_hello }, { NULL, 0, 0, NULL }, };