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