net/eth.c

   1 /*
   2  * QEMU network structures definitions and helper functions
   3  *
   4  * Copyright (c) 2012 Ravello Systems LTD (http://ravellosystems.com)
   5  *
   6  * Developed by Daynix Computing LTD (http://www.daynix.com)
   7  *
   8  * Authors:
   9  * Dmitry Fleytman <dmitry@daynix.com>
  10  * Tamir Shomer <tamirs@daynix.com>
  11  * Yan Vugenfirer <yan@daynix.com>
  12  *
  13  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  14  * See the COPYING file in the top-level directory.
  15  *
  16  */
  17
  18 #include "qemu/osdep.h"
  19 #include "net/eth.h"
  20 #include "net/checksum.h"
  21 #include "qemu-common.h"
  22 #include "net/tap.h"
  23
  24 void eth_setup_vlan_headers_ex(struct eth_header *ehdr, uint16_t vlan_tag,
  25     uint16_t vlan_ethtype, bool *is_new)
  26 {
  27     struct vlan_header *vhdr = PKT_GET_VLAN_HDR(ehdr);
  28
  29     switch (be16_to_cpu(ehdr->h_proto)) {
  30     case ETH_P_VLAN:
  31     case ETH_P_DVLAN:
  32         /* vlan hdr exists */
  33         *is_new = false;
  34         break;
  35
  36     default:
  37         /* No VLAN header, put a new one */
  38         vhdr->h_proto = ehdr->h_proto;
  39         ehdr->h_proto = cpu_to_be16(vlan_ethtype);
  40         *is_new = true;
  41         break;
  42     }
  43     vhdr->h_tci = cpu_to_be16(vlan_tag);
  44 }
  45
  46 uint8_t
  47 eth_get_gso_type(uint16_t l3_proto, uint8_t *l3_hdr, uint8_t l4proto)
  48 {
  49     uint8_t ecn_state = 0;
  50
  51     if (l3_proto == ETH_P_IP) {
  52         struct ip_header *iphdr = (struct ip_header *) l3_hdr;
  53
  54         if (IP_HEADER_VERSION(iphdr) == IP_HEADER_VERSION_4) {
  55             if (IPTOS_ECN(iphdr->ip_tos) == IPTOS_ECN_CE) {
  56                 ecn_state = VIRTIO_NET_HDR_GSO_ECN;
  57             }
  58             if (l4proto == IP_PROTO_TCP) {
  59                 return VIRTIO_NET_HDR_GSO_TCPV4 | ecn_state;
  60             } else if (l4proto == IP_PROTO_UDP) {
  61                 return VIRTIO_NET_HDR_GSO_UDP | ecn_state;
  62             }
  63         }
  64     } else if (l3_proto == ETH_P_IPV6) {
  65         struct ip6_header *ip6hdr = (struct ip6_header *) l3_hdr;
  66
  67         if (IP6_ECN(ip6hdr->ip6_ecn_acc) == IP6_ECN_CE) {
  68             ecn_state = VIRTIO_NET_HDR_GSO_ECN;
  69         }
  70
  71         if (l4proto == IP_PROTO_TCP) {
  72             return VIRTIO_NET_HDR_GSO_TCPV6 | ecn_state;
  73         }
  74     }
  75
  76     /* Unsupported offload */
  77     g_assert_not_reached();
  78
  79     return VIRTIO_NET_HDR_GSO_NONE | ecn_state;
  80 }
  81
  82 uint16_t
  83 eth_get_l3_proto(const struct iovec *l2hdr_iov, int iovcnt, size_t l2hdr_len)
  84 {
  85     uint16_t proto;
  86     size_t copied;
  87     size_t size = iov_size(l2hdr_iov, iovcnt);
  88     size_t proto_offset = l2hdr_len - sizeof(proto);
  89
  90     if (size < proto_offset) {
  91         return ETH_P_UNKNOWN;
  92     }
  93
  94     copied = iov_to_buf(l2hdr_iov, iovcnt, proto_offset,
  95                         &proto, sizeof(proto));
  96
  97     return (copied == sizeof(proto)) ? be16_to_cpu(proto) : ETH_P_UNKNOWN;
  98 }
  99
 100 static bool
 101 _eth_copy_chunk(size_t input_size,
 102                 const struct iovec *iov, int iovcnt,
 103                 size_t offset, size_t length,
 104                 void *buffer)
 105 {
 106     size_t copied;
 107
 108     if (input_size < offset) {
 109         return false;
 110     }
 111
 112     copied = iov_to_buf(iov, iovcnt, offset, buffer, length);
 113
 114     if (copied < length) {
 115         return false;
 116     }
 117
 118     return true;
 119 }
 120
 121 static bool
 122 _eth_tcp_has_data(bool is_ip4,
 123                   const struct ip_header  *ip4_hdr,
 124                   const struct ip6_header *ip6_hdr,
 125                   size_t full_ip6hdr_len,
 126                   const struct tcp_header *tcp)
 127 {
 128     uint32_t l4len;
 129
 130     if (is_ip4) {
 131         l4len = be16_to_cpu(ip4_hdr->ip_len) - IP_HDR_GET_LEN(ip4_hdr);
 132     } else {
 133         size_t opts_len = full_ip6hdr_len - sizeof(struct ip6_header);
 134         l4len = be16_to_cpu(ip6_hdr->ip6_ctlun.ip6_un1.ip6_un1_plen) - opts_len;
 135     }
 136
 137     return l4len > TCP_HEADER_DATA_OFFSET(tcp);
 138 }
 139
 140 void eth_get_protocols(const struct iovec *iov, int iovcnt,
 141                        bool *isip4, bool *isip6,
 142                        bool *isudp, bool *istcp,
 143                        size_t *l3hdr_off,
 144                        size_t *l4hdr_off,
 145                        size_t *l5hdr_off,
 146                        eth_ip6_hdr_info *ip6hdr_info,
 147                        eth_ip4_hdr_info *ip4hdr_info,
 148                        eth_l4_hdr_info  *l4hdr_info)
 149 {
 150     int proto;
 151     bool fragment = false;
 152     size_t l2hdr_len = eth_get_l2_hdr_length_iov(iov, iovcnt);
 153     size_t input_size = iov_size(iov, iovcnt);
 154     size_t copied;
 155
 156     *isip4 = *isip6 = *isudp = *istcp = false;
 157
 158     proto = eth_get_l3_proto(iov, iovcnt, l2hdr_len);
 159
 160     *l3hdr_off = l2hdr_len;
 161
 162     if (proto == ETH_P_IP) {
 163         struct ip_header *iphdr = &ip4hdr_info->ip4_hdr;
 164
 165         if (input_size < l2hdr_len) {
 166             return;
 167         }
 168
 169         copied = iov_to_buf(iov, iovcnt, l2hdr_len, iphdr, sizeof(*iphdr));
 170
 171         *isip4 = true;
 172
 173         if (copied < sizeof(*iphdr)) {
 174             return;
 175         }
 176
 177         if (IP_HEADER_VERSION(iphdr) == IP_HEADER_VERSION_4) {
 178             if (iphdr->ip_p == IP_PROTO_TCP) {
 179                 *istcp = true;
 180             } else if (iphdr->ip_p == IP_PROTO_UDP) {
 181                 *isudp = true;
 182             }
 183         }
 184
 185         ip4hdr_info->fragment = IP4_IS_FRAGMENT(iphdr);
 186         *l4hdr_off = l2hdr_len + IP_HDR_GET_LEN(iphdr);
 187
 188         fragment = ip4hdr_info->fragment;
 189     } else if (proto == ETH_P_IPV6) {
 190
 191         *isip6 = true;
 192         if (eth_parse_ipv6_hdr(iov, iovcnt, l2hdr_len,
 193                                ip6hdr_info)) {
 194             if (ip6hdr_info->l4proto == IP_PROTO_TCP) {
 195                 *istcp = true;
 196             } else if (ip6hdr_info->l4proto == IP_PROTO_UDP) {
 197                 *isudp = true;
 198             }
 199         } else {
 200             return;
 201         }
 202
 203         *l4hdr_off = l2hdr_len + ip6hdr_info->full_hdr_len;
 204         fragment = ip6hdr_info->fragment;
 205     }
 206
 207     if (!fragment) {
 208         if (*istcp) {
 209             *istcp = _eth_copy_chunk(input_size,
 210                                      iov, iovcnt,
 211                                      *l4hdr_off, sizeof(l4hdr_info->hdr.tcp),
 212                                      &l4hdr_info->hdr.tcp);
 213
 214             if (*istcp) {
 215                 *l5hdr_off = *l4hdr_off +
 216                     TCP_HEADER_DATA_OFFSET(&l4hdr_info->hdr.tcp);
 217
 218                 l4hdr_info->has_tcp_data =
 219                     _eth_tcp_has_data(proto == ETH_P_IP,
 220                                       &ip4hdr_info->ip4_hdr,
 221                                       &ip6hdr_info->ip6_hdr,
 222                                       *l4hdr_off - *l3hdr_off,
 223                                       &l4hdr_info->hdr.tcp);
 224             }
 225         } else if (*isudp) {
 226             *isudp = _eth_copy_chunk(input_size,
 227                                      iov, iovcnt,
 228                                      *l4hdr_off, sizeof(l4hdr_info->hdr.udp),
 229                                      &l4hdr_info->hdr.udp);
 230             *l5hdr_off = *l4hdr_off + sizeof(l4hdr_info->hdr.udp);
 231         }
 232     }
 233 }
 234
 235 bool
 236 eth_strip_vlan(const struct iovec *iov, int iovcnt, size_t iovoff,
 237                uint8_t *new_ehdr_buf,
 238                uint16_t *payload_offset, uint16_t *tci)
 239 {
 240     struct vlan_header vlan_hdr;
 241     struct eth_header *new_ehdr = (struct eth_header *) new_ehdr_buf;
 242
 243     size_t copied = iov_to_buf(iov, iovcnt, iovoff,
 244                                new_ehdr, sizeof(*new_ehdr));
 245
 246     if (copied < sizeof(*new_ehdr)) {
 247         return false;
 248     }
 249
 250     switch (be16_to_cpu(new_ehdr->h_proto)) {
 251     case ETH_P_VLAN:
 252     case ETH_P_DVLAN:
 253         copied = iov_to_buf(iov, iovcnt, iovoff + sizeof(*new_ehdr),
 254                             &vlan_hdr, sizeof(vlan_hdr));
 255
 256         if (copied < sizeof(vlan_hdr)) {
 257             return false;
 258         }
 259
 260         new_ehdr->h_proto = vlan_hdr.h_proto;
 261
 262         *tci = be16_to_cpu(vlan_hdr.h_tci);
 263         *payload_offset = iovoff + sizeof(*new_ehdr) + sizeof(vlan_hdr);
 264
 265         if (be16_to_cpu(new_ehdr->h_proto) == ETH_P_VLAN) {
 266
 267             copied = iov_to_buf(iov, iovcnt, *payload_offset,
 268                                 PKT_GET_VLAN_HDR(new_ehdr), sizeof(vlan_hdr));
 269
 270             if (copied < sizeof(vlan_hdr)) {
 271                 return false;
 272             }
 273
 274             *payload_offset += sizeof(vlan_hdr);
 275         }
 276         return true;
 277     default:
 278         return false;
 279     }
 280 }
 281
 282 bool
 283 eth_strip_vlan_ex(const struct iovec *iov, int iovcnt, size_t iovoff,
 284                   uint16_t vet, uint8_t *new_ehdr_buf,
 285                   uint16_t *payload_offset, uint16_t *tci)
 286 {
 287     struct vlan_header vlan_hdr;
 288     struct eth_header *new_ehdr = (struct eth_header *) new_ehdr_buf;
 289
 290     size_t copied = iov_to_buf(iov, iovcnt, iovoff,
 291                                new_ehdr, sizeof(*new_ehdr));
 292
 293     if (copied < sizeof(*new_ehdr)) {
 294         return false;
 295     }
 296
 297     if (be16_to_cpu(new_ehdr->h_proto) == vet) {
 298         copied = iov_to_buf(iov, iovcnt, iovoff + sizeof(*new_ehdr),
 299                             &vlan_hdr, sizeof(vlan_hdr));
 300
 301         if (copied < sizeof(vlan_hdr)) {
 302             return false;
 303         }
 304
 305         new_ehdr->h_proto = vlan_hdr.h_proto;
 306
 307         *tci = be16_to_cpu(vlan_hdr.h_tci);
 308         *payload_offset = iovoff + sizeof(*new_ehdr) + sizeof(vlan_hdr);
 309         return true;
 310     }
 311
 312     return false;
 313 }
 314
 315 void
 316 eth_setup_ip4_fragmentation(const void *l2hdr, size_t l2hdr_len,
 317                             void *l3hdr, size_t l3hdr_len,
 318                             size_t l3payload_len,
 319                             size_t frag_offset, bool more_frags)
 320 {
 321     const struct iovec l2vec = {
 322         .iov_base = (void *) l2hdr,
 323         .iov_len = l2hdr_len
 324     };
 325
 326     if (eth_get_l3_proto(&l2vec, 1, l2hdr_len) == ETH_P_IP) {
 327         uint16_t orig_flags;
 328         struct ip_header *iphdr = (struct ip_header *) l3hdr;
 329         uint16_t frag_off_units = frag_offset / IP_FRAG_UNIT_SIZE;
 330         uint16_t new_ip_off;
 331
 332         assert(frag_offset % IP_FRAG_UNIT_SIZE == 0);
 333         assert((frag_off_units & ~IP_OFFMASK) == 0);
 334
 335         orig_flags = be16_to_cpu(iphdr->ip_off) & ~(IP_OFFMASK|IP_MF);
 336         new_ip_off = frag_off_units | orig_flags  | (more_frags ? IP_MF : 0);
 337         iphdr->ip_off = cpu_to_be16(new_ip_off);
 338         iphdr->ip_len = cpu_to_be16(l3payload_len + l3hdr_len);
 339     }
 340 }
 341
 342 void
 343 eth_fix_ip4_checksum(void *l3hdr, size_t l3hdr_len)
 344 {
 345     struct ip_header *iphdr = (struct ip_header *) l3hdr;
 346     iphdr->ip_sum = 0;
 347     iphdr->ip_sum = cpu_to_be16(net_raw_checksum(l3hdr, l3hdr_len));
 348 }
 349
 350 uint32_t
 351 eth_calc_ip4_pseudo_hdr_csum(struct ip_header *iphdr,
 352                              uint16_t csl,
 353                              uint32_t *cso)
 354 {
 355     struct ip_pseudo_header ipph;
 356     ipph.ip_src = iphdr->ip_src;
 357     ipph.ip_dst = iphdr->ip_dst;
 358     ipph.ip_payload = cpu_to_be16(csl);
 359     ipph.ip_proto = iphdr->ip_p;
 360     ipph.zeros = 0;
 361     *cso = sizeof(ipph);
 362     return net_checksum_add(*cso, (uint8_t *) &ipph);
 363 }
 364
 365 uint32_t
 366 eth_calc_ip6_pseudo_hdr_csum(struct ip6_header *iphdr,
 367                              uint16_t csl,
 368                              uint8_t l4_proto,
 369                              uint32_t *cso)
 370 {
 371     struct ip6_pseudo_header ipph;
 372     ipph.ip6_src = iphdr->ip6_src;
 373     ipph.ip6_dst = iphdr->ip6_dst;
 374     ipph.len = cpu_to_be16(csl);
 375     ipph.zero[0] = 0;
 376     ipph.zero[1] = 0;
 377     ipph.zero[2] = 0;
 378     ipph.next_hdr = l4_proto;
 379     *cso = sizeof(ipph);
 380     return net_checksum_add(*cso, (uint8_t *)&ipph);
 381 }
 382
 383 static bool
 384 eth_is_ip6_extension_header_type(uint8_t hdr_type)
 385 {
 386     switch (hdr_type) {
 387     case IP6_HOP_BY_HOP:
 388     case IP6_ROUTING:
 389     case IP6_FRAGMENT:
 390     case IP6_ESP:
 391     case IP6_AUTHENTICATION:
 392     case IP6_DESTINATON:
 393     case IP6_MOBILITY:
 394         return true;
 395     default:
 396         return false;
 397     }
 398 }
 399
 400 static bool
 401 _eth_get_rss_ex_dst_addr(const struct iovec *pkt, int pkt_frags,
 402                         size_t rthdr_offset,
 403                         struct ip6_ext_hdr *ext_hdr,
 404                         struct in6_address *dst_addr)
 405 {
 406     struct ip6_ext_hdr_routing *rthdr = (struct ip6_ext_hdr_routing *) ext_hdr;
 407
 408     if ((rthdr->rtype == 2) &&
 409         (rthdr->len == sizeof(struct in6_address) / 8) &&
 410         (rthdr->segleft == 1)) {
 411
 412         size_t input_size = iov_size(pkt, pkt_frags);
 413         size_t bytes_read;
 414
 415         if (input_size < rthdr_offset + sizeof(*ext_hdr)) {
 416             return false;
 417         }
 418
 419         bytes_read = iov_to_buf(pkt, pkt_frags,
 420                                 rthdr_offset + sizeof(*ext_hdr),
 421                                 dst_addr, sizeof(*dst_addr));
 422
 423         return bytes_read == sizeof(dst_addr);
 424     }
 425
 426     return false;
 427 }
 428
 429 static bool
 430 _eth_get_rss_ex_src_addr(const struct iovec *pkt, int pkt_frags,
 431                         size_t dsthdr_offset,
 432                         struct ip6_ext_hdr *ext_hdr,
 433                         struct in6_address *src_addr)
 434 {
 435     size_t bytes_left = (ext_hdr->ip6r_len + 1) * 8 - sizeof(*ext_hdr);
 436     struct ip6_option_hdr opthdr;
 437     size_t opt_offset = dsthdr_offset + sizeof(*ext_hdr);
 438
 439     while (bytes_left > sizeof(opthdr)) {
 440         size_t input_size = iov_size(pkt, pkt_frags);
 441         size_t bytes_read, optlen;
 442
 443         if (input_size < opt_offset) {
 444             return false;
 445         }
 446
 447         bytes_read = iov_to_buf(pkt, pkt_frags, opt_offset,
 448                                 &opthdr, sizeof(opthdr));
 449
 450         if (bytes_read != sizeof(opthdr)) {
 451             return false;
 452         }
 453
 454         optlen = (opthdr.type == IP6_OPT_PAD1) ? 1
 455                                                : (opthdr.len + sizeof(opthdr));
 456
 457         if (optlen > bytes_left) {
 458             return false;
 459         }
 460
 461         if (opthdr.type == IP6_OPT_HOME) {
 462             size_t input_size = iov_size(pkt, pkt_frags);
 463
 464             if (input_size < opt_offset + sizeof(opthdr)) {
 465                 return false;
 466             }
 467
 468             bytes_read = iov_to_buf(pkt, pkt_frags,
 469                                     opt_offset + sizeof(opthdr),
 470                                     src_addr, sizeof(*src_addr));
 471
 472             return bytes_read == sizeof(src_addr);
 473         }
 474
 475         opt_offset += optlen;
 476         bytes_left -= optlen;
 477     }
 478
 479     return false;
 480 }
 481
 482 bool eth_parse_ipv6_hdr(const struct iovec *pkt, int pkt_frags,
 483                         size_t ip6hdr_off, eth_ip6_hdr_info *info)
 484 {
 485     struct ip6_ext_hdr ext_hdr;
 486     size_t bytes_read;
 487     uint8_t curr_ext_hdr_type;
 488     size_t input_size = iov_size(pkt, pkt_frags);
 489
 490     info->rss_ex_dst_valid = false;
 491     info->rss_ex_src_valid = false;
 492     info->fragment = false;
 493
 494     if (input_size < ip6hdr_off) {
 495         return false;
 496     }
 497
 498     bytes_read = iov_to_buf(pkt, pkt_frags, ip6hdr_off,
 499                             &info->ip6_hdr, sizeof(info->ip6_hdr));
 500     if (bytes_read < sizeof(info->ip6_hdr)) {
 501         return false;
 502     }
 503
 504     info->full_hdr_len = sizeof(struct ip6_header);
 505
 506     curr_ext_hdr_type = info->ip6_hdr.ip6_nxt;
 507
 508     if (!eth_is_ip6_extension_header_type(curr_ext_hdr_type)) {
 509         info->l4proto = info->ip6_hdr.ip6_nxt;
 510         info->has_ext_hdrs = false;
 511         return true;
 512     }
 513
 514     info->has_ext_hdrs = true;
 515
 516     do {
 517         if (input_size < ip6hdr_off + info->full_hdr_len) {
 518             return false;
 519         }
 520
 521         bytes_read = iov_to_buf(pkt, pkt_frags, ip6hdr_off + info->full_hdr_len,
 522                                 &ext_hdr, sizeof(ext_hdr));
 523
 524         if (bytes_read < sizeof(ext_hdr)) {
 525             return false;
 526         }
 527
 528         if (curr_ext_hdr_type == IP6_ROUTING) {
 529             info->rss_ex_dst_valid =
 530                 _eth_get_rss_ex_dst_addr(pkt, pkt_frags,
 531                                          ip6hdr_off + info->full_hdr_len,
 532                                          &ext_hdr, &info->rss_ex_dst);
 533         } else if (curr_ext_hdr_type == IP6_DESTINATON) {
 534             info->rss_ex_src_valid =
 535                 _eth_get_rss_ex_src_addr(pkt, pkt_frags,
 536                                          ip6hdr_off + info->full_hdr_len,
 537                                          &ext_hdr, &info->rss_ex_src);
 538         } else if (curr_ext_hdr_type == IP6_FRAGMENT) {
 539             info->fragment = true;
 540         }
 541
 542         info->full_hdr_len += (ext_hdr.ip6r_len + 1) * IP6_EXT_GRANULARITY;
 543         curr_ext_hdr_type = ext_hdr.ip6r_nxt;
 544     } while (eth_is_ip6_extension_header_type(curr_ext_hdr_type));
 545
 546     info->l4proto = ext_hdr.ip6r_nxt;
 547     return true;
 548 }