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 <assert.h>
  20 #include <arpa/inet.h>
  21 #include <sys/socket.h>
  22 #include <netinet/in.h>
  23 #include <netinet/ip6.h>
  24 #include <stdlib.h>
  25 #include "byte-order.h"
  26 #include "csum.h"
  27 #include "flow.h"
  28 #include "hmap.h"
  29 #include "dynamic-string.h"
  30 #include "ofpbuf.h"
  31 #include "unaligned.h"
  32
  33 const struct in6_addr in6addr_exact = IN6ADDR_EXACT_INIT;
  34
  35 /* Parses 's' as a 16-digit hexadecimal number representing a datapath ID.  On
  36  * success stores the dpid into '*dpidp' and returns true, on failure stores 0
  37  * into '*dpidp' and returns false.
  38  *
  39  * Rejects an all-zeros dpid as invalid. */
  40 bool
  41 dpid_from_string(const char *s, uint64_t *dpidp)
  42 {
  43     *dpidp = (strlen(s) == 16 && strspn(s, "0123456789abcdefABCDEF") == 16
  44               ? strtoull(s, NULL, 16)
  45               : 0);
  46     return *dpidp != 0;
  47 }
  48
  49 /* Returns true if 'ea' is a reserved address, that a bridge must never
  50  * forward, false otherwise.
  51  *
  52  * If you change this function's behavior, please update corresponding
  53  * documentation in vswitch.xml at the same time. */
  54 bool
  55 eth_addr_is_reserved(const uint8_t ea[ETH_ADDR_LEN])
  56 {
  57     struct eth_addr_node {
  58         struct hmap_node hmap_node;
  59         uint64_t ea64;
  60     };
  61
  62     static struct eth_addr_node nodes[] = {
  63         /* STP, IEEE pause frames, and other reserved protocols. */
  64         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000000ULL },
  65         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000001ULL },
  66         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000002ULL },
  67         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000003ULL },
  68         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000004ULL },
  69         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000005ULL },
  70         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000006ULL },
  71         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000007ULL },
  72         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000008ULL },
  73         { HMAP_NODE_NULL_INITIALIZER, 0x0180c2000009ULL },
  74         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000aULL },
  75         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000bULL },
  76         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000cULL },
  77         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000dULL },
  78         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000eULL },
  79         { HMAP_NODE_NULL_INITIALIZER, 0x0180c200000fULL },
  80
  81         /* Extreme protocols. */
  82         { HMAP_NODE_NULL_INITIALIZER, 0x00e02b000000ULL }, /* EDP. */
  83         { HMAP_NODE_NULL_INITIALIZER, 0x00e02b000004ULL }, /* EAPS. */
  84         { HMAP_NODE_NULL_INITIALIZER, 0x00e02b000006ULL }, /* EAPS. */
  85
  86         /* Cisco protocols. */
  87         { HMAP_NODE_NULL_INITIALIZER, 0x01000c000000ULL }, /* ISL. */
  88         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccccULL }, /* PAgP, UDLD, CDP,
  89                                                             * DTP, VTP. */
  90         { HMAP_NODE_NULL_INITIALIZER, 0x01000ccccccdULL }, /* PVST+. */
  91         { HMAP_NODE_NULL_INITIALIZER, 0x01000ccdcdcdULL }, /* STP Uplink Fast,
  92                                                             * FlexLink. */
  93
  94         /* Cisco CFM. */
  95         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc0ULL },
  96         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc1ULL },
  97         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc2ULL },
  98         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc3ULL },
  99         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc4ULL },
 100         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc5ULL },
 101         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc6ULL },
 102         { HMAP_NODE_NULL_INITIALIZER, 0x01000cccccc7ULL },
 103     };
 104
 105     static struct hmap addrs = HMAP_INITIALIZER(&addrs);
 106     struct eth_addr_node *node;
 107     uint64_t ea64;
 108
 109     if (hmap_is_empty(&addrs)) {
 110         for (node = nodes; node < &nodes[ARRAY_SIZE(nodes)]; node++) {
 111             hmap_insert(&addrs, &node->hmap_node,
 112                         hash_2words(node->ea64, node->ea64 >> 32));
 113         }
 114     }
 115
 116     ea64 = eth_addr_to_uint64(ea);
 117     HMAP_FOR_EACH_IN_BUCKET (node, hmap_node, hash_2words(ea64, ea64 >> 32),
 118                              &addrs) {
 119         if (node->ea64 == ea64) {
 120             return true;
 121         }
 122     }
 123     return false;
 124 }
 125
 126 bool
 127 eth_addr_from_string(const char *s, uint8_t ea[ETH_ADDR_LEN])
 128 {
 129     if (sscanf(s, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(ea))
 130         == ETH_ADDR_SCAN_COUNT) {
 131         return true;
 132     } else {
 133         memset(ea, 0, ETH_ADDR_LEN);
 134         return false;
 135     }
 136 }
 137
 138 /* Fills 'b' with a Reverse ARP packet with Ethernet source address 'eth_src'.
 139  * This function is used by Open vSwitch to compose packets in cases where
 140  * context is important but content doesn't (or shouldn't) matter.
 141  *
 142  * The returned packet has enough headroom to insert an 802.1Q VLAN header if
 143  * desired. */
 144 void
 145 compose_rarp(struct ofpbuf *b, const uint8_t eth_src[ETH_ADDR_LEN])
 146 {
 147     struct eth_header *eth;
 148     struct arp_eth_header *arp;
 149
 150     ofpbuf_clear(b);
 151     ofpbuf_prealloc_tailroom(b, ETH_HEADER_LEN + VLAN_HEADER_LEN
 152                              + ARP_ETH_HEADER_LEN);
 153     ofpbuf_reserve(b, VLAN_HEADER_LEN);
 154     eth = ofpbuf_put_uninit(b, sizeof *eth);
 155     memcpy(eth->eth_dst, eth_addr_broadcast, ETH_ADDR_LEN);
 156     memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
 157     eth->eth_type = htons(ETH_TYPE_RARP);
 158
 159     arp = ofpbuf_put_uninit(b, sizeof *arp);
 160     arp->ar_hrd = htons(ARP_HRD_ETHERNET);
 161     arp->ar_pro = htons(ARP_PRO_IP);
 162     arp->ar_hln = sizeof arp->ar_sha;
 163     arp->ar_pln = sizeof arp->ar_spa;
 164     arp->ar_op = htons(ARP_OP_RARP);
 165     memcpy(arp->ar_sha, eth_src, ETH_ADDR_LEN);
 166     put_16aligned_be32(&arp->ar_spa, htonl(0));
 167     memcpy(arp->ar_tha, eth_src, ETH_ADDR_LEN);
 168     put_16aligned_be32(&arp->ar_tpa, htonl(0));
 169 }
 170
 171 /* Insert VLAN header according to given TCI. Packet passed must be Ethernet
 172  * packet.  Ignores the CFI bit of 'tci' using 0 instead.
 173  *
 174  * Also sets 'packet->l2' to point to the new Ethernet header. */
 175 void
 176 eth_push_vlan(struct ofpbuf *packet, ovs_be16 tci)
 177 {
 178     struct eth_header *eh = packet->data;
 179     struct vlan_eth_header *veh;
 180
 181     /* Insert new 802.1Q header. */
 182     struct vlan_eth_header tmp;
 183     memcpy(tmp.veth_dst, eh->eth_dst, ETH_ADDR_LEN);
 184     memcpy(tmp.veth_src, eh->eth_src, ETH_ADDR_LEN);
 185     tmp.veth_type = htons(ETH_TYPE_VLAN);
 186     tmp.veth_tci = tci & htons(~VLAN_CFI);
 187     tmp.veth_next_type = eh->eth_type;
 188
 189     veh = ofpbuf_push_uninit(packet, VLAN_HEADER_LEN);
 190     memcpy(veh, &tmp, sizeof tmp);
 191
 192     packet->l2 = packet->data;
 193 }
 194
 195 /* Removes outermost VLAN header (if any is present) from 'packet'.
 196  *
 197  * 'packet->l2' must initially point to 'packet''s Ethernet header. */
 198 void
 199 eth_pop_vlan(struct ofpbuf *packet)
 200 {
 201     struct vlan_eth_header *veh = packet->l2;
 202     if (packet->size >= sizeof *veh
 203         && veh->veth_type == htons(ETH_TYPE_VLAN)) {
 204         struct eth_header tmp;
 205
 206         memcpy(tmp.eth_dst, veh->veth_dst, ETH_ADDR_LEN);
 207         memcpy(tmp.eth_src, veh->veth_src, ETH_ADDR_LEN);
 208         tmp.eth_type = veh->veth_next_type;
 209
 210         ofpbuf_pull(packet, VLAN_HEADER_LEN);
 211         packet->l2 = (char*)packet->l2 + VLAN_HEADER_LEN;
 212         memcpy(packet->data, &tmp, sizeof tmp);
 213     }
 214 }
 215
 216 /* Converts hex digits in 'hex' to an Ethernet packet in '*packetp'.  The
 217  * caller must free '*packetp'.  On success, returns NULL.  On failure, returns
 218  * an error message and stores NULL in '*packetp'. */
 219 const char *
 220 eth_from_hex(const char *hex, struct ofpbuf **packetp)
 221 {
 222     struct ofpbuf *packet;
 223
 224     packet = *packetp = ofpbuf_new(strlen(hex) / 2);
 225
 226     if (ofpbuf_put_hex(packet, hex, NULL)[0] != '\0') {
 227         ofpbuf_delete(packet);
 228         *packetp = NULL;
 229         return "Trailing garbage in packet data";
 230     }
 231
 232     if (packet->size < ETH_HEADER_LEN) {
 233         ofpbuf_delete(packet);
 234         *packetp = NULL;
 235         return "Packet data too short for Ethernet";
 236     }
 237
 238     return NULL;
 239 }
 240
 241 void
 242 eth_format_masked(const uint8_t eth[ETH_ADDR_LEN],
 243                   const uint8_t mask[ETH_ADDR_LEN], struct ds *s)
 244 {
 245     ds_put_format(s, ETH_ADDR_FMT, ETH_ADDR_ARGS(eth));
 246     if (mask && !eth_mask_is_exact(mask)) {
 247         ds_put_format(s, "/"ETH_ADDR_FMT, ETH_ADDR_ARGS(mask));
 248     }
 249 }
 250
 251 void
 252 eth_addr_bitand(const uint8_t src[ETH_ADDR_LEN],
 253                 const uint8_t mask[ETH_ADDR_LEN],
 254                 uint8_t dst[ETH_ADDR_LEN])
 255 {
 256     int i;
 257
 258     for (i = 0; i < ETH_ADDR_LEN; i++) {
 259         dst[i] = src[i] & mask[i];
 260     }
 261 }
 262
 263 /* Given the IP netmask 'netmask', returns the number of bits of the IP address
 264  * that it specifies, that is, the number of 1-bits in 'netmask'.
 265  *
 266  * If 'netmask' is not a CIDR netmask (see ip_is_cidr()), the return value will
 267  * still be in the valid range but isn't otherwise meaningful. */
 268 int
 269 ip_count_cidr_bits(ovs_be32 netmask)
 270 {
 271     return 32 - ctz(ntohl(netmask));
 272 }
 273
 274 void
 275 ip_format_masked(ovs_be32 ip, ovs_be32 mask, struct ds *s)
 276 {
 277     ds_put_format(s, IP_FMT, IP_ARGS(&ip));
 278     if (mask != htonl(UINT32_MAX)) {
 279         if (ip_is_cidr(mask)) {
 280             ds_put_format(s, "/%d", ip_count_cidr_bits(mask));
 281         } else {
 282             ds_put_format(s, "/"IP_FMT, IP_ARGS(&mask));
 283         }
 284     }
 285 }
 286
 287
 288 /* Stores the string representation of the IPv6 address 'addr' into the
 289  * character array 'addr_str', which must be at least INET6_ADDRSTRLEN
 290  * bytes long. */
 291 void
 292 format_ipv6_addr(char *addr_str, const struct in6_addr *addr)
 293 {
 294     inet_ntop(AF_INET6, addr, addr_str, INET6_ADDRSTRLEN);
 295 }
 296
 297 void
 298 print_ipv6_addr(struct ds *string, const struct in6_addr *addr)
 299 {
 300     char *dst;
 301
 302     ds_reserve(string, string->length + INET6_ADDRSTRLEN);
 303
 304     dst = string->string + string->length;
 305     format_ipv6_addr(dst, addr);
 306     string->length += strlen(dst);
 307 }
 308
 309 void
 310 print_ipv6_masked(struct ds *s, const struct in6_addr *addr,
 311                   const struct in6_addr *mask)
 312 {
 313     print_ipv6_addr(s, addr);
 314     if (mask && !ipv6_mask_is_exact(mask)) {
 315         if (ipv6_is_cidr(mask)) {
 316             int cidr_bits = ipv6_count_cidr_bits(mask);
 317             ds_put_format(s, "/%d", cidr_bits);
 318         } else {
 319             ds_put_char(s, '/');
 320             print_ipv6_addr(s, mask);
 321         }
 322     }
 323 }
 324
 325 struct in6_addr ipv6_addr_bitand(const struct in6_addr *a,
 326                                  const struct in6_addr *b)
 327 {
 328     int i;
 329     struct in6_addr dst;
 330
 331 #ifdef s6_addr32
 332     for (i=0; i<4; i++) {
 333         dst.s6_addr32[i] = a->s6_addr32[i] & b->s6_addr32[i];
 334     }
 335 #else
 336     for (i=0; i<16; i++) {
 337         dst.s6_addr[i] = a->s6_addr[i] & b->s6_addr[i];
 338     }
 339 #endif
 340
 341     return dst;
 342 }
 343
 344 /* Returns an in6_addr consisting of 'mask' high-order 1-bits and 128-N
 345  * low-order 0-bits. */
 346 struct in6_addr
 347 ipv6_create_mask(int mask)
 348 {
 349     struct in6_addr netmask;
 350     uint8_t *netmaskp = &netmask.s6_addr[0];
 351
 352     memset(&netmask, 0, sizeof netmask);
 353     while (mask > 8) {
 354         *netmaskp = 0xff;
 355         netmaskp++;
 356         mask -= 8;
 357     }
 358
 359     if (mask) {
 360         *netmaskp = 0xff << (8 - mask);
 361     }
 362
 363     return netmask;
 364 }
 365
 366 /* Given the IPv6 netmask 'netmask', returns the number of bits of the IPv6
 367  * address that it specifies, that is, the number of 1-bits in 'netmask'.
 368  * 'netmask' must be a CIDR netmask (see ipv6_is_cidr()).
 369  *
 370  * If 'netmask' is not a CIDR netmask (see ipv6_is_cidr()), the return value
 371  * will still be in the valid range but isn't otherwise meaningful. */
 372 int
 373 ipv6_count_cidr_bits(const struct in6_addr *netmask)
 374 {
 375     int i;
 376     int count = 0;
 377     const uint8_t *netmaskp = &netmask->s6_addr[0];
 378
 379     for (i=0; i<16; i++) {
 380         if (netmaskp[i] == 0xff) {
 381             count += 8;
 382         } else {
 383             uint8_t nm;
 384
 385             for(nm = netmaskp[i]; nm; nm <<= 1) {
 386                 count++;
 387             }
 388             break;
 389         }
 390
 391     }
 392
 393     return count;
 394 }
 395
 396 /* Returns true if 'netmask' is a CIDR netmask, that is, if it consists of N
 397  * high-order 1-bits and 128-N low-order 0-bits. */
 398 bool
 399 ipv6_is_cidr(const struct in6_addr *netmask)
 400 {
 401     const uint8_t *netmaskp = &netmask->s6_addr[0];
 402     int i;
 403
 404     for (i=0; i<16; i++) {
 405         if (netmaskp[i] != 0xff) {
 406             uint8_t x = ~netmaskp[i];
 407             if (x & (x + 1)) {
 408                 return false;
 409             }
 410             while (++i < 16) {
 411                 if (netmaskp[i]) {
 412                     return false;
 413                 }
 414             }
 415         }
 416     }
 417
 418     return true;
 419 }
 420
 421 /* Populates 'b' with an Ethernet II packet headed with the given 'eth_dst',
 422  * 'eth_src' and 'eth_type' parameters.  A payload of 'size' bytes is allocated
 423  * in 'b' and returned.  This payload may be populated with appropriate
 424  * information by the caller.  Sets 'b''s 'l2' and 'l3' pointers to the
 425  * Ethernet header and payload respectively.
 426  *
 427  * The returned packet has enough headroom to insert an 802.1Q VLAN header if
 428  * desired. */
 429 void *
 430 eth_compose(struct ofpbuf *b, const uint8_t eth_dst[ETH_ADDR_LEN],
 431             const uint8_t eth_src[ETH_ADDR_LEN], uint16_t eth_type,
 432             size_t size)
 433 {
 434     void *data;
 435     struct eth_header *eth;
 436
 437     ofpbuf_clear(b);
 438
 439     ofpbuf_prealloc_tailroom(b, ETH_HEADER_LEN + VLAN_HEADER_LEN + size);
 440     ofpbuf_reserve(b, VLAN_HEADER_LEN);
 441     eth = ofpbuf_put_uninit(b, ETH_HEADER_LEN);
 442     data = ofpbuf_put_uninit(b, size);
 443
 444     memcpy(eth->eth_dst, eth_dst, ETH_ADDR_LEN);
 445     memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
 446     eth->eth_type = htons(eth_type);
 447
 448     b->l2 = eth;
 449     b->l3 = data;
 450
 451     return data;
 452 }
 453
 454 static void
 455 packet_set_ipv4_addr(struct ofpbuf *packet,
 456                      ovs_16aligned_be32 *addr, ovs_be32 new_addr)
 457 {
 458     struct ip_header *nh = packet->l3;
 459     ovs_be32 old_addr = get_16aligned_be32(addr);
 460
 461     if (nh->ip_proto == IPPROTO_TCP && packet->l7) {
 462         struct tcp_header *th = packet->l4;
 463
 464         th->tcp_csum = recalc_csum32(th->tcp_csum, old_addr, new_addr);
 465     } else if (nh->ip_proto == IPPROTO_UDP && packet->l7) {
 466         struct udp_header *uh = packet->l4;
 467
 468         if (uh->udp_csum) {
 469             uh->udp_csum = recalc_csum32(uh->udp_csum, old_addr, new_addr);
 470             if (!uh->udp_csum) {
 471                 uh->udp_csum = htons(0xffff);
 472             }
 473         }
 474     }
 475     nh->ip_csum = recalc_csum32(nh->ip_csum, old_addr, new_addr);
 476     put_16aligned_be32(addr, new_addr);
 477 }
 478
 479 /* Returns true, if packet contains at least one routing header where
 480  * segements_left > 0.
 481  *
 482  * This function assumes that L3 and L4 markers are set in the packet. */
 483 static bool
 484 packet_rh_present(struct ofpbuf *packet)
 485 {
 486     const struct ip6_hdr *nh;
 487     int nexthdr;
 488     size_t len;
 489     size_t remaining;
 490     uint8_t *data = packet->l3;
 491
 492     remaining = (uint8_t *)packet->l4 - (uint8_t *)packet->l3;
 493
 494     if (remaining < sizeof *nh) {
 495         return false;
 496     }
 497     nh = (struct ip6_hdr *)data;
 498     data += sizeof *nh;
 499     remaining -= sizeof *nh;
 500     nexthdr = nh->ip6_nxt;
 501
 502     while (1) {
 503         if ((nexthdr != IPPROTO_HOPOPTS)
 504                 && (nexthdr != IPPROTO_ROUTING)
 505                 && (nexthdr != IPPROTO_DSTOPTS)
 506                 && (nexthdr != IPPROTO_AH)
 507                 && (nexthdr != IPPROTO_FRAGMENT)) {
 508             /* It's either a terminal header (e.g., TCP, UDP) or one we
 509              * don't understand.  In either case, we're done with the
 510              * packet, so use it to fill in 'nw_proto'. */
 511             break;
 512         }
 513
 514         /* We only verify that at least 8 bytes of the next header are
 515          * available, but many of these headers are longer.  Ensure that
 516          * accesses within the extension header are within those first 8
 517          * bytes. All extension headers are required to be at least 8
 518          * bytes. */
 519         if (remaining < 8) {
 520             return false;
 521         }
 522
 523         if (nexthdr == IPPROTO_AH) {
 524             /* A standard AH definition isn't available, but the fields
 525              * we care about are in the same location as the generic
 526              * option header--only the header length is calculated
 527              * differently. */
 528             const struct ip6_ext *ext_hdr = (struct ip6_ext *)data;
 529
 530             nexthdr = ext_hdr->ip6e_nxt;
 531             len = (ext_hdr->ip6e_len + 2) * 4;
 532         } else if (nexthdr == IPPROTO_FRAGMENT) {
 533             const struct ip6_frag *frag_hdr = (struct ip6_frag *)data;
 534
 535             nexthdr = frag_hdr->ip6f_nxt;
 536             len = sizeof *frag_hdr;
 537         } else if (nexthdr == IPPROTO_ROUTING) {
 538             const struct ip6_rthdr *rh = (struct ip6_rthdr *)data;
 539
 540             if (rh->ip6r_segleft > 0) {
 541                 return true;
 542             }
 543
 544             nexthdr = rh->ip6r_nxt;
 545             len = (rh->ip6r_len + 1) * 8;
 546         } else {
 547             const struct ip6_ext *ext_hdr = (struct ip6_ext *)data;
 548
 549             nexthdr = ext_hdr->ip6e_nxt;
 550             len = (ext_hdr->ip6e_len + 1) * 8;
 551         }
 552
 553         if (remaining < len) {
 554             return false;
 555         }
 556         remaining -= len;
 557         data += len;
 558     }
 559
 560     return false;
 561 }
 562
 563 static void
 564 packet_update_csum128(struct ofpbuf *packet, uint8_t proto,
 565                      ovs_be32 addr[4], const ovs_be32 new_addr[4])
 566 {
 567     if (proto == IPPROTO_TCP && packet->l7) {
 568         struct tcp_header *th = packet->l4;
 569
 570         th->tcp_csum = recalc_csum128(th->tcp_csum, addr, new_addr);
 571     } else if (proto == IPPROTO_UDP && packet->l7) {
 572         struct udp_header *uh = packet->l4;
 573
 574         if (uh->udp_csum) {
 575             uh->udp_csum = recalc_csum128(uh->udp_csum, addr, new_addr);
 576             if (!uh->udp_csum) {
 577                 uh->udp_csum = htons(0xffff);
 578             }
 579         }
 580     }
 581 }
 582
 583 static void
 584 packet_set_ipv6_addr(struct ofpbuf *packet, uint8_t proto,
 585                      struct in6_addr *addr, const ovs_be32 new_addr[4],
 586                      bool recalculate_csum)
 587 {
 588     if (recalculate_csum) {
 589         packet_update_csum128(packet, proto, (ovs_be32 *)addr, new_addr);
 590     }
 591     memcpy(addr, new_addr, sizeof(*addr));
 592 }
 593
 594 static void
 595 packet_set_ipv6_flow_label(ovs_be32 *flow_label, ovs_be32 flow_key)
 596 {
 597     *flow_label = (*flow_label & htonl(~IPV6_LABEL_MASK)) | flow_key;
 598 }
 599
 600 static void
 601 packet_set_ipv6_tc(ovs_be32 *flow_label, uint8_t tc)
 602 {
 603     *flow_label = (*flow_label & htonl(0xF00FFFFF)) | htonl(tc << 20);
 604 }
 605
 606 /* Modifies the IPv4 header fields of 'packet' to be consistent with 'src',
 607  * 'dst', 'tos', and 'ttl'.  Updates 'packet''s L4 checksums as appropriate.
 608  * 'packet' must contain a valid IPv4 packet with correctly populated l[347]
 609  * markers. */
 610 void
 611 packet_set_ipv4(struct ofpbuf *packet, ovs_be32 src, ovs_be32 dst,
 612                 uint8_t tos, uint8_t ttl)
 613 {
 614     struct ip_header *nh = packet->l3;
 615
 616     if (get_16aligned_be32(&nh->ip_src) != src) {
 617         packet_set_ipv4_addr(packet, &nh->ip_src, src);
 618     }
 619
 620     if (get_16aligned_be32(&nh->ip_dst) != dst) {
 621         packet_set_ipv4_addr(packet, &nh->ip_dst, dst);
 622     }
 623
 624     if (nh->ip_tos != tos) {
 625         uint8_t *field = &nh->ip_tos;
 626
 627         nh->ip_csum = recalc_csum16(nh->ip_csum, htons((uint16_t) *field),
 628                                     htons((uint16_t) tos));
 629         *field = tos;
 630     }
 631
 632     if (nh->ip_ttl != ttl) {
 633         uint8_t *field = &nh->ip_ttl;
 634
 635         nh->ip_csum = recalc_csum16(nh->ip_csum, htons(*field << 8),
 636                                     htons(ttl << 8));
 637         *field = ttl;
 638     }
 639 }
 640
 641 /* Modifies the IPv6 header fields of 'packet' to be consistent with 'src',
 642  * 'dst', 'traffic class', and 'next hop'.  Updates 'packet''s L4 checksums as
 643  * appropriate. 'packet' must contain a valid IPv6 packet with correctly
 644  * populated l[347] markers. */
 645 void
 646 packet_set_ipv6(struct ofpbuf *packet, uint8_t proto, const ovs_be32 src[4],
 647                 const ovs_be32 dst[4], uint8_t key_tc, ovs_be32 key_fl,
 648                 uint8_t key_hl)
 649 {
 650     struct ip6_hdr *nh = packet->l3;
 651
 652     if (memcmp(&nh->ip6_src, src, sizeof(ovs_be32[4]))) {
 653         packet_set_ipv6_addr(packet, proto, &nh->ip6_src, src, true);
 654     }
 655
 656     if (memcmp(&nh->ip6_dst, dst, sizeof(ovs_be32[4]))) {
 657         packet_set_ipv6_addr(packet, proto, &nh->ip6_dst, dst,
 658                              !packet_rh_present(packet));
 659     }
 660
 661     packet_set_ipv6_tc(&nh->ip6_flow, key_tc);
 662
 663     packet_set_ipv6_flow_label(&nh->ip6_flow, key_fl);
 664
 665     nh->ip6_hlim = key_hl;
 666 }
 667
 668 static void
 669 packet_set_port(ovs_be16 *port, ovs_be16 new_port, ovs_be16 *csum)
 670 {
 671     if (*port != new_port) {
 672         *csum = recalc_csum16(*csum, *port, new_port);
 673         *port = new_port;
 674     }
 675 }
 676
 677 /* Sets the TCP source and destination port ('src' and 'dst' respectively) of
 678  * the TCP header contained in 'packet'.  'packet' must be a valid TCP packet
 679  * with its l4 marker properly populated. */
 680 void
 681 packet_set_tcp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
 682 {
 683     struct tcp_header *th = packet->l4;
 684
 685     packet_set_port(&th->tcp_src, src, &th->tcp_csum);
 686     packet_set_port(&th->tcp_dst, dst, &th->tcp_csum);
 687 }
 688
 689 /* Sets the UDP source and destination port ('src' and 'dst' respectively) of
 690  * the UDP header contained in 'packet'.  'packet' must be a valid UDP packet
 691  * with its l4 marker properly populated. */
 692 void
 693 packet_set_udp_port(struct ofpbuf *packet, ovs_be16 src, ovs_be16 dst)
 694 {
 695     struct udp_header *uh = packet->l4;
 696
 697     if (uh->udp_csum) {
 698         packet_set_port(&uh->udp_src, src, &uh->udp_csum);
 699         packet_set_port(&uh->udp_dst, dst, &uh->udp_csum);
 700
 701         if (!uh->udp_csum) {
 702             uh->udp_csum = htons(0xffff);
 703         }
 704     } else {
 705         uh->udp_src = src;
 706         uh->udp_dst = dst;
 707     }
 708 }
 709
 710 /* If 'packet' is a TCP packet, returns the TCP flags.  Otherwise, returns 0.
 711  *
 712  * 'flow' must be the flow corresponding to 'packet' and 'packet''s header
 713  * pointers must be properly initialized (e.g. with flow_extract()). */
 714 uint8_t
 715 packet_get_tcp_flags(const struct ofpbuf *packet, const struct flow *flow)
 716 {
 717     if ((flow->dl_type == htons(ETH_TYPE_IP) ||
 718          flow->dl_type == htons(ETH_TYPE_IPV6)) &&
 719         flow->nw_proto == IPPROTO_TCP && packet->l7) {
 720         const struct tcp_header *tcp = packet->l4;
 721         return TCP_FLAGS(tcp->tcp_ctl);
 722     } else {
 723         return 0;
 724     }
 725 }
 726
 727 /* Appends a string representation of the TCP flags value 'tcp_flags'
 728  * (e.g. obtained via packet_get_tcp_flags() or TCP_FLAGS) to 's', in the
 729  * format used by tcpdump. */
 730 void
 731 packet_format_tcp_flags(struct ds *s, uint8_t tcp_flags)
 732 {
 733     if (!tcp_flags) {
 734         ds_put_cstr(s, "none");
 735         return;
 736     }
 737
 738     if (tcp_flags & TCP_SYN) {
 739         ds_put_char(s, 'S');
 740     }
 741     if (tcp_flags & TCP_FIN) {
 742         ds_put_char(s, 'F');
 743     }
 744     if (tcp_flags & TCP_PSH) {
 745         ds_put_char(s, 'P');
 746     }
 747     if (tcp_flags & TCP_RST) {
 748         ds_put_char(s, 'R');
 749     }
 750     if (tcp_flags & TCP_URG) {
 751         ds_put_char(s, 'U');
 752     }
 753     if (tcp_flags & TCP_ACK) {
 754         ds_put_char(s, '.');
 755     }
 756     if (tcp_flags & 0x40) {
 757         ds_put_cstr(s, "[40]");
 758     }
 759     if (tcp_flags & 0x80) {
 760         ds_put_cstr(s, "[80]");
 761     }
 762 }