X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fofp-util.c;h=f99b2b65d9bb3b7db5c53dd0dc64e239df69cbaa;hb=e0ce13c4dc34f44d81e0001882a0be88321b5c87;hp=50dd137194198ba4428706d0560c7c5a8f37e01a;hpb=9b045a0c66e9dfa6dd0266efb023823eefe82045;p=openvswitch diff --git a/lib/ofp-util.c b/lib/ofp-util.c index 50dd1371..f99b2b65 100644 --- a/lib/ofp-util.c +++ b/lib/ofp-util.c @@ -25,6 +25,7 @@ #include "ofpbuf.h" #include "packets.h" #include "random.h" +#include "type-props.h" #include "vlog.h" VLOG_DEFINE_THIS_MODULE(ofp_util); @@ -126,10 +127,10 @@ ofputil_cls_rule_from_match(const struct ofp_match *match, 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 +200,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 +226,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 +362,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 +471,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 +505,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) }; @@ -839,7 +856,7 @@ ofputil_min_flow_format(const struct cls_rule *rule, bool cookie_support, || !regs_fully_wildcarded(wc) || (!(wc->wildcards & FWW_TUN_ID) && (!cookie_support - || (cookie_hi && cookie_hi != rule->flow.tun_id)))) { + || (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; @@ -978,15 +995,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); - if (flow_format != NXFF_TUN_ID_FROM_COOKIE - || fm->cr.wc.wildcards & FWW_TUN_ID) { - ofm->cookie = fm->cookie; - } else { - uint32_t cookie_lo = ntohll(fm->cookie); - uint32_t cookie_hi = ntohl(fm->cr.flow.tun_id); - ofm->cookie = htonll(cookie_lo | ((uint64_t) cookie_hi << 32)); - } + 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); @@ -1123,14 +1133,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; @@ -1426,7 +1439,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; } @@ -1686,6 +1699,7 @@ 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) { @@ -1695,7 +1709,14 @@ check_nicira_action(const union ofp_action *a, unsigned int 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: @@ -1722,6 +1743,11 @@ check_nicira_action(const union ofp_action *a, unsigned int len, case NXAST_NOTE: return 0; + case NXAST_SET_TUNNEL64: + return check_action_exact_len(a, len, + sizeof(struct nx_action_set_tunnel64)); + + case NXAST_SNAT__OBSOLETE: default: return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE); } @@ -1731,9 +1757,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) { @@ -1782,8 +1809,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); } }