lib/packets.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "packets.h"
  19 #include <arpa/inet.h>
  20 #include <sys/socket.h>
  21 #include <netinet/in.h>
  22 #include <netinet/ip6.h>
  23 #include <stdlib.h>
  24 #include "byte-order.h"
  25 #include "csum.h"
  26 #include "crc32c.h"
  27 #include "flow.h"
  28 #include "hmap.h"
  29 #include "dynamic-string.h"
  30 #include "ofpbuf.h"
  31 #include "ovs-thread.h"
  32 #include "odp-util.h"
  33 #include "unaligned.h"
  34
  35 const struct in6_addr in6addr_exact = IN6ADDR_EXACT_INIT;
  36
  37 /* Parses 's' as a 16-digit hexadecimal number representing a datapath ID.  On
  38  * success stores the dpid into '*dpidp' and returns true, on failure stores 0
  39  * into '*dpidp' and returns false.
  40  *
  41  * Rejects an all-zeros dpid as invalid. */
  42 bool
  43 dpid_from_string(const char *s, uint64_t *dpidp)
  44 {
  45     *dpidp = (strlen(s) == 16 && strspn(s, "0123456789abcdefABCDEF") == 16
  46               ? strtoull(s, NULL, 16)
  47               : 0);
  48     return *dpidp != 0;
  49 }
  50
  51 /* Returns true if 'ea' is a reserved address, that a bridge must never
  52  * forward, false otherwise.
  53  *
  54  * If you change this function's behavior, please update corresponding
  55  * documentation in vswitch.xml at the same time. */
  56 bool
  57 eth_addr_is_reserved(const uint8_t ea[ETH_ADDR_LEN])
  58 {
  59     struct eth_addr_node {
  60         struct hmap_node hmap_node;
  61         const uint64_t ea64;
  62     };
  63
  64     static struct eth_addr_node nodes[] = {
  65         /* STP, IEEE pause frames, and other reserved protocols. */
  66         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000000ULL },
  67         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000001ULL },
  68         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000002ULL },
  69         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000003ULL },
  70         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000004ULL },
  71         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000005ULL },
  72         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000006ULL },
  73         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000007ULL },
  74         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000008ULL },
  75         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000009ULL },
  76         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000aULL },
  77         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000bULL },
  78         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000cULL },
  79         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000dULL },
  80         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000eULL },
  81         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000fULL },
  82
  83         /* Extreme protocols. */
  84         { HMAP_NODE_NULL_INITIALIZER, 0x00e02b000000ULL }, /* EDP. */
  85         { HMAP_NODE_NULL_INITIALIZER, 0x00e02b000004ULL }, /* EAPS. */
  86         { HMAP_NODE_NULL_INITIALIZER, 0x00e02b000006ULL }, /* EAPS. */
  87
  88         /* Cisco protocols. */
  89         { HMAP_NODE_NULL_INITIALIZER, 0x01000c000000ULL }, /* ISL. */
  90         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccccULL }, /* PAgP, UDLD, CDP,
  91                                                             * DTP, VTP. */
  92         { HMAP_NODE_NULL_INITIALIZER, 0x01000ccccccdULL }, /* PVST+. */
  93         { HMAP_NODE_NULL_INITIALIZER, 0x01000ccdcdcdULL }, /* STP Uplink Fast,
  94                                                             * FlexLink. */
  95
  96         /* Cisco CFM. */
  97         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc0ULL },
  98         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc1ULL },
  99         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc2ULL },
 100         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc3ULL },
 101         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc4ULL },
 102         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc5ULL },
 103         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc6ULL },
 104         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc7ULL },
 105     };
 106
 107     static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
 108     struct eth_addr_node *node;
 109     static struct hmap addrs;
 110     uint64_t ea64;
 111
 112     if (ovsthread_once_start(&once)) {
 113         hmap_init(&addrs);
 114         for (node = nodes; node < &nodes[ARRAY_SIZE(nodes)]; node++) {
 115             hmap_insert(&addrs, &node->hmap_node, hash_uint64(node->ea64));
 116         }
 117         ovsthread_once_done(&once);
 118     }
 119
 120     ea64 = eth_addr_to_uint64(ea);
 121     HMAP_FOR_EACH_IN_BUCKET (node, hmap_node, hash_uint64(ea64), &addrs) {
 122         if (node->ea64 == ea64) {
 123             return true;
 124         }
 125     }
 126     return false;
 127 }
 128
 129 bool
 130 eth_addr_from_string(const char *s, uint8_t ea[ETH_ADDR_LEN])
 131 {
 132     if (ovs_scan(s, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(ea))) {
 133         return true;
 134     } else {
 135         memset(ea, 0, ETH_ADDR_LEN);
 136         return false;
 137     }
 138 }
 139
 140 /* Fills 'b' with a Reverse ARP packet with Ethernet source address 'eth_src'.
 141  * This function is used by Open vSwitch to compose packets in cases where
 142  * context is important but content doesn't (or shouldn't) matter.
 143  *
 144  * The returned packet has enough headroom to insert an 802.1Q VLAN header if
 145  * desired. */
 146 void
 147 compose_rarp(struct ofpbuf *b, const uint8_t eth_src[ETH_ADDR_LEN])
 148 {
 149     struct eth_header *eth;
 150     struct arp_eth_header *arp;
 151
 152     ofpbuf_clear(b);
 153     ofpbuf_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN
 154                              + ARP_ETH_HEADER_LEN);
 155     ofpbuf_reserve(b, 2 + VLAN_HEADER_LEN);
 156     eth = ofpbuf_put_uninit(b, sizeof *eth);
 157     memcpy(eth->eth_dst, eth_addr_broadcast, ETH_ADDR_LEN);
 158     memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
 159     eth->eth_type = htons(ETH_TYPE_RARP);
 160
 161     arp = ofpbuf_put_uninit(b, sizeof *arp);
 162     arp->ar_hrd = htons(ARP_HRD_ETHERNET);
 163     arp->ar_pro = htons(ARP_PRO_IP);
 164     arp->ar_hln = sizeof arp->ar_sha;
 165     arp->ar_pln = sizeof arp->ar_spa;
 166     arp->ar_op = htons(ARP_OP_RARP);
 167     memcpy(arp->ar_sha, eth_src, ETH_ADDR_LEN);
 168     put_16aligned_be32(&arp->ar_spa, htonl(0));
 169     memcpy(arp->ar_tha, eth_src, ETH_ADDR_LEN);
 170     put_16aligned_be32(&arp->ar_tpa, htonl(0));
 171 }
 172
 173 /* Insert VLAN header according to given TCI. Packet passed must be Ethernet
 174  * packet.  Ignores the CFI bit of 'tci' using 0 instead.
 175  *
 176  * Also sets 'packet->l2' to point to the new Ethernet header. */
 177 void
 178 eth_push_vlan(struct ofpbuf *packet, ovs_be16 tpid, ovs_be16 tci)
 179 {
 180     struct eth_header *eh = packet->data;
 181     struct vlan_eth_header *veh;
 182
 183     /* Insert new 802.1Q header. */
 184     struct vlan_eth_header tmp;
 185     memcpy(tmp.veth_dst, eh->eth_dst, ETH_ADDR_LEN);
 186     memcpy(tmp.veth_src, eh->eth_src, ETH_ADDR_LEN);
 187     tmp.veth_type = tpid;
 188     tmp.veth_tci = tci & htons(~VLAN_CFI);
 189     tmp.veth_next_type = eh->eth_type;
 190
 191     veh = ofpbuf_push_uninit(packet, VLAN_HEADER_LEN);
 192     memcpy(veh, &tmp, sizeof tmp);
 193
 194     packet->l2 = packet->data;
 195 }
 196
 197 /* Removes outermost VLAN header (if any is present) from 'packet'.
 198  *
 199  * 'packet->l2_5' should initially point to 'packet''s outer-most MPLS header
 200  * or may be NULL if there are no MPLS headers. */
 201 void
 202 eth_pop_vlan(struct ofpbuf *packet)
 203 {
 204     struct vlan_eth_header *veh = packet->l2;
 205     if (packet->size >= sizeof *veh
 206         && veh->veth_type == htons(ETH_TYPE_VLAN)) {
 207         struct eth_header tmp;
 208
 209         memcpy(tmp.eth_dst, veh->veth_dst, ETH_ADDR_LEN);
 210         memcpy(tmp.eth_src, veh->veth_src, ETH_ADDR_LEN);
 211         tmp.eth_type = veh->veth_next_type;
 212
 213         ofpbuf_pull(packet, VLAN_HEADER_LEN);
 214         packet->l2 = (char*)packet->l2 + VLAN_HEADER_LEN;
 215         memcpy(packet->data, &tmp, sizeof tmp);
 216     }
 217 }
 218
 219 /* Set ethertype of the packet. */
 220 static void
 221 set_ethertype(struct ofpbuf *packet, ovs_be16 eth_type)
 222 {
 223     struct eth_header *eh = packet->data;
 224
 225     if (eh->eth_type == htons(ETH_TYPE_VLAN)) {
 226         ovs_be16 *p;
 227         p = ALIGNED_CAST(ovs_be16 *,
 228                 (char *)(packet->l2_5 ? packet->l2_5 : packet->l3) - 2);
 229         *p = eth_type;
 230     } else {
 231         eh->eth_type = eth_type;
 232     }
 233 }
 234
 235 static bool is_mpls(struct ofpbuf *packet)
 236 {
 237     return packet->l2_5 != NULL;
 238 }
 239
 240 /* Set time to live (TTL) of an MPLS label stack entry (LSE). */
 241 void
 242 set_mpls_lse_ttl(ovs_be32 *lse, uint8_t ttl)
 243 {
 244     *lse &= ~htonl(MPLS_TTL_MASK);
 245     *lse |= htonl((ttl << MPLS_TTL_SHIFT) & MPLS_TTL_MASK);
 246 }
 247
 248 /* Set traffic class (TC) of an MPLS label stack entry (LSE). */
 249 void
 250 set_mpls_lse_tc(ovs_be32 *lse, uint8_t tc)
 251 {
 252     *lse &= ~htonl(MPLS_TC_MASK);
 253     *lse |= htonl((tc << MPLS_TC_SHIFT) & MPLS_TC_MASK);
 254 }
 255
 256 /* Set label of an MPLS label stack entry (LSE). */
 257 void
 258 set_mpls_lse_label(ovs_be32 *lse, ovs_be32 label)
 259 {
 260     *lse &= ~htonl(MPLS_LABEL_MASK);
 261     *lse |= htonl((ntohl(label) << MPLS_LABEL_SHIFT) & MPLS_LABEL_MASK);
 262 }
 263
 264 /* Set bottom of stack (BoS) bit of an MPLS label stack entry (LSE). */
 265 void
 266 set_mpls_lse_bos(ovs_be32 *lse, uint8_t bos)
 267 {
 268     *lse &= ~htonl(MPLS_BOS_MASK);
 269     *lse |= htonl((bos << MPLS_BOS_SHIFT) & MPLS_BOS_MASK);
 270 }
 271
 272 /* Compose an MPLS label stack entry (LSE) from its components:
 273  * label, traffic class (TC), time to live (TTL) and
 274  * bottom of stack (BoS) bit. */
 275 ovs_be32
 276 set_mpls_lse_values(uint8_t ttl, uint8_t tc, uint8_t bos, ovs_be32 label)
 277 {
 278     ovs_be32 lse = htonl(0);
 279     set_mpls_lse_ttl(&lse, ttl);
 280     set_mpls_lse_tc(&lse, tc);
 281     set_mpls_lse_bos(&lse, bos);
 282     set_mpls_lse_label(&lse, label);
 283     return lse;
 284 }
 285
 286 /* Push an new MPLS stack entry onto the MPLS stack and adjust 'packet->l2' and
 287  * 'packet->l2_5' accordingly.  The new entry will be the outermost entry on
 288  * the stack.
 289  *
 290  * Previous to calling this function, 'packet->l2_5' must be set; if the MPLS
 291  * label to be pushed will be the first label in 'packet', then it should be
 292  * the same as 'packet->l3'. */
 293 static void
 294 push_mpls_lse(struct ofpbuf *packet, struct mpls_hdr *mh)
 295 {
 296     char * header;
 297     size_t len;
 298     header = ofpbuf_push_uninit(packet, MPLS_HLEN);
 299     len = (char *)packet->l2_5 - (char *)packet->l2;
 300     memmove(header, packet->l2, len);
 301     memcpy(header + len, mh, sizeof *mh);
 302     packet->l2 = (char*)packet->l2 - MPLS_HLEN;
 303     packet->l2_5 = (char*)packet->l2_5 - MPLS_HLEN;
 304 }
 305
 306 /* Set MPLS label stack entry to outermost MPLS header.*/
 307 void
 308 set_mpls_lse(struct ofpbuf *packet, ovs_be32 mpls_lse)
 309 {
 310     struct mpls_hdr *mh = packet->l2_5;
 311
 312     /* Packet type should be MPLS to set label stack entry. */
 313     if (is_mpls(packet)) {
 314         /* Update mpls label stack entry. */
 315         mh->mpls_lse = mpls_lse;
 316     }
 317 }
 318
 319 /* Push MPLS label stack entry 'lse' onto 'packet' as the the outermost MPLS
 320  * header.  If 'packet' does not already have any MPLS labels, then its
 321  * Ethertype is changed to 'ethtype' (which must be an MPLS Ethertype). */
 322 void
 323 push_mpls(struct ofpbuf *packet, ovs_be16 ethtype, ovs_be32 lse)
 324 {
 325     struct mpls_hdr mh;
 326
 327     if (!eth_type_mpls(ethtype)) {
 328         return;
 329     }
 330
 331     set_ethertype(packet, ethtype);
 332
 333     if (!is_mpls(packet)) {
 334         /* Set MPLS label stack entry. */
 335         packet->l2_5 = packet->l3;
 336     }
 337
 338     /* Push new MPLS shim header onto packet. */
 339     mh.mpls_lse = lse;
 340     push_mpls_lse(packet, &mh);
 341 }
 342
 343 /* If 'packet' is an MPLS packet, removes its outermost MPLS label stack entry.
 344  * If the label that was removed was the only MPLS label, changes 'packet''s
 345  * Ethertype to 'ethtype' (which ordinarily should not be an MPLS
 346  * Ethertype). */
 347 void
 348 pop_mpls(struct ofpbuf *packet, ovs_be16 ethtype)
 349 {
 350     struct mpls_hdr *mh = NULL;
 351
 352     if (is_mpls(packet)) {
 353         size_t len;
 354         mh = packet->l2_5;
 355         len = (char*)packet->l2_5 - (char*)packet->l2;
 356         set_ethertype(packet, ethtype);
 357         if (mh->mpls_lse & htonl(MPLS_BOS_MASK)) {
 358             packet->l2_5 = NULL;
 359         } else {
 360             packet->l2_5 = (char*)packet->l2_5 + MPLS_HLEN;
 361         }
 362         /* Shift the l2 header forward. */
 363         memmove((char*)packet->data + MPLS_HLEN, packet->data, len);
 364         packet->size -= MPLS_HLEN;
 365         packet->data = (char*)packet->data + MPLS_HLEN;
 366         packet->l2 = (char*)packet->l2 + MPLS_HLEN;
 367     }
 368 }
 369
 370 /* Converts hex digits in 'hex' to an Ethernet packet in '*packetp'.  The
 371  * caller must free '*packetp'.  On success, returns NULL.  On failure, returns
 372  * an error message and stores NULL in '*packetp'.
 373  *
 374  * Aligns the L3 header of '*packetp' on a 32-bit boundary. */
 375 const char *
 376 eth_from_hex(const char *hex, struct ofpbuf **packetp)
 377 {
 378     struct ofpbuf *packet;
 379
 380     /* Use 2 bytes of headroom to 32-bit align the L3 header. */
 381     packet = *packetp = ofpbuf_new_with_headroom(strlen(hex) / 2, 2);
 382
 383     if (ofpbuf_put_hex(packet, hex, NULL)[0] != '\0') {
 384         ofpbuf_delete(packet);
 385         *packetp = NULL;
 386         return "Trailing garbage in packet data";
 387     }
 388
 389     if (packet->size < ETH_HEADER_LEN) {
 390         ofpbuf_delete(packet);
 391         *packetp = NULL;
 392         return "Packet data too short for Ethernet";
 393     }
 394
 395     return NULL;
 396 }
 397
 398 void
 399 eth_format_masked(const uint8_t eth[ETH_ADDR_LEN],
 400                   const uint8_t mask[ETH_ADDR_LEN], struct ds *s)
 401 {
 402     ds_put_format(s, ETH_ADDR_FMT, ETH_ADDR_ARGS(eth));
 403     if (mask && !eth_mask_is_exact(mask)) {
 404         ds_put_format(s, "/"ETH_ADDR_FMT, ETH_ADDR_ARGS(mask));
 405     }
 406 }
 407
 408 void
 409 eth_addr_bitand(const uint8_t src[ETH_ADDR_LEN],
 410                 const uint8_t mask[ETH_ADDR_LEN],
 411                 uint8_t dst[ETH_ADDR_LEN])
 412 {
 413     int i;
 414
 415     for (i = 0; i < ETH_ADDR_LEN; i++) {
 416         dst[i] = src[i] & mask[i];
 417     }
 418 }
 419
 420 /* Given the IP netmask 'netmask', returns the number of bits of the IP address
 421  * that it specifies, that is, the number of 1-bits in 'netmask'.
 422  *
 423  * If 'netmask' is not a CIDR netmask (see ip_is_cidr()), the return value will
 424  * still be in the valid range but isn't otherwise meaningful. */
 425 int
 426 ip_count_cidr_bits(ovs_be32 netmask)
 427 {
 428     return 32 - ctz32(ntohl(netmask));
 429 }
 430
 431 void
 432 ip_format_masked(ovs_be32 ip, ovs_be32 mask, struct ds *s)
 433 {
 434     ds_put_format(s, IP_FMT, IP_ARGS(ip));
 435     if (mask != OVS_BE32_MAX) {
 436         if (ip_is_cidr(mask)) {
 437             ds_put_format(s, "/%d", ip_count_cidr_bits(mask));
 438         } else {
 439             ds_put_format(s, "/"IP_FMT, IP_ARGS(mask));
 440         }
 441     }
 442 }
 443
 444
 445 /* Stores the string representation of the IPv6 address 'addr' into the
 446  * character array 'addr_str', which must be at least INET6_ADDRSTRLEN
 447  * bytes long. */
 448 void
 449 format_ipv6_addr(char *addr_str, const struct in6_addr *addr)
 450 {
 451     inet_ntop(AF_INET6, addr, addr_str, INET6_ADDRSTRLEN);
 452 }
 453
 454 void
 455 print_ipv6_addr(struct ds *string, const struct in6_addr *addr)
 456 {
 457     char *dst;
 458
 459     ds_reserve(string, string->length + INET6_ADDRSTRLEN);
 460
 461     dst = string->string + string->length;
 462     format_ipv6_addr(dst, addr);
 463     string->length += strlen(dst);
 464 }
 465
 466 void
 467 print_ipv6_masked(struct ds *s, const struct in6_addr *addr,
 468                   const struct in6_addr *mask)
 469 {
 470     print_ipv6_addr(s, addr);
 471     if (mask && !ipv6_mask_is_exact(mask)) {
 472         if (ipv6_is_cidr(mask)) {
 473             int cidr_bits = ipv6_count_cidr_bits(mask);
 474             ds_put_format(s, "/%d", cidr_bits);
 475         } else {
 476             ds_put_char(s, '/');
 477             print_ipv6_addr(s, mask);
 478         }
 479     }
 480 }
 481
 482 struct in6_addr ipv6_addr_bitand(const struct in6_addr *a,
 483                                  const struct in6_addr *b)
 484 {
 485     int i;
 486     struct in6_addr dst;
 487
 488 #ifdef s6_addr32
 489     for (i=0; i<4; i++) {
 490         dst.s6_addr32[i] = a->s6_addr32[i] & b->s6_addr32[i];
 491     }
 492 #else
 493     for (i=0; i<16; i++) {
 494         dst.s6_addr[i] = a->s6_addr[i] & b->s6_addr[i];
 495     }
 496 #endif
 497
 498     return dst;
 499 }
 500
 501 /* Returns an in6_addr consisting of 'mask' high-order 1-bits and 128-N
 502  * low-order 0-bits. */
 503 struct in6_addr
 504 ipv6_create_mask(int mask)
 505 {
 506     struct in6_addr netmask;
 507     uint8_t *netmaskp = &netmask.s6_addr[0];
 508
 509     memset(&netmask, 0, sizeof netmask);
 510     while (mask > 8) {
 511         *netmaskp = 0xff;
 512         netmaskp++;
 513         mask -= 8;
 514     }
 515
 516     if (mask) {
 517         *netmaskp = 0xff << (8 - mask);
 518     }
 519
 520     return netmask;
 521 }
 522
 523 /* Given the IPv6 netmask 'netmask', returns the number of bits of the IPv6
 524  * address that it specifies, that is, the number of 1-bits in 'netmask'.
 525  * 'netmask' must be a CIDR netmask (see ipv6_is_cidr()).
 526  *
 527  * If 'netmask' is not a CIDR netmask (see ipv6_is_cidr()), the return value
 528  * will still be in the valid range but isn't otherwise meaningful. */
 529 int
 530 ipv6_count_cidr_bits(const struct in6_addr *netmask)
 531 {
 532     int i;
 533     int count = 0;
 534     const uint8_t *netmaskp = &netmask->s6_addr[0];
 535
 536     for (i=0; i<16; i++) {
 537         if (netmaskp[i] == 0xff) {
 538             count += 8;
 539         } else {
 540             uint8_t nm;
 541
 542             for(nm = netmaskp[i]; nm; nm <<= 1) {
 543                 count++;
 544             }
 545             break;
 546         }
 547
 548     }
 549
 550     return count;
 551 }
 552
 553 /* Returns true if 'netmask' is a CIDR netmask, that is, if it consists of N
 554  * high-order 1-bits and 128-N low-order 0-bits. */
 555 bool
 556 ipv6_is_cidr(const struct in6_addr *netmask)
 557 {
 558     const uint8_t *netmaskp = &netmask->s6_addr[0];
 559     int i;
 560
 561     for (i=0; i<16; i++) {
 562         if (netmaskp[i] != 0xff) {
 563             uint8_t x = ~netmaskp[i];
 564             if (x & (x + 1)) {
 565                 return false;
 566             }
 567             while (++i < 16) {
 568                 if (netmaskp[i]) {
 569                     return false;
 570                 }
 571             }
 572         }
 573     }
 574
 575     return true;
 576 }
 577
 578 /* Populates 'b' with an Ethernet II packet headed with the given 'eth_dst',
 579  * 'eth_src' and 'eth_type' parameters.  A payload of 'size' bytes is allocated
 580  * in 'b' and returned.  This payload may be populated with appropriate
 581  * information by the caller.  Sets 'b''s 'l2' and 'l3' pointers to the
 582  * Ethernet header and payload respectively.  Aligns b->l3 on a 32-bit
 583  * boundary.
 584  *
 585  * The returned packet has enough headroom to insert an 802.1Q VLAN header if
 586  * desired. */
 587 void *
 588 eth_compose(struct ofpbuf *b, const uint8_t eth_dst[ETH_ADDR_LEN],
 589             const uint8_t eth_src[ETH_ADDR_LEN], uint16_t eth_type,
 590             size_t size)
 591 {
 592     void *data;
 593     struct eth_header *eth;
 594
 595     ofpbuf_clear(b);
 596
 597     /* The magic 2 here ensures that the L3 header (when it is added later)
 598      * will be 32-bit aligned. */
 599     ofpbuf_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN + size);
 600     ofpbuf_reserve(b, 2 + VLAN_HEADER_LEN);
 601     eth = ofpbuf_put_uninit(b, ETH_HEADER_LEN);
 602     data = ofpbuf_put_uninit(b, size);
 603
 604     memcpy(eth->eth_dst, eth_dst, ETH_ADDR_LEN);
 605     memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
 606     eth->eth_type = htons(eth_type);
 607
 608     b->l2 = eth;
 609     b->l3 = data;
 610
 611     return data;
 612 }
 613
 614 static void
 615 packet_set_ipv4_addr(struct ofpbuf *packet,
 616                      ovs_16aligned_be32 *addr, ovs_be32 new_addr)
 617 {
 618     struct ip_header *nh = packet->l3;
 619     ovs_be32 old_addr = get_16aligned_be32(addr);
 620     size_t l4_size = ofpbuf_get_l4_size(packet);
 621
 622     if (nh->ip_proto == IPPROTO_TCP && l4_size >= TCP_HEADER_LEN) {
 623         struct tcp_header *th = packet->l4;
 624
 625         th->tcp_csum = recalc_csum32(th->tcp_csum, old_addr, new_addr);
 626     } else if (nh->ip_proto == IPPROTO_UDP && l4_size >= UDP_HEADER_LEN ) {
 627         struct udp_header *uh = packet->l4;
 628
 629         if (uh->udp_csum) {
 630             uh->udp_csum = recalc_csum32(uh->udp_csum, old_addr, new_addr);
 631             if (!uh->udp_csum) {
 632                 uh->udp_csum = htons(0xffff);
 633             }
 634         }
 635     }
 636     nh->ip_csum = recalc_csum32(nh->ip_csum, old_addr, new_addr);
 637     put_16aligned_be32(addr, new_addr);
 638 }
 639
 640 /* Returns true, if packet contains at least one routing header where
 641  * segements_left > 0.
 642  *
 643  * This function assumes that L3 and L4 markers are set in the packet. */
 644 static bool
 645 packet_rh_present(struct ofpbuf *packet)
 646 {
 647     const struct ovs_16aligned_ip6_hdr *nh;
 648     int nexthdr;
 649     size_t len;
 650     size_t remaining;
 651     uint8_t *data = packet->l3;
 652
 653     remaining = (uint8_t *)packet->l4 - (uint8_t *)packet->l3;
 654
 655     if (remaining < sizeof *nh) {
 656         return false;
 657     }
 658     nh = ALIGNED_CAST(struct ovs_16aligned_ip6_hdr *, data);
 659     data += sizeof *nh;
 660     remaining -= sizeof *nh;
 661     nexthdr = nh->ip6_nxt;
 662
 663     while (1) {
 664         if ((nexthdr != IPPROTO_HOPOPTS)
 665                 && (nexthdr != IPPROTO_ROUTING)
 666                 && (nexthdr != IPPROTO_DSTOPTS)
 667                 && (nexthdr != IPPROTO_AH)
 668                 && (nexthdr != IPPROTO_FRAGMENT)) {
 669             /* It's either a terminal header (e.g., TCP, UDP) or one we
 670              * don't understand.  In either case, we're done with the
 671              * packet, so use it to fill in 'nw_proto'. */
 672             break;
 673         }
 674
 675         /* We only verify that at least 8 bytes of the next header are
 676          * available, but many of these headers are longer.  Ensure that
 677          * accesses within the extension header are within those first 8
 678          * bytes. All extension headers are required to be at least 8
 679          * bytes. */
 680         if (remaining < 8) {
 681             return false;
 682         }
 683
 684         if (nexthdr == IPPROTO_AH) {
 685             /* A standard AH definition isn't available, but the fields
 686              * we care about are in the same location as the generic
 687              * option header--only the header length is calculated
 688              * differently. */
 689             const struct ip6_ext *ext_hdr = (struct ip6_ext *)data;
 690
 691             nexthdr = ext_hdr->ip6e_nxt;
 692             len = (ext_hdr->ip6e_len + 2) * 4;
 693         } else if (nexthdr == IPPROTO_FRAGMENT) {
 694             const struct ovs_16aligned_ip6_frag *frag_hdr
 695                 = ALIGNED_CAST(struct ovs_16aligned_ip6_frag *, data);
 696
 697             nexthdr = frag_hdr->ip6f_nxt;
 698             len = sizeof *frag_hdr;
 699         } else if (nexthdr == IPPROTO_ROUTING) {
 700             const struct ip6_rthdr *rh = (struct ip6_rthdr *)data;
 701
 702             if (rh->ip6r_segleft > 0) {
 703                 return true;
 704             }
 705
 706             nexthdr = rh->ip6r_nxt;
 707             len = (rh->ip6r_len + 1) * 8;
 708         } else {
 709             const struct ip6_ext *ext_hdr = (struct ip6_ext *)data;
 710
 711             nexthdr = ext_hdr->ip6e_nxt;
 712             len = (ext_hdr->ip6e_len + 1) * 8;
 713         }
 714
 715         if (remaining < len) {
 716             return false;
 717         }
 718         remaining -= len;
 719         data += len;
 720     }
 721
 722     return false;
 723 }
 724
 725 static void
 726 packet_update_csum128(struct ofpbuf *packet, uint8_t proto,
 727                      ovs_16aligned_be32 addr[4], const ovs_be32 new_addr[4])
 728 {
 729     size_t l4_size = ofpbuf_get_l4_size(packet);
 730
 731     if (proto == IPPROTO_TCP && l4_size >= TCP_HEADER_LEN) {
 732         struct tcp_header *th = packet->l4;
 733
 734         th->tcp_csum = recalc_csum128(th->tcp_csum, addr, new_addr);
 735     } else if (proto == IPPROTO_UDP && l4_size >= UDP_HEADER_LEN) {
 736         struct udp_header *uh = packet->l4;
 737
 738         if (uh->udp_csum) {
 739             uh->udp_csum = recalc_csum128(uh->udp_csum, addr, new_addr);
 740             if (!uh->udp_csum) {
 741                 uh->udp_csum = htons(0xffff);
 742             }
 743         }
 744     }
 745 }
 746
 747 static void
 748 packet_set_ipv6_addr(struct ofpbuf *packet, uint8_t proto,
 749                      ovs_16aligned_be32 addr[4], const ovs_be32 new_addr[4],
 750                      bool recalculate_csum)
 751 {
 752     if (recalculate_csum) {
 753         packet_update_csum128(packet, proto, addr, new_addr);
 754     }
 755     memcpy(addr, new_addr, sizeof(ovs_be32[4]));
 756 }
 757
 758 static void
 759 packet_set_ipv6_flow_label(ovs_16aligned_be32 *flow_label, ovs_be32 flow_key)
 760 {
 761     ovs_be32 old_label = get_16aligned_be32(flow_label);
 762     ovs_be32 new_label = (old_label & htonl(~IPV6_LABEL_MASK)) | flow_key;
 763     put_16aligned_be32(flow_label, new_label);
 764 }
 765
 766 static void
 767 packet_set_ipv6_tc(ovs_16aligned_be32 *flow_label, uint8_t tc)
 768 {
 769     ovs_be32 old_label = get_16aligned_be32(flow_label);
 770     ovs_be32 new_label = (old_label & htonl(0xF00FFFFF)) | htonl(tc << 20);
 771     put_16aligned_be32(flow_label, new_label);
 772 }
 773
 774 /* Modifies the IPv4 header fields of 'packet' to be consistent with 'src',
 775  * 'dst', 'tos', and 'ttl'.  Updates 'packet''s L4 checksums as appropriate.
 776  * 'packet' must contain a valid IPv4 packet with correctly populated l[347]
 777  * markers. */
 778 void
 779 packet_set_ipv4(struct ofpbuf *packet, ovs_be32 src, ovs_be32 dst,
 780                 uint8_t tos, uint8_t ttl)
 781 {
 782     struct ip_header *nh = packet->l3;
 783
 784     if (get_16aligned_be32(&nh->ip_src) != src) {
 785         packet_set_ipv4_addr(packet, &nh->ip_src, src);
 786     }
 787
 788     if (get_16aligned_be32(&nh->ip_dst) != dst) {
 789         packet_set_ipv4_addr(packet, &nh->ip_dst, dst);
 790     }
 791
 792     if (nh->ip_tos != tos) {
 793         uint8_t *field = &nh->ip_tos;
 794
 795         nh->ip_csum = recalc_csum16(nh->ip_csum, htons((uint16_t) *field),
 796                                     htons((uint16_t) tos));
 797         *field = tos;
 798     }
 799
 800     if (nh->ip_ttl != ttl) {
 801         uint8_t *field = &nh->ip_ttl;
 802
 803         nh->ip_csum = recalc_csum16(nh->ip_csum, htons(*field << 8),
 804                                     htons(ttl << 8));
 805         *field = ttl;
 806     }
 807 }
 808
 809 /* Modifies the IPv6 header fields of 'packet' to be consistent with 'src',
 810  * 'dst', 'traffic class', and 'next hop'.  Updates 'packet''s L4 checksums as
 811  * appropriate. 'packet' must contain a valid IPv6 packet with correctly
 812  * populated l[347] markers. */
 813 void
 814 packet_set_ipv6(struct ofpbuf *packet, uint8_t proto, const ovs_be32 src[4],
 815                 const ovs_be32 dst[4], uint8_t key_tc, ovs_be32 key_fl,
 816                 uint8_t key_hl)
 817 {
 818     struct ovs_16aligned_ip6_hdr *nh = packet->l3;
 819
 820     if (memcmp(&nh->ip6_src, src, sizeof(ovs_be32[4]))) {
 821         packet_set_ipv6_addr(packet, proto, nh->ip6_src.be32, src, true);
 822     }
 823
 824     if (memcmp(&nh->ip6_dst, dst, sizeof(ovs_be32[4]))) {
 825         packet_set_ipv6_addr(packet, proto, nh->ip6_dst.be32, dst,
 826                              !packet_rh_present(packet));
 827     }
 828
 829     packet_set_ipv6_tc(&nh->ip6_flow, key_tc);
 830
 831     packet_set_ipv6_flow_label(&nh->ip6_flow, key_fl);
 832
 833     nh->ip6_hlim = key_hl;
 834 }
 835
 836 static void
 837 packet_set_port(ovs_be16 *port, ovs_be16 new_port, ovs_be16 *csum)
 838 {
 839     if (*port != new_port) {
 840         *csum = recalc_csum16(*csum, *port, new_port);
 841         *port = new_port;
 842     }
 843 }
 844
 845 /* Sets the TCP source and destination port ('src' and 'dst' respectively) of
 846  * the TCP header contained in 'packet'.  'packet' must be a valid TCP packet
 847  * with its l4 marker properly populated. */
 848 void
 849 packet_set_tcp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
 850 {
 851     struct tcp_header *th = packet->l4;
 852
 853     packet_set_port(&th->tcp_src, src, &th->tcp_csum);
 854     packet_set_port(&th->tcp_dst, dst, &th->tcp_csum);
 855 }
 856
 857 /* Sets the UDP source and destination port ('src' and 'dst' respectively) of
 858  * the UDP header contained in 'packet'.  'packet' must be a valid UDP packet
 859  * with its l4 marker properly populated. */
 860 void
 861 packet_set_udp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
 862 {
 863     struct udp_header *uh = packet->l4;
 864
 865     if (uh->udp_csum) {
 866         packet_set_port(&uh->udp_src, src, &uh->udp_csum);
 867         packet_set_port(&uh->udp_dst, dst, &uh->udp_csum);
 868
 869         if (!uh->udp_csum) {
 870             uh->udp_csum = htons(0xffff);
 871         }
 872     } else {
 873         uh->udp_src = src;
 874         uh->udp_dst = dst;
 875     }
 876 }
 877
 878 /* Sets the SCTP source and destination port ('src' and 'dst' respectively) of
 879  * the SCTP header contained in 'packet'.  'packet' must be a valid SCTP packet
 880  * with its l4 marker properly populated. */
 881 void
 882 packet_set_sctp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
 883 {
 884     struct sctp_header *sh = packet->l4;
 885     ovs_be32 old_csum, old_correct_csum, new_csum;
 886     uint16_t tp_len = packet->size - ((uint8_t*)sh - (uint8_t*)packet->data);
 887
 888     old_csum = sh->sctp_csum;
 889     sh->sctp_csum = 0;
 890     old_correct_csum = crc32c(packet->l4, tp_len);
 891
 892     sh->sctp_src = src;
 893     sh->sctp_dst = dst;
 894
 895     new_csum = crc32c(packet->l4, tp_len);
 896     sh->sctp_csum = old_csum ^ old_correct_csum ^ new_csum;
 897 }
 898
 899 const char *
 900 packet_tcp_flag_to_string(uint32_t flag)
 901 {
 902     switch (flag) {
 903     case TCP_FIN:
 904         return "fin";
 905     case TCP_SYN:
 906         return "syn";
 907     case TCP_RST:
 908         return "rst";
 909     case TCP_PSH:
 910         return "psh";
 911     case TCP_ACK:
 912         return "ack";
 913     case TCP_URG:
 914         return "urg";
 915     case TCP_ECE:
 916         return "ece";
 917     case TCP_CWR:
 918         return "cwr";
 919     case TCP_NS:
 920         return "ns";
 921     case 0x200:
 922         return "[200]";
 923     case 0x400:
 924         return "[400]";
 925     case 0x800:
 926         return "[800]";
 927     default:
 928         return NULL;
 929     }
 930 }
 931
 932 /* Appends a string representation of the TCP flags value 'tcp_flags'
 933  * (e.g. from struct flow.tcp_flags or obtained via TCP_FLAGS) to 's', in the
 934  * format used by tcpdump. */
 935 void
 936 packet_format_tcp_flags(struct ds *s, uint16_t tcp_flags)
 937 {
 938     if (!tcp_flags) {
 939         ds_put_cstr(s, "none");
 940         return;
 941     }
 942
 943     if (tcp_flags & TCP_SYN) {
 944         ds_put_char(s, 'S');
 945     }
 946     if (tcp_flags & TCP_FIN) {
 947         ds_put_char(s, 'F');
 948     }
 949     if (tcp_flags & TCP_PSH) {
 950         ds_put_char(s, 'P');
 951     }
 952     if (tcp_flags & TCP_RST) {
 953         ds_put_char(s, 'R');
 954     }
 955     if (tcp_flags & TCP_URG) {
 956         ds_put_char(s, 'U');
 957     }
 958     if (tcp_flags & TCP_ACK) {
 959         ds_put_char(s, '.');
 960     }
 961     if (tcp_flags & TCP_ECE) {
 962         ds_put_cstr(s, "E");
 963     }
 964     if (tcp_flags & TCP_CWR) {
 965         ds_put_cstr(s, "C");
 966     }
 967     if (tcp_flags & TCP_NS) {
 968         ds_put_cstr(s, "N");
 969     }
 970     if (tcp_flags & 0x200) {
 971         ds_put_cstr(s, "[200]");
 972     }
 973     if (tcp_flags & 0x400) {
 974         ds_put_cstr(s, "[400]");
 975     }
 976     if (tcp_flags & 0x800) {
 977         ds_put_cstr(s, "[800]");
 978     }
 979 }