X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-util.c;h=90f4f35f416f75067329ba3f4a9fa044a3a2be3f;hb=4e022ec09e14;hp=40983504ec917b6c5e70e9fbb97964e0fded69f2;hpb=a6b112a8b31fdf56a73cb539c0ab41672fc71712;p=sliver-openvswitch.git diff --git a/lib/ofp-util.c b/lib/ofp-util.c index 40983504e..90f4f35f4 100644 --- a/lib/ofp-util.c +++ b/lib/ofp-util.c @@ -23,7 +23,6 @@ #include #include #include -#include "autopath.h" #include "bundle.h" #include "byte-order.h" #include "classifier.h" @@ -85,13 +84,13 @@ ofputil_netmask_to_wcbits(ovs_be32 netmask) void ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc) { - BUILD_ASSERT_DECL(FLOW_WC_SEQ == 18); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 20); /* Initialize most of wc. */ flow_wildcards_init_catchall(wc); if (!(ofpfw & OFPFW10_IN_PORT)) { - wc->masks.in_port = UINT16_MAX; + wc->masks.in_port.ofp_port = u16_to_ofp(UINT16_MAX); } if (!(ofpfw & OFPFW10_NW_TOS)) { @@ -146,7 +145,7 @@ ofputil_match_from_ofp10_match(const struct ofp10_match *ofmatch, /* Initialize most of match->flow. */ match->flow.nw_src = ofmatch->nw_src; match->flow.nw_dst = ofmatch->nw_dst; - match->flow.in_port = ntohs(ofmatch->in_port); + match->flow.in_port.ofp_port = u16_to_ofp(ntohs(ofmatch->in_port)); match->flow.dl_type = ofputil_dl_type_from_openflow(ofmatch->dl_type); match->flow.tp_src = ofmatch->tp_src; match->flow.tp_dst = ofmatch->tp_dst; @@ -191,7 +190,7 @@ ofputil_match_to_ofp10_match(const struct match *match, /* Figure out most OpenFlow wildcards. */ ofpfw = 0; - if (!wc->masks.in_port) { + if (!wc->masks.in_port.ofp_port) { ofpfw |= OFPFW10_IN_PORT; } if (!wc->masks.dl_type) { @@ -245,7 +244,7 @@ ofputil_match_to_ofp10_match(const struct match *match, /* Compose most of the match structure. */ ofmatch->wildcards = htonl(ofpfw); - ofmatch->in_port = htons(match->flow.in_port); + ofmatch->in_port = htons(ofp_to_u16(match->flow.in_port.ofp_port)); memcpy(ofmatch->dl_src, match->flow.dl_src, ETH_ADDR_LEN); memcpy(ofmatch->dl_dst, match->flow.dl_dst, ETH_ADDR_LEN); ofmatch->dl_type = ofputil_dl_type_to_openflow(match->flow.dl_type); @@ -312,7 +311,7 @@ ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch, match_init_catchall(match); if (!(wc & OFPFW11_IN_PORT)) { - uint16_t ofp_port; + ofp_port_t ofp_port; enum ofperr error; error = ofputil_port_from_ofp11(ofmatch->in_port, &ofp_port); @@ -440,8 +439,7 @@ ofputil_match_from_ofp11_match(const struct ofp11_match *ofmatch, } } - if (match->flow.dl_type == htons(ETH_TYPE_MPLS) || - match->flow.dl_type == htons(ETH_TYPE_MPLS_MCAST)) { + if (eth_type_mpls(match->flow.dl_type)) { enum { OFPFW11_MPLS_ALL = OFPFW11_MPLS_LABEL | OFPFW11_MPLS_TC }; if ((wc & OFPFW11_MPLS_ALL) != OFPFW11_MPLS_ALL) { @@ -468,10 +466,10 @@ ofputil_match_to_ofp11_match(const struct match *match, ofmatch->omh.type = htons(OFPMT_STANDARD); ofmatch->omh.length = htons(OFPMT11_STANDARD_LENGTH); - if (!match->wc.masks.in_port) { + if (!match->wc.masks.in_port.ofp_port) { wc |= OFPFW11_IN_PORT; } else { - ofmatch->in_port = ofputil_port_to_ofp11(match->flow.in_port); + ofmatch->in_port = ofputil_port_to_ofp11(match->flow.in_port.ofp_port); } memcpy(ofmatch->dl_src, match->flow.dl_src, ETH_ADDR_LEN); @@ -924,7 +922,7 @@ ofputil_version_from_string(const char *s) } static bool -is_delimiter(char c) +is_delimiter(unsigned char c) { return isspace(c) || c == ','; } @@ -1041,16 +1039,6 @@ regs_fully_wildcarded(const struct flow_wildcards *wc) return true; } -static bool -tun_parms_fully_wildcarded(const struct flow_wildcards *wc) -{ - return (!wc->masks.tunnel.ip_src && - !wc->masks.tunnel.ip_dst && - !wc->masks.tunnel.ip_ttl && - !wc->masks.tunnel.ip_tos && - !wc->masks.tunnel.flags); -} - /* Returns a bit-mask of ofputil_protocols that can be used for sending 'match' * to a switch (e.g. to add or remove a flow). Only NXM can handle tunnel IDs, * registers, or fixing the Ethernet multicast bit. Otherwise, it's better to @@ -1060,10 +1048,11 @@ ofputil_usable_protocols(const struct match *match) { const struct flow_wildcards *wc = &match->wc; - BUILD_ASSERT_DECL(FLOW_WC_SEQ == 18); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 20); - /* tunnel params other than tun_id can't be sent in a flow_mod */ - if (!tun_parms_fully_wildcarded(wc)) { + /* These tunnel params can't be sent in a flow_mod */ + if (wc->masks.tunnel.ip_ttl + || wc->masks.tunnel.ip_tos || wc->masks.tunnel.flags) { return OFPUTIL_P_NONE; } @@ -1109,8 +1098,10 @@ ofputil_usable_protocols(const struct match *match) | OFPUTIL_P_OF13_OXM; } - /* NXM and OXM support matching tun_id. */ - if (wc->masks.tunnel.tun_id != htonll(0)) { + /* NXM and OXM support matching tun_id, tun_src, and tun_dst. */ + if (wc->masks.tunnel.tun_id != htonll(0) + || wc->masks.tunnel.ip_src != htonl(0) + || wc->masks.tunnel.ip_dst != htonl(0)) { return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM | OFPUTIL_P_OF13_OXM; } @@ -1152,6 +1143,26 @@ ofputil_usable_protocols(const struct match *match) | OFPUTIL_P_OF13_OXM; } + /* NXM and OF1.1+ support matching MPLS label */ + if (wc->masks.mpls_lse & htonl(MPLS_LABEL_MASK)) { + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; + } + + /* NXM and OF1.1+ support matching MPLS TC */ + if (wc->masks.mpls_lse & htonl(MPLS_TC_MASK)) { + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; + } + + /* NXM and OF1.3+ support matching MPLS stack flag */ + /* Allow for OF1.2 as there doesn't seem to be a + * particularly good reason not to */ + if (wc->masks.mpls_lse & htonl(MPLS_BOS_MASK)) { + return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM + | OFPUTIL_P_OF13_OXM; + } + /* Other formats can express this rule. */ return OFPUTIL_P_ANY; } @@ -1491,7 +1502,8 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, return error; } - error = ofpacts_pull_openflow11_instructions(&b, b.size, ofpacts); + error = ofpacts_pull_openflow11_instructions(&b, b.size, ofm->table_id, + ofpacts); if (error) { return error; } @@ -1555,7 +1567,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->idle_timeout = ntohs(ofm->idle_timeout); fm->hard_timeout = ntohs(ofm->hard_timeout); fm->buffer_id = ntohl(ofm->buffer_id); - fm->out_port = ntohs(ofm->out_port); + fm->out_port = u16_to_ofp(ntohs(ofm->out_port)); fm->flags = ntohs(ofm->flags); } else if (raw == OFPRAW_NXT_FLOW_MOD) { /* Nicira extended flow_mod. */ @@ -1586,7 +1598,7 @@ ofputil_decode_flow_mod(struct ofputil_flow_mod *fm, fm->idle_timeout = ntohs(nfm->idle_timeout); fm->hard_timeout = ntohs(nfm->hard_timeout); fm->buffer_id = ntohl(nfm->buffer_id); - fm->out_port = ntohs(nfm->out_port); + fm->out_port = u16_to_ofp(ntohs(nfm->out_port)); fm->flags = ntohs(nfm->flags); } else { NOT_REACHED(); @@ -1641,7 +1653,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, case OFPUTIL_P_OF13_OXM: { struct ofp11_flow_mod *ofm; - msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, + msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, ofputil_protocol_to_ofp_version(protocol), NXM_TYPICAL_LEN + fm->ofpacts_len); ofm = ofpbuf_put_zeros(msg, sizeof *ofm); @@ -1679,7 +1691,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, ofm->hard_timeout = htons(fm->hard_timeout); ofm->priority = htons(fm->priority); ofm->buffer_id = htonl(fm->buffer_id); - ofm->out_port = htons(fm->out_port); + ofm->out_port = htons(ofp_to_u16(fm->out_port)); ofm->flags = htons(fm->flags); ofpacts_put_openflow10(fm->ofpacts, fm->ofpacts_len, msg); break; @@ -1701,7 +1713,7 @@ ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm, nfm->hard_timeout = htons(fm->hard_timeout); nfm->priority = htons(fm->priority); nfm->buffer_id = htonl(fm->buffer_id); - nfm->out_port = htons(fm->out_port); + nfm->out_port = htons(ofp_to_u16(fm->out_port)); nfm->flags = htons(fm->flags); nfm->match_len = htons(match_len); ofpacts_put_openflow10(fm->ofpacts, fm->ofpacts_len, msg); @@ -1754,7 +1766,7 @@ ofputil_decode_ofpst10_flow_request(struct ofputil_flow_stats_request *fsr, { fsr->aggregate = aggregate; ofputil_match_from_ofp10_match(&ofsr->match, &fsr->match); - fsr->out_port = ntohs(ofsr->out_port); + fsr->out_port = u16_to_ofp(ntohs(ofsr->out_port)); fsr->table_id = ofsr->table_id; fsr->cookie = fsr->cookie_mask = htonll(0); @@ -1806,7 +1818,7 @@ ofputil_decode_nxst_flow_request(struct ofputil_flow_stats_request *fsr, } fsr->aggregate = aggregate; - fsr->out_port = ntohs(nfsr->out_port); + fsr->out_port = u16_to_ofp(ntohs(nfsr->out_port)); fsr->table_id = nfsr->table_id; return 0; @@ -1890,7 +1902,7 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, ofsr = ofpbuf_put_zeros(msg, sizeof *ofsr); ofputil_match_to_ofp10_match(&fsr->match, &ofsr->match); ofsr->table_id = fsr->table_id; - ofsr->out_port = htons(fsr->out_port); + ofsr->out_port = htons(ofp_to_u16(fsr->out_port)); break; } @@ -1908,7 +1920,7 @@ ofputil_encode_flow_stats_request(const struct ofputil_flow_stats_request *fsr, fsr->cookie, fsr->cookie_mask); nfsr = msg->l3; - nfsr->out_port = htons(fsr->out_port); + nfsr->out_port = htons(ofp_to_u16(fsr->out_port)); nfsr->match_len = htons(match_len); nfsr->table_id = fsr->table_id; break; @@ -2003,7 +2015,8 @@ ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *fs, } if (ofpacts_pull_openflow11_instructions(msg, length - sizeof *ofs - - padded_match_len, ofpacts)) { + padded_match_len, + ofs->table_id, ofpacts)) { VLOG_WARN_RL(&bad_ofmsg_rl, "OFPST_FLOW reply bad instructions"); return EINVAL; } @@ -2327,7 +2340,7 @@ ofputil_decode_flow_removed(struct ofputil_flow_removed *fr, fr->priority = ntohs(nfr->priority); fr->cookie = nfr->cookie; fr->reason = nfr->reason; - fr->table_id = 255; + fr->table_id = nfr->table_id ? nfr->table_id - 1 : 255; fr->duration_sec = ntohl(nfr->duration_sec); fr->duration_nsec = ntohl(nfr->duration_nsec); fr->idle_timeout = ntohs(nfr->idle_timeout); @@ -2406,6 +2419,7 @@ ofputil_encode_flow_removed(const struct ofputil_flow_removed *fr, nfr->cookie = fr->cookie; nfr->priority = htons(fr->priority); nfr->reason = fr->reason; + nfr->table_id = fr->table_id + 1; nfr->duration_sec = htonl(fr->duration_sec); nfr->duration_nsec = htonl(fr->duration_nsec); nfr->idle_timeout = htons(fr->idle_timeout); @@ -2429,8 +2443,10 @@ ofputil_decode_packet_in_finish(struct ofputil_packet_in *pin, pin->packet = b->data; pin->packet_len = b->size; - pin->fmd.in_port = match->flow.in_port; + pin->fmd.in_port = match->flow.in_port.ofp_port; pin->fmd.tun_id = match->flow.tunnel.tun_id; + pin->fmd.tun_src = match->flow.tunnel.ip_src; + pin->fmd.tun_dst = match->flow.tunnel.ip_dst; pin->fmd.metadata = match->flow.metadata; memcpy(pin->fmd.regs, match->flow.regs, sizeof pin->fmd.regs); } @@ -2486,7 +2502,7 @@ ofputil_decode_packet_in(struct ofputil_packet_in *pin, pin->packet = opi->data; pin->packet_len = b.size; - pin->fmd.in_port = ntohs(opi->in_port); + pin->fmd.in_port = u16_to_ofp(ntohs(opi->in_port)); pin->reason = opi->reason; pin->buffer_id = ntohl(opi->buffer_id); pin->total_len = ntohs(opi->total_len); @@ -2531,6 +2547,12 @@ ofputil_packet_in_to_match(const struct ofputil_packet_in *pin, if (pin->fmd.tun_id != htonll(0)) { match_set_tun_id(match, pin->fmd.tun_id); } + if (pin->fmd.tun_src != htonl(0)) { + match_set_tun_src(match, pin->fmd.tun_src); + } + if (pin->fmd.tun_dst != htonl(0)) { + match_set_tun_dst(match, pin->fmd.tun_dst); + } if (pin->fmd.metadata != htonll(0)) { match_set_metadata(match, pin->fmd.metadata); } @@ -2598,7 +2620,7 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, htonl(0), send_len); opi = ofpbuf_put_zeros(packet, offsetof(struct ofp10_packet_in, data)); opi->total_len = htons(pin->total_len); - opi->in_port = htons(pin->fmd.in_port); + opi->in_port = htons(ofp_to_u16(pin->fmd.in_port)); opi->reason = pin->reason; opi->buffer_id = htonl(pin->buffer_id); @@ -2634,11 +2656,13 @@ ofputil_encode_packet_in(const struct ofputil_packet_in *pin, return packet; } +/* Returns a string form of 'reason'. The return value is either a statically + * allocated constant string or the 'bufsize'-byte buffer 'reasonbuf'. + * 'bufsize' should be at least OFPUTIL_PACKET_IN_REASON_BUFSIZE. */ const char * -ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason) +ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason, + char *reasonbuf, size_t bufsize) { - static char s[INT_STRLEN(int) + 1]; - switch (reason) { case OFPR_NO_MATCH: return "no_match"; @@ -2649,8 +2673,8 @@ ofputil_packet_in_reason_to_string(enum ofp_packet_in_reason reason) case OFPR_N_REASONS: default: - sprintf(s, "%d", (int) reason); - return s; + snprintf(reasonbuf, bufsize, "%d", (int) reason); + return reasonbuf; } } @@ -2661,7 +2685,12 @@ ofputil_packet_in_reason_from_string(const char *s, int i; for (i = 0; i < OFPR_N_REASONS; i++) { - if (!strcasecmp(s, ofputil_packet_in_reason_to_string(i))) { + char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE]; + const char *reason_s; + + reason_s = ofputil_packet_in_reason_to_string(i, reasonbuf, + sizeof reasonbuf); + if (!strcasecmp(s, reason_s)) { *reason = i; return true; } @@ -2708,7 +2737,7 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po, const struct ofp10_packet_out *opo = ofpbuf_pull(&b, sizeof *opo); po->buffer_id = ntohl(opo->buffer_id); - po->in_port = ntohs(opo->in_port); + po->in_port = u16_to_ofp(ntohs(opo->in_port)); error = ofpacts_pull_openflow10(&b, ntohs(opo->actions_len), ofpacts); if (error) { @@ -2718,7 +2747,8 @@ ofputil_decode_packet_out(struct ofputil_packet_out *po, NOT_REACHED(); } - if (po->in_port >= OFPP_MAX && po->in_port != OFPP_LOCAL + if (ofp_to_u16(po->in_port) >= ofp_to_u16(OFPP_MAX) + && po->in_port != OFPP_LOCAL && po->in_port != OFPP_NONE && po->in_port != OFPP_CONTROLLER) { VLOG_WARN_RL(&bad_ofmsg_rl, "packet-out has bad input port %#"PRIx16, po->in_port); @@ -2805,7 +2835,7 @@ ofputil_decode_ofp10_phy_port(struct ofputil_phy_port *pp, { memset(pp, 0, sizeof *pp); - pp->port_no = ntohs(opp->port_no); + pp->port_no = u16_to_ofp(ntohs(opp->port_no)); memcpy(pp->hw_addr, opp->hw_addr, OFP_ETH_ALEN); ovs_strlcpy(pp->name, opp->name, OFP_MAX_PORT_NAME_LEN); @@ -2873,7 +2903,7 @@ ofputil_encode_ofp10_phy_port(const struct ofputil_phy_port *pp, { memset(opp, 0, sizeof *opp); - opp->port_no = htons(pp->port_no); + opp->port_no = htons(ofp_to_u16(pp->port_no)); memcpy(opp->hw_addr, pp->hw_addr, ETH_ADDR_LEN); ovs_strlcpy(opp->name, pp->name, OFP_MAX_PORT_NAME_LEN); @@ -3283,7 +3313,7 @@ ofputil_decode_port_mod(const struct ofp_header *oh, if (raw == OFPRAW_OFPT10_PORT_MOD) { const struct ofp10_port_mod *opm = b.data; - pm->port_no = ntohs(opm->port_no); + pm->port_no = u16_to_ofp(ntohs(opm->port_no)); memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN); pm->config = ntohl(opm->config) & OFPPC10_ALL; pm->mask = ntohl(opm->mask) & OFPPC10_ALL; @@ -3325,7 +3355,7 @@ ofputil_encode_port_mod(const struct ofputil_port_mod *pm, b = ofpraw_alloc(OFPRAW_OFPT10_PORT_MOD, ofp_version, 0); opm = ofpbuf_put_zeros(b, sizeof *opm); - opm->port_no = htons(pm->port_no); + opm->port_no = htons(ofp_to_u16(pm->port_no)); memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN); opm->config = htonl(pm->config & OFPPC10_ALL); opm->mask = htonl(pm->mask & OFPPC10_ALL); @@ -3364,43 +3394,54 @@ enum ofperr ofputil_decode_role_message(const struct ofp_header *oh, struct ofputil_role_request *rr) { - const struct ofp12_role_request *orr = ofpmsg_body(oh); - uint32_t role = ntohl(orr->role); struct ofpbuf b; enum ofpraw raw; - memset(rr, 0, sizeof *rr); - ofpbuf_use_const(&b, oh, ntohs(oh->length)); raw = ofpraw_pull_assert(&b); - if (raw == OFPRAW_OFPT12_ROLE_REQUEST - || raw == OFPRAW_OFPT12_ROLE_REPLY) { + if (raw == OFPRAW_OFPT12_ROLE_REQUEST || + raw == OFPRAW_OFPT12_ROLE_REPLY) { + const struct ofp12_role_request *orr = b.l3; - if (raw == OFPRAW_OFPT12_ROLE_REQUEST) { - if (role == OFPCR12_ROLE_NOCHANGE) { - rr->request_current_role_only = true; - return 0; - } - if (role == OFPCR12_ROLE_MASTER || role == OFPCR12_ROLE_SLAVE) { - rr->generation_id = ntohll(orr->generation_id); - rr->have_generation_id = true; - } + if (orr->role != htonl(OFPCR12_ROLE_NOCHANGE) && + orr->role != htonl(OFPCR12_ROLE_EQUAL) && + orr->role != htonl(OFPCR12_ROLE_MASTER) && + orr->role != htonl(OFPCR12_ROLE_SLAVE)) { + return OFPERR_OFPRRFC_BAD_ROLE; } - /* Map to enum nx_role */ - role -= 1; /* OFPCR12_ROLE_MASTER -> NX_ROLE_MASTER etc. */ - } else if (raw != OFPRAW_NXT_ROLE_REQUEST - && raw != OFPRAW_NXT_ROLE_REPLY) { - return OFPERR_OFPBRC_BAD_TYPE; - } + rr->role = ntohl(orr->role); + if (raw == OFPRAW_OFPT12_ROLE_REQUEST + ? orr->role == htonl(OFPCR12_ROLE_NOCHANGE) + : orr->generation_id == htonll(UINT64_MAX)) { + rr->have_generation_id = false; + rr->generation_id = 0; + } else { + rr->have_generation_id = true; + rr->generation_id = ntohll(orr->generation_id); + } + } else if (raw == OFPRAW_NXT_ROLE_REQUEST || + raw == OFPRAW_NXT_ROLE_REPLY) { + const struct nx_role_request *nrr = b.l3; + + BUILD_ASSERT(NX_ROLE_OTHER + 1 == OFPCR12_ROLE_EQUAL); + BUILD_ASSERT(NX_ROLE_MASTER + 1 == OFPCR12_ROLE_MASTER); + BUILD_ASSERT(NX_ROLE_SLAVE + 1 == OFPCR12_ROLE_SLAVE); + + if (nrr->role != htonl(NX_ROLE_OTHER) && + nrr->role != htonl(NX_ROLE_MASTER) && + nrr->role != htonl(NX_ROLE_SLAVE)) { + return OFPERR_OFPRRFC_BAD_ROLE; + } - if (role != NX_ROLE_OTHER && role != NX_ROLE_MASTER - && role != NX_ROLE_SLAVE) { - return OFPERR_OFPRRFC_BAD_ROLE; + rr->role = ntohl(nrr->role) + 1; + rr->have_generation_id = false; + rr->generation_id = 0; + } else { + NOT_REACHED(); } - rr->role = role; return 0; } @@ -3408,47 +3449,35 @@ ofputil_decode_role_message(const struct ofp_header *oh, * buffer owned by the caller. */ struct ofpbuf * ofputil_encode_role_reply(const struct ofp_header *request, - enum nx_role role) + const struct ofputil_role_request *rr) { - struct ofp12_role_request *reply; struct ofpbuf *buf; - size_t reply_size; - - struct ofpbuf b; enum ofpraw raw; - ofpbuf_use_const(&b, request, ntohs(request->length)); - raw = ofpraw_pull_assert(&b); + raw = ofpraw_decode_assert(request); if (raw == OFPRAW_OFPT12_ROLE_REQUEST) { - reply_size = sizeof (struct ofp12_role_request); - raw = OFPRAW_OFPT12_ROLE_REPLY; - } - else if (raw == OFPRAW_NXT_ROLE_REQUEST) { - reply_size = sizeof (struct nx_role_request); - raw = OFPRAW_NXT_ROLE_REPLY; - } else { - NOT_REACHED(); - } + struct ofp12_role_request *orr; - buf = ofpraw_alloc_reply(raw, request, 0); - reply = ofpbuf_put_zeros(buf, reply_size); + buf = ofpraw_alloc_reply(OFPRAW_OFPT12_ROLE_REPLY, request, 0); + orr = ofpbuf_put_zeros(buf, sizeof *orr); - if (raw == OFPRAW_OFPT12_ROLE_REPLY) { - /* Map to OpenFlow enum ofp12_controller_role */ - role += 1; /* NX_ROLE_MASTER -> OFPCR12_ROLE_MASTER etc. */ - /* - * OpenFlow specification does not specify use of generation_id field - * on reply messages. Intuitively, it would seem a good idea to return - * the current value. However, the current value is undefined - * initially, and there is no way to insert an undefined value in the - * message. Therefore we leave the generation_id zeroed on reply - * messages. - * - * A request for clarification has been filed with the Open Networking - * Foundation as EXT-272. - */ + orr->role = htonl(rr->role); + orr->generation_id = htonll(rr->have_generation_id + ? rr->generation_id + : UINT64_MAX); + } else if (raw == OFPRAW_NXT_ROLE_REQUEST) { + struct nx_role_request *nrr; + + BUILD_ASSERT(NX_ROLE_OTHER == OFPCR12_ROLE_EQUAL - 1); + BUILD_ASSERT(NX_ROLE_MASTER == OFPCR12_ROLE_MASTER - 1); + BUILD_ASSERT(NX_ROLE_SLAVE == OFPCR12_ROLE_SLAVE - 1); + + buf = ofpraw_alloc_reply(OFPRAW_NXT_ROLE_REPLY, request, 0); + nrr = ofpbuf_put_zeros(buf, sizeof *nrr); + nrr->role = htonl(rr->role - 1); + } else { + NOT_REACHED(); } - reply->role = htonl(role); return buf; } @@ -3662,7 +3691,7 @@ ofputil_decode_flow_monitor_request(struct ofputil_flow_monitor_request *rq, rq->id = ntohl(nfmr->id); rq->flags = flags; - rq->out_port = ntohs(nfmr->out_port); + rq->out_port = u16_to_ofp(ntohs(nfmr->out_port)); rq->table_id = nfmr->table_id; return nx_pull_match(msg, ntohs(nfmr->match_len), &rq->match, NULL, NULL); @@ -3687,7 +3716,7 @@ ofputil_append_flow_monitor_request( nfmr = ofpbuf_at_assert(msg, start_ofs, sizeof *nfmr); nfmr->id = htonl(rq->id); nfmr->flags = htons(rq->flags); - nfmr->out_port = htons(rq->out_port); + nfmr->out_port = htons(ofp_to_u16(rq->out_port)); nfmr->match_len = htons(match_len); nfmr->table_id = rq->table_id; } @@ -3895,7 +3924,7 @@ ofputil_encode_packet_out(const struct ofputil_packet_out *po, opo = msg->l3; opo->buffer_id = htonl(po->buffer_id); - opo->in_port = htons(po->in_port); + opo->in_port = htons(ofp_to_u16(po->in_port)); opo->actions_len = htons(msg->size - actions_ofs); break; } @@ -4010,25 +4039,26 @@ ofputil_frag_handling_from_string(const char *s, enum ofp_config_flags *flags) /* Converts the OpenFlow 1.1+ port number 'ofp11_port' into an OpenFlow 1.0 * port number and stores the latter in '*ofp10_port', for the purpose of * decoding OpenFlow 1.1+ protocol messages. Returns 0 if successful, - * otherwise an OFPERR_* number. + * otherwise an OFPERR_* number. On error, stores OFPP_NONE in '*ofp10_port'. * * See the definition of OFP11_MAX for an explanation of the mapping. */ enum ofperr -ofputil_port_from_ofp11(ovs_be32 ofp11_port, uint16_t *ofp10_port) +ofputil_port_from_ofp11(ovs_be32 ofp11_port, ofp_port_t *ofp10_port) { uint32_t ofp11_port_h = ntohl(ofp11_port); - if (ofp11_port_h < OFPP_MAX) { - *ofp10_port = ofp11_port_h; + if (ofp11_port_h < ofp_to_u16(OFPP_MAX)) { + *ofp10_port = u16_to_ofp(ofp11_port_h); return 0; - } else if (ofp11_port_h >= OFPP11_MAX) { - *ofp10_port = ofp11_port_h - OFPP11_OFFSET; + } else if (ofp11_port_h >= ofp11_to_u32(OFPP11_MAX)) { + *ofp10_port = u16_to_ofp(ofp11_port_h - OFPP11_OFFSET); return 0; } else { + *ofp10_port = OFPP_NONE; VLOG_WARN_RL(&bad_ofmsg_rl, "port %"PRIu32" is outside the supported " "range 0 through %d or 0x%"PRIx32" through 0x%"PRIx32, - ofp11_port_h, OFPP_MAX - 1, - (uint32_t) OFPP11_MAX, UINT32_MAX); + ofp11_port_h, ofp_to_u16(OFPP_MAX) - 1, + ofp11_to_u32(OFPP11_MAX), UINT32_MAX); return OFPERR_OFPBAC_BAD_OUT_PORT; } } @@ -4038,18 +4068,18 @@ ofputil_port_from_ofp11(ovs_be32 ofp11_port, uint16_t *ofp10_port) * * See the definition of OFP11_MAX for an explanation of the mapping. */ ovs_be32 -ofputil_port_to_ofp11(uint16_t ofp10_port) +ofputil_port_to_ofp11(ofp_port_t ofp10_port) { - return htonl(ofp10_port < OFPP_MAX - ? ofp10_port - : ofp10_port + OFPP11_OFFSET); + return htonl(ofp_to_u16(ofp10_port) < ofp_to_u16(OFPP_MAX) + ? ofp_to_u16(ofp10_port) + : ofp_to_u16(ofp10_port) + OFPP11_OFFSET); } /* Checks that 'port' is a valid output port for the OFPAT10_OUTPUT action, given * that the switch will never have more than 'max_ports' ports. Returns 0 if * 'port' is valid, otherwise an OpenFlow return code. */ enum ofperr -ofputil_check_output_port(uint16_t port, int max_ports) +ofputil_check_output_port(ofp_port_t port, ofp_port_t max_ports) { switch (port) { case OFPP_IN_PORT: @@ -4063,7 +4093,7 @@ ofputil_check_output_port(uint16_t port, int max_ports) return 0; default: - if (port < max_ports) { + if (ofp_to_u16(port) < ofp_to_u16(max_ports)) { return 0; } return OFPERR_OFPBAC_BAD_OUT_PORT; @@ -4099,46 +4129,42 @@ ofputil_check_output_port(uint16_t port, int max_ports) * of OpenFlow 1.1+ port numbers, mapping those port numbers into the 16-bit * range as described in include/openflow/openflow-1.1.h. */ bool -ofputil_port_from_string(const char *s, uint16_t *portp) +ofputil_port_from_string(const char *s, ofp_port_t *portp) { - unsigned int port32; + uint32_t port32; *portp = 0; if (str_to_uint(s, 10, &port32)) { - if (port32 < OFPP_MAX) { - *portp = port32; - return true; - } else if (port32 < OFPP_FIRST_RESV) { + if (port32 < ofp_to_u16(OFPP_MAX)) { + /* Pass. */ + } else if (port32 < ofp_to_u16(OFPP_FIRST_RESV)) { VLOG_WARN("port %u is a reserved OF1.0 port number that will " "be translated to %u when talking to an OF1.1 or " "later controller", port32, port32 + OFPP11_OFFSET); - *portp = port32; - return true; - } else if (port32 <= OFPP_LAST_RESV) { + } else if (port32 <= ofp_to_u16(OFPP_LAST_RESV)) { struct ds msg; ds_init(&msg); - ofputil_format_port(port32, &msg); + ofputil_format_port(u16_to_ofp(port32), &msg); VLOG_WARN_ONCE("referring to port %s as %u is deprecated for " "compatibility with future versions of OpenFlow", ds_cstr(&msg), port32); ds_destroy(&msg); - - *portp = port32; - return true; - } else if (port32 < OFPP11_MAX) { + } else if (port32 < ofp11_to_u32(OFPP11_MAX)) { VLOG_WARN("port %u is outside the supported range 0 through " "%"PRIx16" or 0x%x through 0x%"PRIx32, port32, - UINT16_MAX, (unsigned int) OFPP11_MAX, UINT32_MAX); + UINT16_MAX, ofp11_to_u32(OFPP11_MAX), UINT32_MAX); return false; } else { - *portp = port32 - OFPP11_OFFSET; - return true; + port32 -= OFPP11_OFFSET; } + + *portp = u16_to_ofp(port32); + return true; } else { struct pair { const char *name; - uint16_t value; + ofp_port_t value; }; static const struct pair pairs[] = { #define OFPUTIL_NAMED_PORT(NAME) {#NAME, OFPP_##NAME}, @@ -4161,7 +4187,7 @@ ofputil_port_from_string(const char *s, uint16_t *portp) * Most ports' string representation is just the port number, but for special * ports, e.g. OFPP_LOCAL, it is the name, e.g. "LOCAL". */ void -ofputil_format_port(uint16_t port, struct ds *s) +ofputil_format_port(ofp_port_t port, struct ds *s) { const char *name; @@ -4217,7 +4243,7 @@ size_t ofputil_count_phy_ports(uint8_t ofp_version, struct ofpbuf *b) int ofputil_action_code_from_name(const char *name) { - static const char *names[OFPUTIL_N_ACTIONS] = { + static const char *const names[OFPUTIL_N_ACTIONS] = { NULL, #define OFPAT10_ACTION(ENUM, STRUCT, NAME) NAME, #define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) NAME, @@ -4225,7 +4251,7 @@ ofputil_action_code_from_name(const char *name) #include "ofp-util.def" }; - const char **p; + const char *const *p; for (p = names; p < &names[ARRAY_SIZE(names)]; p++) { if (*p && !strcasecmp(name, *p)) { @@ -4307,7 +4333,8 @@ ofputil_normalize_match__(struct match *match, bool may_log) MAY_ARP_SHA = 1 << 4, /* arp_sha */ MAY_ARP_THA = 1 << 5, /* arp_tha */ MAY_IPV6 = 1 << 6, /* ipv6_src, ipv6_dst, ipv6_label */ - MAY_ND_TARGET = 1 << 7 /* nd_target */ + MAY_ND_TARGET = 1 << 7, /* nd_target */ + MAY_MPLS = 1 << 8, /* mpls label and tc */ } may_match; struct flow_wildcards wc; @@ -4336,6 +4363,8 @@ ofputil_normalize_match__(struct match *match, bool may_log) } else if (match->flow.dl_type == htons(ETH_TYPE_ARP) || match->flow.dl_type == htons(ETH_TYPE_RARP)) { may_match = MAY_NW_PROTO | MAY_NW_ADDR | MAY_ARP_SHA | MAY_ARP_THA; + } else if (eth_type_mpls(match->flow.dl_type)) { + may_match = MAY_MPLS; } else { may_match = 0; } @@ -4368,6 +4397,10 @@ ofputil_normalize_match__(struct match *match, bool may_log) if (!(may_match & MAY_ND_TARGET)) { wc.masks.nd_target = in6addr_any; } + if (!(may_match & MAY_MPLS)) { + wc.masks.mpls_lse = htonl(0); + wc.masks.mpls_depth = 0; + } /* Log any changes. */ if (!flow_wildcards_equal(&wc, &match->wc)) { @@ -4495,7 +4528,7 @@ ofputil_parse_key_value(char **stringp, char **keyp, char **valuep) * will be for Open Flow version 'ofp_version'. Returns message * as a struct ofpbuf. Returns encoded message on success, NULL on error */ struct ofpbuf * -ofputil_encode_dump_ports_request(enum ofp_version ofp_version, int16_t port) +ofputil_encode_dump_ports_request(enum ofp_version ofp_version, ofp_port_t port) { struct ofpbuf *request; @@ -4504,7 +4537,7 @@ ofputil_encode_dump_ports_request(enum ofp_version ofp_version, int16_t port) struct ofp10_port_stats_request *req; request = ofpraw_alloc(OFPRAW_OFPST10_PORT_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); - req->port_no = htons(port); + req->port_no = htons(ofp_to_u16(port)); break; } case OFP11_VERSION: @@ -4527,7 +4560,7 @@ static void ofputil_port_stats_to_ofp10(const struct ofputil_port_stats *ops, struct ofp10_port_stats *ps10) { - ps10->port_no = htons(ops->port_no); + ps10->port_no = htons(ofp_to_u16(ops->port_no)); memset(ps10->pad, 0, sizeof ps10->pad); put_32aligned_be64(&ps10->rx_packets, htonll(ops->stats.rx_packets)); put_32aligned_be64(&ps10->tx_packets, htonll(ops->stats.tx_packets)); @@ -4568,11 +4601,8 @@ ofputil_port_stats_to_ofp13(const struct ofputil_port_stats *ops, struct ofp13_port_stats *ps13) { ofputil_port_stats_to_ofp11(ops, &ps13->ps); - - /* OF 1.3 adds duration fields */ - /* FIXME: Need to implement port alive duration (sec + nsec) */ - ps13->duration_sec = htonl(~0); - ps13->duration_nsec = htonl(~0); + ps13->duration_sec = htonl(ops->duration_sec); + ps13->duration_nsec = htonl(ops->duration_nsec); } @@ -4614,7 +4644,7 @@ ofputil_port_stats_from_ofp10(struct ofputil_port_stats *ops, { memset(ops, 0, sizeof *ops); - ops->port_no = ntohs(ps10->port_no); + ops->port_no = u16_to_ofp(ntohs(ps10->port_no)); ops->stats.rx_packets = ntohll(get_32aligned_be64(&ps10->rx_packets)); ops->stats.tx_packets = ntohll(get_32aligned_be64(&ps10->tx_packets)); ops->stats.rx_bytes = ntohll(get_32aligned_be64(&ps10->rx_bytes)); @@ -4628,6 +4658,7 @@ ofputil_port_stats_from_ofp10(struct ofputil_port_stats *ops, ops->stats.rx_over_errors = ntohll(get_32aligned_be64(&ps10->rx_over_err)); ops->stats.rx_crc_errors = ntohll(get_32aligned_be64(&ps10->rx_crc_err)); ops->stats.collisions = ntohll(get_32aligned_be64(&ps10->collisions)); + ops->duration_sec = ops->duration_nsec = UINT32_MAX; return 0; } @@ -4656,6 +4687,7 @@ ofputil_port_stats_from_ofp11(struct ofputil_port_stats *ops, ops->stats.rx_over_errors = ntohll(ps11->rx_over_err); ops->stats.rx_crc_errors = ntohll(ps11->rx_crc_err); ops->stats.collisions = ntohll(ps11->collisions); + ops->duration_sec = ops->duration_nsec = UINT32_MAX; return 0; } @@ -4664,13 +4696,11 @@ static enum ofperr ofputil_port_stats_from_ofp13(struct ofputil_port_stats *ops, const struct ofp13_port_stats *ps13) { - enum ofperr error = - ofputil_port_stats_from_ofp11(ops, &ps13->ps); + enum ofperr error = ofputil_port_stats_from_ofp11(ops, &ps13->ps); if (!error) { - /* FIXME: Get ps13->duration_sec and ps13->duration_nsec, - * Add to netdev_stats? */ + ops->duration_sec = ntohl(ps13->duration_sec); + ops->duration_nsec = ntohl(ps13->duration_nsec); } - return error; } @@ -4754,7 +4784,7 @@ ofputil_decode_port_stats(struct ofputil_port_stats *ps, struct ofpbuf *msg) * Returns 0 if successful, otherwise an OFPERR_* number. */ enum ofperr ofputil_decode_port_stats_request(const struct ofp_header *request, - uint16_t *ofp10_port) + ofp_port_t *ofp10_port) { switch ((enum ofp_version)request->version) { case OFP13_VERSION: @@ -4766,7 +4796,7 @@ ofputil_decode_port_stats_request(const struct ofp_header *request, case OFP10_VERSION: { const struct ofp10_port_stats_request *psr10 = ofpmsg_body(request); - *ofp10_port = ntohs(psr10->port_no); + *ofp10_port = u16_to_ofp(ntohs(psr10->port_no)); return 0; } @@ -4793,7 +4823,7 @@ ofputil_decode_queue_stats_request(const struct ofp_header *request, case OFP10_VERSION: { const struct ofp10_queue_stats_request *qsr10 = ofpmsg_body(request); oqsr->queue_id = ntohl(qsr10->queue_id); - oqsr->port_no = ntohs(qsr10->port_no); + oqsr->port_no = u16_to_ofp(ntohs(qsr10->port_no)); /* OF 1.0 uses OFPP_ALL for OFPP_ANY */ if (oqsr->port_no == OFPP_ALL) { oqsr->port_no = OFPP_ANY; @@ -4831,8 +4861,8 @@ ofputil_encode_queue_stats_request(enum ofp_version ofp_version, request = ofpraw_alloc(OFPRAW_OFPST10_QUEUE_REQUEST, ofp_version, 0); req = ofpbuf_put_zeros(request, sizeof *req); /* OpenFlow 1.0 needs OFPP_ALL instead of OFPP_ANY */ - req->port_no = htons(oqsr->port_no == OFPP_ANY - ? OFPP_ALL : oqsr->port_no); + req->port_no = htons(ofp_to_u16(oqsr->port_no == OFPP_ANY + ? OFPP_ALL : oqsr->port_no)); req->queue_id = htonl(oqsr->queue_id); break; } @@ -4862,7 +4892,7 @@ static enum ofperr ofputil_queue_stats_from_ofp10(struct ofputil_queue_stats *oqs, const struct ofp10_queue_stats *qs10) { - oqs->port_no = ntohs(qs10->port_no); + oqs->port_no = u16_to_ofp(ntohs(qs10->port_no)); oqs->queue_id = ntohl(qs10->queue_id); oqs->stats.tx_bytes = ntohll(get_32aligned_be64(&qs10->tx_bytes)); oqs->stats.tx_packets = ntohll(get_32aligned_be64(&qs10->tx_packets)); @@ -4967,7 +4997,7 @@ static void ofputil_queue_stats_to_ofp10(const struct ofputil_queue_stats *oqs, struct ofp10_queue_stats *qs10) { - qs10->port_no = htons(oqs->port_no); + qs10->port_no = htons(ofp_to_u16(oqs->port_no)); memset(qs10->pad, 0, sizeof qs10->pad); qs10->queue_id = htonl(oqs->queue_id); put_32aligned_be64(&qs10->tx_bytes, htonll(oqs->stats.tx_bytes));