static struct ip_header *
pull_ip(struct ofpbuf *packet)
{
- if (packet->size >= IP_HEADER_LEN) {
- struct ip_header *ip = packet->data;
+ if (ofpbuf_size(packet) >= IP_HEADER_LEN) {
+ struct ip_header *ip = ofpbuf_data(packet);
int ip_len = IP_IHL(ip->ip_ihl_ver) * 4;
- if (ip_len >= IP_HEADER_LEN && packet->size >= ip_len) {
+ if (ip_len >= IP_HEADER_LEN && ofpbuf_size(packet) >= ip_len) {
return ofpbuf_pull(packet, ip_len);
}
}
return NULL;
}
-static struct tcp_header *
-pull_tcp(struct ofpbuf *packet)
-{
- if (packet->size >= TCP_HEADER_LEN) {
- struct tcp_header *tcp = packet->data;
- int tcp_len = TCP_OFFSET(tcp->tcp_ctl) * 4;
- if (tcp_len >= TCP_HEADER_LEN && packet->size >= tcp_len) {
- return ofpbuf_pull(packet, tcp_len);
- }
- }
- return NULL;
-}
-
-static struct udp_header *
-pull_udp(struct ofpbuf *packet)
-{
- return ofpbuf_try_pull(packet, UDP_HEADER_LEN);
-}
-
-static struct sctp_header *
-pull_sctp(struct ofpbuf *packet)
-{
- return ofpbuf_try_pull(packet, SCTP_HEADER_LEN);
-}
-
static struct icmp_header *
pull_icmp(struct ofpbuf *packet)
{
ovs_be16 tci;
};
- if (b->size >= sizeof(struct qtag_prefix) + sizeof(ovs_be16)) {
+ if (ofpbuf_size(b) >= sizeof(struct qtag_prefix) + sizeof(ovs_be16)) {
struct qtag_prefix *qp = ofpbuf_pull(b, sizeof *qp);
flow->vlan_tci = qp->tci | htons(VLAN_CFI);
}
return proto;
}
- if (b->size < sizeof *llc) {
+ if (ofpbuf_size(b) < sizeof *llc) {
return htons(FLOW_DL_TYPE_NONE);
}
- llc = b->data;
+ llc = ofpbuf_data(b);
if (llc->llc.llc_dsap != LLC_DSAP_SNAP
|| llc->llc.llc_ssap != LLC_SSAP_SNAP
|| llc->llc.llc_cntl != LLC_CNTL_SNAP
* accesses within the extension header are within those first 8
* bytes. All extension headers are required to be at least 8
* bytes. */
- if (packet->size < 8) {
+ if (ofpbuf_size(packet) < 8) {
return EINVAL;
}
|| (nexthdr == IPPROTO_DSTOPTS)) {
/* These headers, while different, have the fields we care about
* in the same location and with the same interpretation. */
- const struct ip6_ext *ext_hdr = packet->data;
+ const struct ip6_ext *ext_hdr = ofpbuf_data(packet);
nexthdr = ext_hdr->ip6e_nxt;
if (!ofpbuf_try_pull(packet, (ext_hdr->ip6e_len + 1) * 8)) {
return EINVAL;
* we care about are in the same location as the generic
* option header--only the header length is calculated
* differently. */
- const struct ip6_ext *ext_hdr = packet->data;
+ const struct ip6_ext *ext_hdr = ofpbuf_data(packet);
nexthdr = ext_hdr->ip6e_nxt;
if (!ofpbuf_try_pull(packet, (ext_hdr->ip6e_len + 2) * 4)) {
return EINVAL;
}
} else if (nexthdr == IPPROTO_FRAGMENT) {
- const struct ovs_16aligned_ip6_frag *frag_hdr = packet->data;
+ const struct ovs_16aligned_ip6_frag *frag_hdr = ofpbuf_data(packet);
nexthdr = frag_hdr->ip6f_nxt;
if (!ofpbuf_try_pull(packet, sizeof *frag_hdr)) {
}
static void
-parse_tcp(struct ofpbuf *packet, struct ofpbuf *b, struct flow *flow)
+parse_tcp(struct ofpbuf *b, struct flow *flow)
{
- const struct tcp_header *tcp = pull_tcp(b);
- if (tcp) {
+ if (ofpbuf_size(b) >= TCP_HEADER_LEN) {
+ const struct tcp_header *tcp = ofpbuf_data(b);
+
flow->tp_src = tcp->tcp_src;
flow->tp_dst = tcp->tcp_dst;
flow->tcp_flags = tcp->tcp_ctl & htons(0x0fff);
- packet->l7 = b->data;
}
}
static void
-parse_udp(struct ofpbuf *packet, struct ofpbuf *b, struct flow *flow)
+parse_udp(struct ofpbuf *b, struct flow *flow)
{
- const struct udp_header *udp = pull_udp(b);
- if (udp) {
+ if (ofpbuf_size(b) >= UDP_HEADER_LEN) {
+ const struct udp_header *udp = ofpbuf_data(b);
+
flow->tp_src = udp->udp_src;
flow->tp_dst = udp->udp_dst;
- packet->l7 = b->data;
}
}
static void
-parse_sctp(struct ofpbuf *packet, struct ofpbuf *b, struct flow *flow)
+parse_sctp(struct ofpbuf *b, struct flow *flow)
{
- const struct sctp_header *sctp = pull_sctp(b);
- if (sctp) {
+ if (ofpbuf_size(b) >= SCTP_HEADER_LEN) {
+ const struct sctp_header *sctp = ofpbuf_data(b);
+
flow->tp_src = sctp->sctp_src;
flow->tp_dst = sctp->sctp_dst;
- packet->l7 = b->data;
}
}
-static bool
+static void
parse_icmpv6(struct ofpbuf *b, struct flow *flow)
{
const struct icmp6_hdr *icmp = pull_icmpv6(b);
if (!icmp) {
- return false;
+ return;
}
/* The ICMPv6 type and code fields use the 16-bit transport port
nd_target = ofpbuf_try_pull(b, sizeof *nd_target);
if (!nd_target) {
- return false;
+ return;
}
flow->nd_target = *nd_target;
- while (b->size >= 8) {
+ while (ofpbuf_size(b) >= 8) {
/* The minimum size of an option is 8 bytes, which also is
* the size of Ethernet link-layer options. */
- const struct nd_opt_hdr *nd_opt = b->data;
+ const struct nd_opt_hdr *nd_opt = ofpbuf_data(b);
int opt_len = nd_opt->nd_opt_len * 8;
- if (!opt_len || opt_len > b->size) {
+ if (!opt_len || opt_len > ofpbuf_size(b)) {
goto invalid;
}
}
}
- return true;
+ return;
invalid:
memset(&flow->nd_target, 0, sizeof(flow->nd_target));
memset(flow->arp_sha, 0, sizeof(flow->arp_sha));
memset(flow->arp_tha, 0, sizeof(flow->arp_tha));
- return false;
-
+ return;
}
/* Initializes 'flow' members from 'packet' and 'md'
*
- * Initializes 'packet' header pointers as follows:
+ * Initializes 'packet' header l2 pointer to the start of the Ethernet
+ * header, and the layer offsets as follows:
*
- * - packet->l2 to the start of the Ethernet header.
+ * - packet->l2_5_ofs to the start of the MPLS shim header, or UINT16_MAX
+ * when there is no MPLS shim header.
*
- * - packet->l2_5 to the start of the MPLS shim header.
- *
- * - packet->l3 to just past the Ethernet header, or just past the
+ * - packet->l3_ofs to just past the Ethernet header, or just past the
* vlan_header if one is present, to the first byte of the payload of the
- * Ethernet frame.
- *
- * - packet->l4 to just past the IPv4 header, if one is present and has a
- * correct length, and otherwise NULL.
+ * Ethernet frame. UINT16_MAX if the frame is too short to contain an
+ * Ethernet header.
*
- * - packet->l7 to just past the TCP/UDP/SCTP/ICMP header, if one is
- * present and has a correct length, and otherwise NULL.
+ * - packet->l4_ofs to just past the IPv4 header, if one is present and
+ * has at least the content used for the fields of interest for the flow,
+ * otherwise UINT16_MAX.
*/
void
flow_extract(struct ofpbuf *packet, const struct pkt_metadata *md,
if (md) {
flow->tunnel = md->tunnel;
- if (md->in_port.odp_port != ODPP_NONE) {
- flow->in_port = md->in_port;
- };
+ flow->in_port = md->in_port;
flow->skb_priority = md->skb_priority;
flow->pkt_mark = md->pkt_mark;
}
- packet->l2 = b.data;
- packet->l2_5 = NULL;
- packet->l3 = NULL;
- packet->l4 = NULL;
- packet->l7 = NULL;
+ ofpbuf_set_frame(packet, ofpbuf_data(packet));
- if (b.size < sizeof *eth) {
+ if (ofpbuf_size(&b) < sizeof *eth) {
return;
}
/* Link layer. */
- eth = b.data;
+ eth = ofpbuf_data(&b);
memcpy(flow->dl_src, eth->eth_src, ETH_ADDR_LEN);
memcpy(flow->dl_dst, eth->eth_dst, ETH_ADDR_LEN);
/* Parse mpls, copy l3 ttl. */
if (eth_type_mpls(flow->dl_type)) {
- packet->l2_5 = b.data;
+ ofpbuf_set_l2_5(packet, ofpbuf_data(&b));
parse_mpls(&b, flow);
}
/* Network layer. */
- packet->l3 = b.data;
+ ofpbuf_set_l3(packet, ofpbuf_data(&b));
if (flow->dl_type == htons(ETH_TYPE_IP)) {
const struct ip_header *nh = pull_ip(&b);
if (nh) {
- packet->l4 = b.data;
+ ofpbuf_set_l4(packet, ofpbuf_data(&b));
flow->nw_src = get_16aligned_be32(&nh->ip_src);
flow->nw_dst = get_16aligned_be32(&nh->ip_dst);
if (!(nh->ip_frag_off & htons(IP_FRAG_OFF_MASK))) {
if (flow->nw_proto == IPPROTO_TCP) {
- parse_tcp(packet, &b, flow);
+ parse_tcp(&b, flow);
} else if (flow->nw_proto == IPPROTO_UDP) {
- parse_udp(packet, &b, flow);
+ parse_udp(&b, flow);
} else if (flow->nw_proto == IPPROTO_SCTP) {
- parse_sctp(packet, &b, flow);
+ parse_sctp(&b, flow);
} else if (flow->nw_proto == IPPROTO_ICMP) {
const struct icmp_header *icmp = pull_icmp(&b);
if (icmp) {
flow->tp_src = htons(icmp->icmp_type);
flow->tp_dst = htons(icmp->icmp_code);
- packet->l7 = b.data;
}
}
}
return;
}
- packet->l4 = b.data;
+ ofpbuf_set_l4(packet, ofpbuf_data(&b));
if (flow->nw_proto == IPPROTO_TCP) {
- parse_tcp(packet, &b, flow);
+ parse_tcp(&b, flow);
} else if (flow->nw_proto == IPPROTO_UDP) {
- parse_udp(packet, &b, flow);
+ parse_udp(&b, flow);
} else if (flow->nw_proto == IPPROTO_SCTP) {
- parse_sctp(packet, &b, flow);
+ parse_sctp(&b, flow);
} else if (flow->nw_proto == IPPROTO_ICMPV6) {
- if (parse_icmpv6(&b, flow)) {
- packet->l7 = b.data;
- }
+ parse_icmpv6(&b, flow);
}
} else if (flow->dl_type == htons(ETH_TYPE_ARP) ||
flow->dl_type == htons(ETH_TYPE_RARP)) {
void
flow_get_metadata(const struct flow *flow, struct flow_metadata *fmd)
{
- BUILD_ASSERT_DECL(FLOW_WC_SEQ == 24);
+ BUILD_ASSERT_DECL(FLOW_WC_SEQ == 25);
+ fmd->dp_hash = flow->dp_hash;
+ fmd->recirc_id = flow->recirc_id;
fmd->tun_id = flow->tunnel.tun_id;
fmd->tun_src = flow->tunnel.ip_src;
fmd->tun_dst = flow->tunnel.ip_dst;
wc->masks.regs[idx] = mask;
}
+/* Calculates the 5-tuple hash from the given flow. */
+uint32_t
+flow_hash_5tuple(const struct flow *flow, uint32_t basis)
+{
+ uint32_t hash = 0;
+
+ if (!flow) {
+ return 0;
+ }
+
+ hash = mhash_add(basis, (OVS_FORCE uint32_t) flow->nw_src);
+ hash = mhash_add(hash, (OVS_FORCE uint32_t) flow->nw_dst);
+ hash = mhash_add(hash, ((OVS_FORCE uint32_t) flow->tp_src << 16)
+ | (OVS_FORCE uint32_t) flow->tp_dst);
+ hash = mhash_add(hash, flow->nw_proto);
+
+ return mhash_finish(hash, 13);
+}
+
/* Hashes 'flow' based on its L2 through L4 protocol information. */
uint32_t
flow_hash_symmetric_l4(const struct flow *flow, uint32_t basis)
flow->mpls_lse[0] = set_mpls_lse_values(ttl, tc, 1, htonl(label));
/* Clear all L3 and L4 fields. */
- BUILD_ASSERT(FLOW_WC_SEQ == 24);
+ BUILD_ASSERT(FLOW_WC_SEQ == 25);
memset((char *) flow + FLOW_SEGMENT_2_ENDS_AT, 0,
sizeof(struct flow) - FLOW_SEGMENT_2_ENDS_AT);
}
flow->mpls_lse[idx] = lse;
}
-static void
+static size_t
flow_compose_l4(struct ofpbuf *b, const struct flow *flow)
{
+ size_t l4_len = 0;
+
if (!(flow->nw_frag & FLOW_NW_FRAG_ANY)
|| !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
if (flow->nw_proto == IPPROTO_TCP) {
struct tcp_header *tcp;
- tcp = ofpbuf_put_zeros(b, sizeof *tcp);
+ l4_len = sizeof *tcp;
+ tcp = ofpbuf_put_zeros(b, l4_len);
tcp->tcp_src = flow->tp_src;
tcp->tcp_dst = flow->tp_dst;
tcp->tcp_ctl = TCP_CTL(ntohs(flow->tcp_flags), 5);
- b->l7 = ofpbuf_tail(b);
} else if (flow->nw_proto == IPPROTO_UDP) {
struct udp_header *udp;
- udp = ofpbuf_put_zeros(b, sizeof *udp);
+ l4_len = sizeof *udp;
+ udp = ofpbuf_put_zeros(b, l4_len);
udp->udp_src = flow->tp_src;
udp->udp_dst = flow->tp_dst;
- b->l7 = ofpbuf_tail(b);
} else if (flow->nw_proto == IPPROTO_SCTP) {
struct sctp_header *sctp;
- sctp = ofpbuf_put_zeros(b, sizeof *sctp);
+ l4_len = sizeof *sctp;
+ sctp = ofpbuf_put_zeros(b, l4_len);
sctp->sctp_src = flow->tp_src;
sctp->sctp_dst = flow->tp_dst;
- b->l7 = ofpbuf_tail(b);
} else if (flow->nw_proto == IPPROTO_ICMP) {
struct icmp_header *icmp;
- icmp = ofpbuf_put_zeros(b, sizeof *icmp);
+ l4_len = sizeof *icmp;
+ icmp = ofpbuf_put_zeros(b, l4_len);
icmp->icmp_type = ntohs(flow->tp_src);
icmp->icmp_code = ntohs(flow->tp_dst);
icmp->icmp_csum = csum(icmp, ICMP_HEADER_LEN);
- b->l7 = ofpbuf_tail(b);
} else if (flow->nw_proto == IPPROTO_ICMPV6) {
struct icmp6_hdr *icmp;
- icmp = ofpbuf_put_zeros(b, sizeof *icmp);
+ l4_len = sizeof *icmp;
+ icmp = ofpbuf_put_zeros(b, l4_len);
icmp->icmp6_type = ntohs(flow->tp_src);
icmp->icmp6_code = ntohs(flow->tp_dst);
struct in6_addr *nd_target;
struct nd_opt_hdr *nd_opt;
+ l4_len += sizeof *nd_target;
nd_target = ofpbuf_put_zeros(b, sizeof *nd_target);
*nd_target = flow->nd_target;
if (!eth_addr_is_zero(flow->arp_sha)) {
+ l4_len += 8;
nd_opt = ofpbuf_put_zeros(b, 8);
nd_opt->nd_opt_len = 1;
nd_opt->nd_opt_type = ND_OPT_SOURCE_LINKADDR;
memcpy(nd_opt + 1, flow->arp_sha, ETH_ADDR_LEN);
}
if (!eth_addr_is_zero(flow->arp_tha)) {
+ l4_len += 8;
nd_opt = ofpbuf_put_zeros(b, 8);
nd_opt->nd_opt_len = 1;
nd_opt->nd_opt_type = ND_OPT_TARGET_LINKADDR;
}
icmp->icmp6_cksum = (OVS_FORCE uint16_t)
csum(icmp, (char *)ofpbuf_tail(b) - (char *)icmp);
- b->l7 = ofpbuf_tail(b);
}
}
+ return l4_len;
}
/* Puts into 'b' a packet that flow_extract() would parse as having the given
void
flow_compose(struct ofpbuf *b, const struct flow *flow)
{
+ size_t l4_len;
+
/* eth_compose() sets l3 pointer and makes sure it is 32-bit aligned. */
eth_compose(b, flow->dl_dst, flow->dl_src, ntohs(flow->dl_type), 0);
if (flow->dl_type == htons(FLOW_DL_TYPE_NONE)) {
- struct eth_header *eth = b->l2;
- eth->eth_type = htons(b->size);
+ struct eth_header *eth = ofpbuf_l2(b);
+ eth->eth_type = htons(ofpbuf_size(b));
return;
}
}
}
- b->l4 = ofpbuf_tail(b);
+ ofpbuf_set_l4(b, ofpbuf_tail(b));
- flow_compose_l4(b, flow);
+ l4_len = flow_compose_l4(b, flow);
- ip->ip_tot_len = htons((uint8_t *) b->data + b->size
- - (uint8_t *) b->l3);
+ ip->ip_tot_len = htons(b->l4_ofs - b->l3_ofs + l4_len);
ip->ip_csum = csum(ip, sizeof *ip);
} else if (flow->dl_type == htons(ETH_TYPE_IPV6)) {
struct ovs_16aligned_ip6_hdr *nh;
memcpy(&nh->ip6_src, &flow->ipv6_src, sizeof(nh->ip6_src));
memcpy(&nh->ip6_dst, &flow->ipv6_dst, sizeof(nh->ip6_dst));
- b->l4 = ofpbuf_tail(b);
+ ofpbuf_set_l4(b, ofpbuf_tail(b));
- flow_compose_l4(b, flow);
+ l4_len = flow_compose_l4(b, flow);
- nh->ip6_plen =
- b->l7 ? htons((uint8_t *) b->l7 - (uint8_t *) b->l4) : htons(0);
+ nh->ip6_plen = htons(l4_len);
} else if (flow->dl_type == htons(ETH_TYPE_ARP) ||
flow->dl_type == htons(ETH_TYPE_RARP)) {
struct arp_eth_header *arp;
- b->l3 = arp = ofpbuf_put_zeros(b, sizeof *arp);
+ arp = ofpbuf_put_zeros(b, sizeof *arp);
+ ofpbuf_set_l3(b, arp);
arp->ar_hrd = htons(1);
arp->ar_pro = htons(ETH_TYPE_IP);
arp->ar_hln = ETH_ADDR_LEN;
if (eth_type_mpls(flow->dl_type)) {
int n;
- b->l2_5 = b->l3;
+ b->l2_5_ofs = b->l3_ofs;
for (n = 1; n < FLOW_MAX_MPLS_LABELS; n++) {
if (flow->mpls_lse[n - 1] & htonl(MPLS_BOS_MASK)) {
break;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff