X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-util.c;h=7aea3319e727b0074ac2d77aa713e08f61e51baf;hb=f0e167f0dbadbe2a8d684f63ad9faf68d8cb9884;hp=8cf269a4bc4be5a3be03937240118b87253b3f36;hpb=2e4f5fcf3f5837de6805ccad58cd852a7cca595d;p=sliver-openvswitch.git diff --git a/lib/ofp-util.c b/lib/ofp-util.c index 8cf269a4b..7aea3319e 100644 --- a/lib/ofp-util.c +++ b/lib/ofp-util.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,15 +16,20 @@ #include #include "ofp-print.h" +#include #include #include #include "byte-order.h" #include "classifier.h" +#include "dynamic-string.h" +#include "multipath.h" #include "nx-match.h" +#include "ofp-errors.h" #include "ofp-util.h" #include "ofpbuf.h" #include "packets.h" #include "random.h" +#include "type-props.h" #include "vlog.h" VLOG_DEFINE_THIS_MODULE(ofp_util); @@ -105,7 +110,7 @@ void ofputil_cls_rule_from_match(const struct ofp_match *match, unsigned int priority, enum nx_flow_format flow_format, - uint64_t cookie, struct cls_rule *rule) + ovs_be64 cookie, struct cls_rule *rule) { struct flow_wildcards *wc = &rule->wc; unsigned int ofpfw; @@ -117,19 +122,19 @@ ofputil_cls_rule_from_match(const struct ofp_match *match, rule->priority = !ofpfw ? UINT16_MAX : priority; /* Initialize most of rule->wc. */ + flow_wildcards_init_catchall(wc); wc->wildcards = ofpfw & WC_INVARIANTS; if (ofpfw & OFPFW_NW_TOS) { wc->wildcards |= FWW_NW_TOS; } - memset(wc->reg_masks, 0, sizeof wc->reg_masks); wc->nw_src_mask = ofputil_wcbits_to_netmask(ofpfw >> OFPFW_NW_SRC_SHIFT); wc->nw_dst_mask = ofputil_wcbits_to_netmask(ofpfw >> OFPFW_NW_DST_SHIFT); if (flow_format == NXFF_TUN_ID_FROM_COOKIE && !(ofpfw & NXFW_TUN_ID)) { - rule->flow.tun_id = htonl(ntohll(cookie) >> 32); + rule->flow.tun_id = htonll(ntohll(cookie) >> 32); } else { wc->wildcards |= FWW_TUN_ID; - rule->flow.tun_id = 0; + rule->flow.tun_id = htonll(0); } if (ofpfw & OFPFW_DL_DST) { @@ -199,16 +204,21 @@ ofputil_cls_rule_from_match(const struct ofp_match *match, cls_rule_zero_wildcarded_fields(rule); } -/* Extract 'flow' with 'wildcards' into the OpenFlow match structure - * 'match'. +/* Convert 'rule' into the OpenFlow match structure 'match'. 'flow_format' + * must either NXFF_OPENFLOW10 or NXFF_TUN_ID_FROM_COOKIE. * - * 'flow_format' must either NXFF_OPENFLOW10 or NXFF_TUN_ID_FROM_COOKIE. In - * the latter case only, 'match''s NXFW_TUN_ID bit will be filled in; otherwise - * it is always set to 0. */ + * The NXFF_TUN_ID_FROM_COOKIE flow format requires modifying the flow cookie. + * This function can help with that, if 'cookie_out' is nonnull. For + * NXFF_OPENFLOW10, or if the tunnel ID is wildcarded, 'cookie_in' will be + * copied directly to '*cookie_out'. For NXFF_TUN_ID_FROM_COOKIE when tunnel + * ID is matched, 'cookie_in' will be modified appropriately before setting + * '*cookie_out'. + */ void ofputil_cls_rule_to_match(const struct cls_rule *rule, enum nx_flow_format flow_format, - struct ofp_match *match) + struct ofp_match *match, + ovs_be64 cookie_in, ovs_be64 *cookie_out) { const struct flow_wildcards *wc = &rule->wc; unsigned int ofpfw; @@ -220,8 +230,19 @@ ofputil_cls_rule_to_match(const struct cls_rule *rule, if (wc->wildcards & FWW_NW_TOS) { ofpfw |= OFPFW_NW_TOS; } - if (flow_format == NXFF_TUN_ID_FROM_COOKIE && wc->wildcards & FWW_TUN_ID) { - ofpfw |= NXFW_TUN_ID; + + /* Tunnel ID. */ + if (flow_format == NXFF_TUN_ID_FROM_COOKIE) { + if (wc->wildcards & FWW_TUN_ID) { + ofpfw |= NXFW_TUN_ID; + } else { + uint32_t cookie_lo = ntohll(cookie_in); + uint32_t cookie_hi = ntohll(rule->flow.tun_id); + cookie_in = htonll(cookie_lo | ((uint64_t) cookie_hi << 32)); + } + } + if (cookie_out) { + *cookie_out = cookie_in; } /* Translate VLANs. */ @@ -345,7 +366,7 @@ ofputil_lookup_openflow_message(const struct ofputil_msg_category *cat, } } - VLOG_WARN_RL(&bad_ofmsg_rl, "received %s of unknown type %u", + VLOG_WARN_RL(&bad_ofmsg_rl, "received %s of unknown type %"PRIu32, cat->name, value); return cat->missing_error; } @@ -454,7 +475,7 @@ ofputil_decode_nxst_request(const struct ofp_header *oh, }; static const struct ofputil_msg_category nxst_request_category = { - "Nicira extension statistics", + "Nicira extension statistics request", nxst_requests, ARRAY_SIZE(nxst_requests), OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE) }; @@ -488,7 +509,7 @@ ofputil_decode_nxst_reply(const struct ofp_header *oh, }; static const struct ofputil_msg_category nxst_reply_category = { - "Nicira extension statistics", + "Nicira extension statistics reply", nxst_replies, ARRAY_SIZE(nxst_replies), OFP_MKERR(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE) }; @@ -756,9 +777,128 @@ ofputil_msg_type_code(const struct ofputil_msg_type *type) return type->code; } -/* Converts an OFPT_FLOW_MOD or NXT_FLOW_MOD message 'oh', received when the - * current flow format was 'flow_format', into an abstract flow_mod in 'fm'. - * Returns 0 if successful, otherwise an OpenFlow error code. +/* Flow formats. */ + +bool +ofputil_flow_format_is_valid(enum nx_flow_format flow_format) +{ + switch (flow_format) { + case NXFF_OPENFLOW10: + case NXFF_TUN_ID_FROM_COOKIE: + case NXFF_NXM: + return true; + } + + return false; +} + +const char * +ofputil_flow_format_to_string(enum nx_flow_format flow_format) +{ + switch (flow_format) { + case NXFF_OPENFLOW10: + return "openflow10"; + case NXFF_TUN_ID_FROM_COOKIE: + return "tun_id_from_cookie"; + case NXFF_NXM: + return "nxm"; + default: + NOT_REACHED(); + } +} + +int +ofputil_flow_format_from_string(const char *s) +{ + return (!strcmp(s, "openflow10") ? NXFF_OPENFLOW10 + : !strcmp(s, "tun_id_from_cookie") ? NXFF_TUN_ID_FROM_COOKIE + : !strcmp(s, "nxm") ? NXFF_NXM + : -1); +} + +static bool +regs_fully_wildcarded(const struct flow_wildcards *wc) +{ + int i; + + for (i = 0; i < FLOW_N_REGS; i++) { + if (wc->reg_masks[i] != 0) { + return false; + } + } + return true; +} + +/* Returns the minimum nx_flow_format to use for sending 'rule' to a switch + * (e.g. to add or remove a flow). 'cookie_support' should be true if the + * command to be sent includes a flow cookie (as OFPT_FLOW_MOD does, for + * example) or false if the command does not (OFPST_FLOW and OFPST_AGGREGATE do + * not, for example). If 'cookie_support' is true, then 'cookie' should be the + * cookie to be sent; otherwise its value is ignored. + * + * The "best" flow format is chosen on this basis: + * + * - It must be capable of expressing the rule. NXFF_OPENFLOW10 flows can't + * handle tunnel IDs. NXFF_TUN_ID_FROM_COOKIE flows can't handle registers + * or fixing the Ethernet multicast bit, and can't handle tunnel IDs that + * conflict with the high 32 bits of the cookie or commands that don't + * support cookies. + * + * - Otherwise, the chosen format should be as backward compatible as + * possible. (NXFF_OPENFLOW10 is more backward compatible than + * NXFF_TUN_ID_FROM_COOKIE, which is more backward compatible than + * NXFF_NXM.) + */ +enum nx_flow_format +ofputil_min_flow_format(const struct cls_rule *rule, bool cookie_support, + ovs_be64 cookie) +{ + const struct flow_wildcards *wc = &rule->wc; + ovs_be32 cookie_hi = htonl(ntohll(cookie) >> 32); + + if (!(wc->wildcards & FWW_DL_DST) != !(wc->wildcards & FWW_ETH_MCAST) + || !regs_fully_wildcarded(wc) + || (!(wc->wildcards & FWW_TUN_ID) + && (!cookie_support + || (cookie_hi && cookie_hi != ntohll(rule->flow.tun_id))))) { + return NXFF_NXM; + } else if (!(wc->wildcards & FWW_TUN_ID)) { + return NXFF_TUN_ID_FROM_COOKIE; + } else { + return NXFF_OPENFLOW10; + } +} + +/* Returns an OpenFlow message that can be used to set the flow format to + * 'flow_format'. */ +struct ofpbuf * +ofputil_make_set_flow_format(enum nx_flow_format flow_format) +{ + struct ofpbuf *msg; + + if (flow_format == NXFF_OPENFLOW10 + || flow_format == NXFF_TUN_ID_FROM_COOKIE) { + struct nxt_tun_id_cookie *tic; + + tic = make_nxmsg(sizeof *tic, NXT_TUN_ID_FROM_COOKIE, &msg); + tic->set = flow_format == NXFF_TUN_ID_FROM_COOKIE; + } else { + struct nxt_set_flow_format *sff; + + sff = make_nxmsg(sizeof *sff, NXT_SET_FLOW_FORMAT, &msg); + sff->format = htonl(flow_format); + } + + return msg; +} + +/* Converts an OFPT_FLOW_MOD or NXT_FLOW_MOD message 'oh' into an abstract + * flow_mod in 'fm'. Returns 0 if successful, otherwise an OpenFlow error + * code. + * + * For OFPT_FLOW_MOD messages, 'flow_format' should be the current flow format + * at the time when the message was received. Otherwise 'flow_format' is + * ignored. * * Does not validate the flow_mod actions. */ int @@ -768,8 +908,7 @@ ofputil_decode_flow_mod(struct flow_mod *fm, const struct ofp_header *oh, const struct ofputil_msg_type *type; struct ofpbuf b; - b.data = (void *) oh; - b.size = ntohs(oh->length); + ofpbuf_use_const(&b, oh, ntohs(oh->length)); ofputil_decode_msg_type(oh, &type); if (ofputil_msg_type_code(type) == OFPUTIL_OFPT_FLOW_MOD) { @@ -779,10 +918,7 @@ ofputil_decode_flow_mod(struct flow_mod *fm, const struct ofp_header *oh, int error; /* Dissect the message. */ - ofm = ofpbuf_try_pull(&b, sizeof *ofm); - if (!ofm) { - return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); - } + ofm = ofpbuf_pull(&b, sizeof *ofm); error = ofputil_pull_actions(&b, b.size, &fm->actions, &fm->n_actions); if (error) { return error; @@ -822,10 +958,7 @@ ofputil_decode_flow_mod(struct flow_mod *fm, const struct ofp_header *oh, int error; /* Dissect the message. */ - nfm = ofpbuf_try_pull(&b, sizeof *nfm); - if (!nfm) { - return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); - } + nfm = ofpbuf_pull(&b, sizeof *nfm); error = nx_pull_match(&b, ntohs(nfm->match_len), ntohs(nfm->priority), &fm->cr); if (error) { @@ -866,8 +999,8 @@ ofputil_encode_flow_mod(const struct flow_mod *fm, msg = ofpbuf_new(sizeof *ofm + actions_len); ofm = put_openflow(sizeof *ofm, OFPT_FLOW_MOD, msg); - ofputil_cls_rule_to_match(&fm->cr, flow_format, &ofm->match); - ofm->cookie = fm->cookie; + ofputil_cls_rule_to_match(&fm->cr, flow_format, &ofm->match, + fm->cookie, &ofm->cookie); ofm->command = htons(fm->command); ofm->idle_timeout = htons(fm->idle_timeout); ofm->hard_timeout = htons(fm->hard_timeout); @@ -927,13 +1060,9 @@ ofputil_decode_nxst_flow_request(struct flow_stats_request *fsr, struct ofpbuf b; int error; - b.data = (void *) oh; - b.size = ntohs(oh->length); + ofpbuf_use_const(&b, oh, ntohs(oh->length)); - nfsr = ofpbuf_try_pull(&b, sizeof *nfsr); - if (!nfsr) { - return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); - } + nfsr = ofpbuf_pull(&b, sizeof *nfsr); error = nx_pull_match(&b, ntohs(nfsr->match_len), 0, &fsr->match); if (error) { return error; @@ -952,7 +1081,11 @@ ofputil_decode_nxst_flow_request(struct flow_stats_request *fsr, /* Converts an OFPST_FLOW, OFPST_AGGREGATE, NXST_FLOW, or NXST_AGGREGATE * message 'oh', received when the current flow format was 'flow_format', into * an abstract flow_stats_request in 'fsr'. Returns 0 if successful, otherwise - * an OpenFlow error code. */ + * an OpenFlow error code. + * + * For OFPST_FLOW and OFPST_AGGREGATE messages, 'flow_format' should be the + * current flow format at the time when the message was received. Otherwise + * 'flow_format' is ignored. */ int ofputil_decode_flow_stats_request(struct flow_stats_request *fsr, const struct ofp_header *oh, @@ -962,8 +1095,7 @@ ofputil_decode_flow_stats_request(struct flow_stats_request *fsr, struct ofpbuf b; int code; - b.data = (void *) oh; - b.size = ntohs(oh->length); + ofpbuf_use_const(&b, oh, ntohs(oh->length)); ofputil_decode_msg_type(oh, &type); code = ofputil_msg_type_code(type); @@ -1005,14 +1137,17 @@ ofputil_encode_flow_stats_request(const struct flow_stats_request *fsr, type = fsr->aggregate ? OFPST_AGGREGATE : OFPST_FLOW; ofsr = ofputil_make_stats_request(sizeof *ofsr, type, &msg); - ofputil_cls_rule_to_match(&fsr->match, flow_format, &ofsr->match); + ofputil_cls_rule_to_match(&fsr->match, flow_format, &ofsr->match, + 0, NULL); ofsr->table_id = fsr->table_id; ofsr->out_port = htons(fsr->out_port); } else if (flow_format == NXFF_NXM) { struct nx_flow_stats_request *nfsr; int match_len; + int subtype; - ofputil_make_nxstats_request(sizeof *nfsr, NXST_FLOW, &msg); + subtype = fsr->aggregate ? NXST_AGGREGATE : NXST_FLOW; + ofputil_make_nxstats_request(sizeof *nfsr, subtype, &msg); match_len = nx_put_match(msg, &fsr->match); nfsr = msg->data; @@ -1026,6 +1161,68 @@ ofputil_encode_flow_stats_request(const struct flow_stats_request *fsr, return msg; } +/* Converts an OFPT_FLOW_REMOVED or NXT_FLOW_REMOVED message 'oh', received + * when the current flow format was 'flow_format', into an abstract + * ofputil_flow_removed in 'fr'. Returns 0 if successful, otherwise an + * OpenFlow error code. + * + * For OFPT_FLOW_REMOVED messages, 'flow_format' should be the current flow + * format at the time when the message was received. Otherwise 'flow_format' + * is ignored. */ +int +ofputil_decode_flow_removed(struct ofputil_flow_removed *fr, + const struct ofp_header *oh, + enum nx_flow_format flow_format) +{ + const struct ofputil_msg_type *type; + enum ofputil_msg_code code; + + ofputil_decode_msg_type(oh, &type); + code = ofputil_msg_type_code(type); + if (code == OFPUTIL_OFPT_FLOW_REMOVED) { + const struct ofp_flow_removed *ofr; + + ofr = (const struct ofp_flow_removed *) oh; + ofputil_cls_rule_from_match(&ofr->match, ntohs(ofr->priority), + flow_format, ofr->cookie, &fr->rule); + fr->cookie = ofr->cookie; + fr->reason = ofr->reason; + fr->duration_sec = ntohl(ofr->duration_sec); + fr->duration_nsec = ntohl(ofr->duration_nsec); + fr->idle_timeout = ntohs(ofr->idle_timeout); + fr->packet_count = ntohll(ofr->packet_count); + fr->byte_count = ntohll(ofr->byte_count); + } else if (code == OFPUTIL_NXT_FLOW_REMOVED) { + struct nx_flow_removed *nfr; + struct ofpbuf b; + int error; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + + nfr = ofpbuf_pull(&b, sizeof *nfr); + error = nx_pull_match(&b, ntohs(nfr->match_len), ntohs(nfr->priority), + &fr->rule); + if (error) { + return error; + } + if (b.size) { + return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); + } + + fr->cookie = nfr->cookie; + fr->reason = nfr->reason; + fr->duration_sec = ntohl(nfr->duration_sec); + fr->duration_nsec = ntohl(nfr->duration_nsec); + fr->idle_timeout = ntohs(nfr->idle_timeout); + fr->packet_count = ntohll(nfr->packet_count); + fr->byte_count = ntohll(nfr->byte_count); + } else { + NOT_REACHED(); + } + + return 0; +} + /* Returns a string representing the message type of 'type'. The string is the * enumeration constant for the type, e.g. "OFPT_HELLO". For statistics * messages, the constant is followed by "request" or "reply", @@ -1217,6 +1414,22 @@ ofputil_stats_body_len(const struct ofp_header *oh) return ntohs(oh->length) - sizeof(struct ofp_stats_request); } +/* Returns the first byte of the body of the nicira_stats_msg in 'oh'. */ +const void * +ofputil_nxstats_body(const struct ofp_header *oh) +{ + assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY); + return ((const struct nicira_stats_msg *) oh) + 1; +} + +/* Returns the length of the body of the nicira_stats_msg in 'oh'. */ +size_t +ofputil_nxstats_body_len(const struct ofp_header *oh) +{ + assert(oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY); + return ntohs(oh->length) - sizeof(struct nicira_stats_msg); +} + struct ofpbuf * make_flow_mod(uint16_t command, const struct cls_rule *rule, size_t actions_len) @@ -1230,7 +1443,7 @@ make_flow_mod(uint16_t command, const struct cls_rule *rule, ofm->header.length = htons(size); ofm->cookie = 0; ofm->priority = htons(MIN(rule->priority, UINT16_MAX)); - ofputil_cls_rule_to_match(rule, NXFF_OPENFLOW10, &ofm->match); + ofputil_cls_rule_to_match(rule, NXFF_OPENFLOW10, &ofm->match, 0, NULL); ofm->command = htons(command); return out; } @@ -1427,9 +1640,23 @@ check_action_exact_len(const union ofp_action *a, unsigned int len, unsigned int required_len) { if (len != required_len) { - VLOG_DBG_RL(&bad_ofmsg_rl, - "action %u has invalid length %"PRIu16" (must be %u)\n", - a->type, ntohs(a->header.len), required_len); + VLOG_WARN_RL(&bad_ofmsg_rl, "action %"PRIu16" has invalid length " + "%"PRIu16" (must be %u)\n", + ntohs(a->type), ntohs(a->header.len), required_len); + return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); + } + return 0; +} + +static int +check_nx_action_exact_len(const struct nx_action_header *a, + unsigned int len, unsigned int required_len) +{ + if (len != required_len) { + VLOG_WARN_RL(&bad_ofmsg_rl, + "Nicira action %"PRIu16" has invalid length %"PRIu16" " + "(must be %u)\n", + ntohs(a->subtype), ntohs(a->len), required_len); return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } return 0; @@ -1490,34 +1717,42 @@ check_nicira_action(const union ofp_action *a, unsigned int len, const struct flow *flow) { const struct nx_action_header *nah; + uint16_t subtype; int error; if (len < 16) { - VLOG_DBG_RL(&bad_ofmsg_rl, - "Nicira vendor action only %u bytes", len); + VLOG_WARN_RL(&bad_ofmsg_rl, + "Nicira vendor action only %u bytes", len); return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } nah = (const struct nx_action_header *) a; - switch (ntohs(nah->subtype)) { + subtype = ntohs(nah->subtype); + if (subtype > TYPE_MAXIMUM(enum nx_action_subtype)) { + /* This is necessary because enum nx_action_subtype is probably an + * 8-bit type, so the cast below throws away the top 8 bits. */ + return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE); + } + + switch ((enum nx_action_subtype) subtype) { case NXAST_RESUBMIT: case NXAST_SET_TUNNEL: case NXAST_DROP_SPOOFED_ARP: case NXAST_SET_QUEUE: case NXAST_POP_QUEUE: - return check_action_exact_len(a, len, 16); + return check_nx_action_exact_len(nah, len, 16); case NXAST_REG_MOVE: - error = check_action_exact_len(a, len, - sizeof(struct nx_action_reg_move)); + error = check_nx_action_exact_len(nah, len, + sizeof(struct nx_action_reg_move)); if (error) { return error; } return nxm_check_reg_move((const struct nx_action_reg_move *) a, flow); case NXAST_REG_LOAD: - error = check_action_exact_len(a, len, - sizeof(struct nx_action_reg_load)); + error = check_nx_action_exact_len(nah, len, + sizeof(struct nx_action_reg_load)); if (error) { return error; } @@ -1526,7 +1761,23 @@ check_nicira_action(const union ofp_action *a, unsigned int len, case NXAST_NOTE: return 0; + case NXAST_SET_TUNNEL64: + return check_nx_action_exact_len( + nah, len, sizeof(struct nx_action_set_tunnel64)); + + case NXAST_MULTIPATH: + error = check_nx_action_exact_len( + nah, len, sizeof(struct nx_action_multipath)); + if (error) { + return error; + } + return multipath_check((const struct nx_action_multipath *) a); + + case NXAST_SNAT__OBSOLETE: default: + VLOG_WARN_RL(&bad_ofmsg_rl, + "unknown Nicira vendor action subtype %"PRIu16, + ntohs(nah->subtype)); return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE); } } @@ -1535,9 +1786,10 @@ static int check_action(const union ofp_action *a, unsigned int len, const struct flow *flow, int max_ports) { + enum ofp_action_type type = ntohs(a->type); int error; - switch (ntohs(a->type)) { + switch (type) { case OFPAT_OUTPUT: error = check_action_exact_len(a, len, 8); if (error) { @@ -1586,8 +1838,7 @@ check_action(const union ofp_action *a, unsigned int len, return check_enqueue_action(a, len, max_ports); default: - VLOG_WARN_RL(&bad_ofmsg_rl, "unknown action type %"PRIu16, - ntohs(a->type)); + VLOG_WARN_RL(&bad_ofmsg_rl, "unknown action type %d", (int) type); return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE); } } @@ -1606,16 +1857,16 @@ validate_actions(const union ofp_action *actions, size_t n_actions, int error; if (n_slots > slots_left) { - VLOG_DBG_RL(&bad_ofmsg_rl, - "action requires %u slots but only %u remain", - n_slots, slots_left); + VLOG_WARN_RL(&bad_ofmsg_rl, + "action requires %u slots but only %u remain", + n_slots, slots_left); return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } else if (!len) { - VLOG_DBG_RL(&bad_ofmsg_rl, "action has invalid length 0"); + VLOG_WARN_RL(&bad_ofmsg_rl, "action has invalid length 0"); return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } else if (len % OFP_ACTION_ALIGN) { - VLOG_DBG_RL(&bad_ofmsg_rl, "action length %u is not a multiple " - "of %d", len, OFP_ACTION_ALIGN); + VLOG_WARN_RL(&bad_ofmsg_rl, "action length %u is not a multiple " + "of %d", len, OFP_ACTION_ALIGN); return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } @@ -1795,6 +2046,18 @@ vendor_code_to_id(uint8_t code) } } +static int +vendor_id_to_code(uint32_t id) +{ + switch (id) { +#define OFPUTIL_VENDOR(NAME, VENDOR_ID) case VENDOR_ID: return NAME; + OFPUTIL_VENDORS +#undef OFPUTIL_VENDOR + default: + return -1; + } +} + /* Creates and returns an OpenFlow message of type OFPT_ERROR with the error * information taken from 'error', whose encoding must be as described in the * large comment in ofp-util.h. If 'oh' is nonnull, then the error will use @@ -1803,7 +2066,7 @@ vendor_code_to_id(uint8_t code) * * Returns NULL if 'error' is not an OpenFlow error code. */ struct ofpbuf * -make_ofp_error_msg(int error, const struct ofp_header *oh) +ofputil_encode_error_msg(int error, const struct ofp_header *oh) { static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); @@ -1862,19 +2125,116 @@ make_ofp_error_msg(int error, const struct ofp_header *oh) oem->type = htons(NXET_VENDOR); oem->code = htons(NXVC_VENDOR_ERROR); - nve = ofpbuf_put_uninit(buf, sizeof *nve); + nve = (struct nx_vendor_error *)oem->data; nve->vendor = htonl(vendor_id); nve->type = htons(type); nve->code = htons(code); } if (len) { + buf->size -= len; ofpbuf_put(buf, data, len); } return buf; } +/* Decodes 'oh', which should be an OpenFlow OFPT_ERROR message, and returns an + * Open vSwitch internal error code in the format described in the large + * comment in ofp-util.h. + * + * If 'payload_ofs' is nonnull, on success '*payload_ofs' is set to the offset + * to the payload starting from 'oh' and on failure it is set to 0. */ +int +ofputil_decode_error_msg(const struct ofp_header *oh, size_t *payload_ofs) +{ + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); + + const struct ofp_error_msg *oem; + uint16_t type, code; + struct ofpbuf b; + int vendor; + + if (payload_ofs) { + *payload_ofs = 0; + } + if (oh->type != OFPT_ERROR) { + return EPROTO; + } + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + oem = ofpbuf_try_pull(&b, sizeof *oem); + if (!oem) { + return EPROTO; + } + + type = ntohs(oem->type); + code = ntohs(oem->code); + if (type == NXET_VENDOR && code == NXVC_VENDOR_ERROR) { + const struct nx_vendor_error *nve = ofpbuf_try_pull(&b, sizeof *nve); + if (!nve) { + return EPROTO; + } + + vendor = vendor_id_to_code(ntohl(nve->vendor)); + if (vendor < 0) { + VLOG_WARN_RL(&rl, "error contains unknown vendor ID %#"PRIx32, + ntohl(nve->vendor)); + return EPROTO; + } + type = ntohs(nve->type); + code = ntohs(nve->code); + } else { + vendor = OFPUTIL_VENDOR_OPENFLOW; + } + + if (type >= 1024) { + VLOG_WARN_RL(&rl, "error contains type %"PRIu16" greater than " + "supported maximum value 1023", type); + return EPROTO; + } + + if (payload_ofs) { + *payload_ofs = (uint8_t *) b.data - (uint8_t *) oh; + } + return ofp_mkerr_vendor(vendor, type, code); +} + +void +ofputil_format_error(struct ds *s, int error) +{ + if (is_errno(error)) { + ds_put_cstr(s, strerror(error)); + } else { + uint16_t type = get_ofp_err_type(error); + uint16_t code = get_ofp_err_code(error); + const char *type_s = ofp_error_type_to_string(type); + const char *code_s = ofp_error_code_to_string(type, code); + + ds_put_format(s, "type "); + if (type_s) { + ds_put_cstr(s, type_s); + } else { + ds_put_format(s, "%"PRIu16, type); + } + + ds_put_cstr(s, ", code "); + if (code_s) { + ds_put_cstr(s, code_s); + } else { + ds_put_format(s, "%"PRIu16, code); + } + } +} + +char * +ofputil_error_to_string(int error) +{ + struct ds s = DS_EMPTY_INITIALIZER; + ofputil_format_error(&s, error); + return ds_steal_cstr(&s); +} + /* Attempts to pull 'actions_len' bytes from the front of 'b'. Returns 0 if * successful, otherwise an OpenFlow error. * @@ -1891,16 +2251,16 @@ ofputil_pull_actions(struct ofpbuf *b, unsigned int actions_len, union ofp_action **actionsp, size_t *n_actionsp) { if (actions_len % OFP_ACTION_ALIGN != 0) { - VLOG_DBG_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u " - "is not a multiple of %d", actions_len, OFP_ACTION_ALIGN); + VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u " + "is not a multiple of %d", actions_len, OFP_ACTION_ALIGN); goto error; } *actionsp = ofpbuf_try_pull(b, actions_len); if (*actionsp == NULL) { - VLOG_DBG_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u " - "exceeds remaining message length (%zu)", - actions_len, b->size); + VLOG_WARN_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u " + "exceeds remaining message length (%zu)", + actions_len, b->size); goto error; }