net/ipv6/exthdrs.c

   1 /*
   2  *      Extension Header handling for IPv6
   3  *      Linux INET6 implementation
   4  *
   5  *      Authors:
   6  *      Pedro Roque             <roque@di.fc.ul.pt>
   7  *      Andi Kleen              <ak@muc.de>
   8  *      Alexey Kuznetsov        <kuznet@ms2.inr.ac.ru>
   9  *
  10  *      $Id: exthdrs.c,v 1.13 2001/06/19 15:58:56 davem Exp $
  11  *
  12  *      This program is free software; you can redistribute it and/or
  13  *      modify it under the terms of the GNU General Public License
  14  *      as published by the Free Software Foundation; either version
  15  *      2 of the License, or (at your option) any later version.
  16  */
  17
  18 /* Changes:
  19  *      yoshfuji                : ensure not to overrun while parsing
  20  *                                tlv options.
  21  *      Mitsuru KANDA @USAGI and: Remove ipv6_parse_exthdrs().
  22  *      YOSHIFUJI Hideaki @USAGI  Register inbound extension header
  23  *                                handlers as inet6_protocol{}.
  24  */
  25
  26 #include <linux/errno.h>
  27 #include <linux/types.h>
  28 #include <linux/socket.h>
  29 #include <linux/sockios.h>
  30 #include <linux/sched.h>
  31 #include <linux/net.h>
  32 #include <linux/netdevice.h>
  33 #include <linux/in6.h>
  34 #include <linux/icmpv6.h>
  35
  36 #include <net/sock.h>
  37 #include <net/snmp.h>
  38
  39 #include <net/ipv6.h>
  40 #include <net/protocol.h>
  41 #include <net/transp_v6.h>
  42 #include <net/rawv6.h>
  43 #include <net/ndisc.h>
  44 #include <net/ip6_route.h>
  45 #include <net/addrconf.h>
  46 #ifdef CONFIG_IPV6_MIP6
  47 #include <net/xfrm.h>
  48 #endif
  49
  50 #include <asm/uaccess.h>
  51
  52 int ipv6_find_tlv(struct sk_buff *skb, int offset, int type)
  53 {
  54         int packet_len = skb->tail - skb->nh.raw;
  55         struct ipv6_opt_hdr *hdr;
  56         int len;
  57
  58         if (offset + 2 > packet_len)
  59                 goto bad;
  60         hdr = (struct ipv6_opt_hdr*)(skb->nh.raw + offset);
  61         len = ((hdr->hdrlen + 1) << 3);
  62
  63         if (offset + len > packet_len)
  64                 goto bad;
  65
  66         offset += 2;
  67         len -= 2;
  68
  69         while (len > 0) {
  70                 int opttype = skb->nh.raw[offset];
  71                 int optlen;
  72
  73                 if (opttype == type)
  74                         return offset;
  75
  76                 switch (opttype) {
  77                 case IPV6_TLV_PAD0:
  78                         optlen = 1;
  79                         break;
  80                 default:
  81                         optlen = skb->nh.raw[offset + 1] + 2;
  82                         if (optlen > len)
  83                                 goto bad;
  84                         break;
  85                 }
  86                 offset += optlen;
  87                 len -= optlen;
  88         }
  89         /* not_found */
  90  bad:
  91         return -1;
  92 }
  93
  94 /*
  95  *      Parsing tlv encoded headers.
  96  *
  97  *      Parsing function "func" returns 1, if parsing succeed
  98  *      and 0, if it failed.
  99  *      It MUST NOT touch skb->h.
 100  */
 101
 102 struct tlvtype_proc {
 103         int     type;
 104         int     (*func)(struct sk_buff **skbp, int offset);
 105 };
 106
 107 /*********************
 108   Generic functions
 109  *********************/
 110
 111 /* An unknown option is detected, decide what to do */
 112
 113 static int ip6_tlvopt_unknown(struct sk_buff **skbp, int optoff)
 114 {
 115         struct sk_buff *skb = *skbp;
 116
 117         switch ((skb->nh.raw[optoff] & 0xC0) >> 6) {
 118         case 0: /* ignore */
 119                 return 1;
 120
 121         case 1: /* drop packet */
 122                 break;
 123
 124         case 3: /* Send ICMP if not a multicast address and drop packet */
 125                 /* Actually, it is redundant check. icmp_send
 126                    will recheck in any case.
 127                  */
 128                 if (ipv6_addr_is_multicast(&skb->nh.ipv6h->daddr))
 129                         break;
 130         case 2: /* send ICMP PARM PROB regardless and drop packet */
 131                 icmpv6_param_prob(skb, ICMPV6_UNK_OPTION, optoff);
 132                 return 0;
 133         };
 134
 135         kfree_skb(skb);
 136         return 0;
 137 }
 138
 139 /* Parse tlv encoded option header (hop-by-hop or destination) */
 140
 141 static int ip6_parse_tlv(struct tlvtype_proc *procs, struct sk_buff **skbp)
 142 {
 143         struct sk_buff *skb = *skbp;
 144         struct tlvtype_proc *curr;
 145         int off = skb->h.raw - skb->nh.raw;
 146         int len = ((skb->h.raw[1]+1)<<3);
 147
 148         if ((skb->h.raw + len) - skb->data > skb_headlen(skb))
 149                 goto bad;
 150
 151         off += 2;
 152         len -= 2;
 153
 154         while (len > 0) {
 155                 int optlen = skb->nh.raw[off+1]+2;
 156
 157                 switch (skb->nh.raw[off]) {
 158                 case IPV6_TLV_PAD0:
 159                         optlen = 1;
 160                         break;
 161
 162                 case IPV6_TLV_PADN:
 163                         break;
 164
 165                 default: /* Other TLV code so scan list */
 166                         if (optlen > len)
 167                                 goto bad;
 168                         for (curr=procs; curr->type >= 0; curr++) {
 169                                 if (curr->type == skb->nh.raw[off]) {
 170                                         /* type specific length/alignment
 171                                            checks will be performed in the
 172                                            func(). */
 173                                         if (curr->func(skbp, off) == 0)
 174                                                 return 0;
 175                                         break;
 176                                 }
 177                         }
 178                         if (curr->type < 0) {
 179                                 if (ip6_tlvopt_unknown(skbp, off) == 0)
 180                                         return 0;
 181                         }
 182                         break;
 183                 }
 184                 off += optlen;
 185                 len -= optlen;
 186         }
 187         if (len == 0)
 188                 return 1;
 189 bad:
 190         kfree_skb(skb);
 191         return 0;
 192 }
 193
 194 /*****************************
 195   Destination options header.
 196  *****************************/
 197
 198 #ifdef CONFIG_IPV6_MIP6
 199 static int ipv6_dest_hao(struct sk_buff **skbp, int optoff)
 200 {
 201         struct sk_buff *skb = *skbp;
 202         struct ipv6_destopt_hao *hao;
 203         struct inet6_skb_parm *opt = IP6CB(skb);
 204         struct ipv6hdr *ipv6h = (struct ipv6hdr *)skb->nh.raw;
 205         struct in6_addr tmp_addr;
 206         int ret;
 207
 208         if (opt->dsthao) {
 209                 LIMIT_NETDEBUG(KERN_DEBUG "hao duplicated\n");
 210                 goto discard;
 211         }
 212         opt->dsthao = opt->dst1;
 213         opt->dst1 = 0;
 214
 215         hao = (struct ipv6_destopt_hao *)(skb->nh.raw + optoff);
 216
 217         if (hao->length != 16) {
 218                 LIMIT_NETDEBUG(
 219                         KERN_DEBUG "hao invalid option length = %d\n", hao->length);
 220                 goto discard;
 221         }
 222
 223         if (!(ipv6_addr_type(&hao->addr) & IPV6_ADDR_UNICAST)) {
 224                 LIMIT_NETDEBUG(
 225                         KERN_DEBUG "hao is not an unicast addr: " NIP6_FMT "\n", NIP6(hao->addr));
 226                 goto discard;
 227         }
 228
 229         ret = xfrm6_input_addr(skb, (xfrm_address_t *)&ipv6h->daddr,
 230                                (xfrm_address_t *)&hao->addr, IPPROTO_DSTOPTS);
 231         if (unlikely(ret < 0))
 232                 goto discard;
 233
 234         if (skb_cloned(skb)) {
 235                 struct sk_buff *skb2 = skb_copy(skb, GFP_ATOMIC);
 236                 struct inet6_skb_parm *opt2;
 237
 238                 if (skb2 == NULL)
 239                         goto discard;
 240
 241                 opt2 = IP6CB(skb2);
 242                 memcpy(opt2, opt, sizeof(*opt2));
 243
 244                 kfree_skb(skb);
 245
 246                 /* update all variable using below by copied skbuff */
 247                 *skbp = skb = skb2;
 248                 hao = (struct ipv6_destopt_hao *)(skb2->nh.raw + optoff);
 249                 ipv6h = (struct ipv6hdr *)skb2->nh.raw;
 250         }
 251
 252         if (skb->ip_summed == CHECKSUM_COMPLETE)
 253                 skb->ip_summed = CHECKSUM_NONE;
 254
 255         ipv6_addr_copy(&tmp_addr, &ipv6h->saddr);
 256         ipv6_addr_copy(&ipv6h->saddr, &hao->addr);
 257         ipv6_addr_copy(&hao->addr, &tmp_addr);
 258
 259         if (skb->tstamp.off_sec == 0)
 260                 __net_timestamp(skb);
 261
 262         return 1;
 263
 264  discard:
 265         kfree_skb(skb);
 266         return 0;
 267 }
 268 #endif
 269
 270 static struct tlvtype_proc tlvprocdestopt_lst[] = {
 271 #ifdef CONFIG_IPV6_MIP6
 272         {
 273                 .type   = IPV6_TLV_HAO,
 274                 .func   = ipv6_dest_hao,
 275         },
 276 #endif
 277         {-1,                    NULL}
 278 };
 279
 280 static int ipv6_destopt_rcv(struct sk_buff **skbp)
 281 {
 282         struct sk_buff *skb = *skbp;
 283         struct inet6_skb_parm *opt = IP6CB(skb);
 284 #ifdef CONFIG_IPV6_MIP6
 285         __u16 dstbuf;
 286 #endif
 287
 288         if (!pskb_may_pull(skb, (skb->h.raw-skb->data)+8) ||
 289             !pskb_may_pull(skb, (skb->h.raw-skb->data)+((skb->h.raw[1]+1)<<3))) {
 290                 IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 291                 kfree_skb(skb);
 292                 return -1;
 293         }
 294
 295         opt->lastopt = skb->h.raw - skb->nh.raw;
 296         opt->dst1 = skb->h.raw - skb->nh.raw;
 297 #ifdef CONFIG_IPV6_MIP6
 298         dstbuf = opt->dst1;
 299 #endif
 300
 301         if (ip6_parse_tlv(tlvprocdestopt_lst, skbp)) {
 302                 skb = *skbp;
 303                 skb->h.raw += ((skb->h.raw[1]+1)<<3);
 304                 opt = IP6CB(skb);
 305 #ifdef CONFIG_IPV6_MIP6
 306                 opt->nhoff = dstbuf;
 307 #else
 308                 opt->nhoff = opt->dst1;
 309 #endif
 310                 return 1;
 311         }
 312
 313         IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 314         return -1;
 315 }
 316
 317 static struct inet6_protocol destopt_protocol = {
 318         .handler        =       ipv6_destopt_rcv,
 319         .flags          =       INET6_PROTO_NOPOLICY | INET6_PROTO_GSO_EXTHDR,
 320 };
 321
 322 void __init ipv6_destopt_init(void)
 323 {
 324         if (inet6_add_protocol(&destopt_protocol, IPPROTO_DSTOPTS) < 0)
 325                 printk(KERN_ERR "ipv6_destopt_init: Could not register protocol\n");
 326 }
 327
 328 /********************************
 329   NONE header. No data in packet.
 330  ********************************/
 331
 332 static int ipv6_nodata_rcv(struct sk_buff **skbp)
 333 {
 334         struct sk_buff *skb = *skbp;
 335
 336         kfree_skb(skb);
 337         return 0;
 338 }
 339
 340 static struct inet6_protocol nodata_protocol = {
 341         .handler        =       ipv6_nodata_rcv,
 342         .flags          =       INET6_PROTO_NOPOLICY,
 343 };
 344
 345 void __init ipv6_nodata_init(void)
 346 {
 347         if (inet6_add_protocol(&nodata_protocol, IPPROTO_NONE) < 0)
 348                 printk(KERN_ERR "ipv6_nodata_init: Could not register protocol\n");
 349 }
 350
 351 /********************************
 352   Routing header.
 353  ********************************/
 354
 355 static int ipv6_rthdr_rcv(struct sk_buff **skbp)
 356 {
 357         struct sk_buff *skb = *skbp;
 358         struct inet6_skb_parm *opt = IP6CB(skb);
 359         struct in6_addr *addr = NULL;
 360         struct in6_addr daddr;
 361         int n, i;
 362
 363         struct ipv6_rt_hdr *hdr;
 364         struct rt0_hdr *rthdr;
 365
 366         if (!pskb_may_pull(skb, (skb->h.raw-skb->data)+8) ||
 367             !pskb_may_pull(skb, (skb->h.raw-skb->data)+((skb->h.raw[1]+1)<<3))) {
 368                 IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 369                 kfree_skb(skb);
 370                 return -1;
 371         }
 372
 373         hdr = (struct ipv6_rt_hdr *) skb->h.raw;
 374
 375         if (ipv6_addr_is_multicast(&skb->nh.ipv6h->daddr) ||
 376             skb->pkt_type != PACKET_HOST) {
 377                 IP6_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);
 378                 kfree_skb(skb);
 379                 return -1;
 380         }
 381
 382 looped_back:
 383         if (hdr->segments_left == 0) {
 384                 switch (hdr->type) {
 385 #ifdef CONFIG_IPV6_MIP6
 386                 case IPV6_SRCRT_TYPE_2:
 387                         /* Silently discard type 2 header unless it was
 388                          * processed by own
 389                          */
 390                         if (!addr) {
 391                                 IP6_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);
 392                                 kfree_skb(skb);
 393                                 return -1;
 394                         }
 395                         break;
 396 #endif
 397                 default:
 398                         break;
 399                 }
 400
 401                 opt->lastopt = skb->h.raw - skb->nh.raw;
 402                 opt->srcrt = skb->h.raw - skb->nh.raw;
 403                 skb->h.raw += (hdr->hdrlen + 1) << 3;
 404                 opt->dst0 = opt->dst1;
 405                 opt->dst1 = 0;
 406                 opt->nhoff = (&hdr->nexthdr) - skb->nh.raw;
 407                 return 1;
 408         }
 409
 410         switch (hdr->type) {
 411         case IPV6_SRCRT_TYPE_0:
 412                 if (hdr->hdrlen & 0x01) {
 413                         IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 414                         icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, (&hdr->hdrlen) - skb->nh.raw);
 415                         return -1;
 416                 }
 417                 break;
 418 #ifdef CONFIG_IPV6_MIP6
 419         case IPV6_SRCRT_TYPE_2:
 420                 /* Silently discard invalid RTH type 2 */
 421                 if (hdr->hdrlen != 2 || hdr->segments_left != 1) {
 422                         IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 423                         kfree_skb(skb);
 424                         return -1;
 425                 }
 426                 break;
 427 #endif
 428         default:
 429                 IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 430                 icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, (&hdr->type) - skb->nh.raw);
 431                 return -1;
 432         }
 433
 434         /*
 435          *      This is the routing header forwarding algorithm from
 436          *      RFC 2460, page 16.
 437          */
 438
 439         n = hdr->hdrlen >> 1;
 440
 441         if (hdr->segments_left > n) {
 442                 IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 443                 icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, (&hdr->segments_left) - skb->nh.raw);
 444                 return -1;
 445         }
 446
 447         /* We are about to mangle packet header. Be careful!
 448            Do not damage packets queued somewhere.
 449          */
 450         if (skb_cloned(skb)) {
 451                 struct sk_buff *skb2 = skb_copy(skb, GFP_ATOMIC);
 452                 kfree_skb(skb);
 453                 /* the copy is a forwarded packet */
 454                 if (skb2 == NULL) {
 455                         IP6_INC_STATS_BH(IPSTATS_MIB_OUTDISCARDS);
 456                         return -1;
 457                 }
 458                 *skbp = skb = skb2;
 459                 opt = IP6CB(skb2);
 460                 hdr = (struct ipv6_rt_hdr *) skb2->h.raw;
 461         }
 462
 463         if (skb->ip_summed == CHECKSUM_COMPLETE)
 464                 skb->ip_summed = CHECKSUM_NONE;
 465
 466         i = n - --hdr->segments_left;
 467
 468         rthdr = (struct rt0_hdr *) hdr;
 469         addr = rthdr->addr;
 470         addr += i - 1;
 471
 472         switch (hdr->type) {
 473 #ifdef CONFIG_IPV6_MIP6
 474         case IPV6_SRCRT_TYPE_2:
 475                 if (xfrm6_input_addr(skb, (xfrm_address_t *)addr,
 476                                      (xfrm_address_t *)&skb->nh.ipv6h->saddr,
 477                                      IPPROTO_ROUTING) < 0) {
 478                         IP6_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);
 479                         kfree_skb(skb);
 480                         return -1;
 481                 }
 482                 if (!ipv6_chk_home_addr(addr)) {
 483                         IP6_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);
 484                         kfree_skb(skb);
 485                         return -1;
 486                 }
 487                 break;
 488 #endif
 489         default:
 490                 break;
 491         }
 492
 493         if (ipv6_addr_is_multicast(addr)) {
 494                 IP6_INC_STATS_BH(IPSTATS_MIB_INADDRERRORS);
 495                 kfree_skb(skb);
 496                 return -1;
 497         }
 498
 499         ipv6_addr_copy(&daddr, addr);
 500         ipv6_addr_copy(addr, &skb->nh.ipv6h->daddr);
 501         ipv6_addr_copy(&skb->nh.ipv6h->daddr, &daddr);
 502
 503         dst_release(xchg(&skb->dst, NULL));
 504         ip6_route_input(skb);
 505         if (skb->dst->error) {
 506                 skb_push(skb, skb->data - skb->nh.raw);
 507                 dst_input(skb);
 508                 return -1;
 509         }
 510
 511         if (skb->dst->dev->flags&IFF_LOOPBACK) {
 512                 if (skb->nh.ipv6h->hop_limit <= 1) {
 513                         IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 514                         icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
 515                                     0, skb->dev);
 516                         kfree_skb(skb);
 517                         return -1;
 518                 }
 519                 skb->nh.ipv6h->hop_limit--;
 520                 goto looped_back;
 521         }
 522
 523         skb_push(skb, skb->data - skb->nh.raw);
 524         dst_input(skb);
 525         return -1;
 526 }
 527
 528 static struct inet6_protocol rthdr_protocol = {
 529         .handler        =       ipv6_rthdr_rcv,
 530         .flags          =       INET6_PROTO_NOPOLICY | INET6_PROTO_GSO_EXTHDR,
 531 };
 532
 533 void __init ipv6_rthdr_init(void)
 534 {
 535         if (inet6_add_protocol(&rthdr_protocol, IPPROTO_ROUTING) < 0)
 536                 printk(KERN_ERR "ipv6_rthdr_init: Could not register protocol\n");
 537 };
 538
 539 /*
 540    This function inverts received rthdr.
 541    NOTE: specs allow to make it automatically only if
 542    packet authenticated.
 543
 544    I will not discuss it here (though, I am really pissed off at
 545    this stupid requirement making rthdr idea useless)
 546
 547    Actually, it creates severe problems  for us.
 548    Embryonic requests has no associated sockets,
 549    so that user have no control over it and
 550    cannot not only to set reply options, but
 551    even to know, that someone wants to connect
 552    without success. :-(
 553
 554    For now we need to test the engine, so that I created
 555    temporary (or permanent) backdoor.
 556    If listening socket set IPV6_RTHDR to 2, then we invert header.
 557                                                    --ANK (980729)
 558  */
 559
 560 struct ipv6_txoptions *
 561 ipv6_invert_rthdr(struct sock *sk, struct ipv6_rt_hdr *hdr)
 562 {
 563         /* Received rthdr:
 564
 565            [ H1 -> H2 -> ... H_prev ]  daddr=ME
 566
 567            Inverted result:
 568            [ H_prev -> ... -> H1 ] daddr =sender
 569
 570            Note, that IP output engine will rewrite this rthdr
 571            by rotating it left by one addr.
 572          */
 573
 574         int n, i;
 575         struct rt0_hdr *rthdr = (struct rt0_hdr*)hdr;
 576         struct rt0_hdr *irthdr;
 577         struct ipv6_txoptions *opt;
 578         int hdrlen = ipv6_optlen(hdr);
 579
 580         if (hdr->segments_left ||
 581             hdr->type != IPV6_SRCRT_TYPE_0 ||
 582             hdr->hdrlen & 0x01)
 583                 return NULL;
 584
 585         n = hdr->hdrlen >> 1;
 586         opt = sock_kmalloc(sk, sizeof(*opt) + hdrlen, GFP_ATOMIC);
 587         if (opt == NULL)
 588                 return NULL;
 589         memset(opt, 0, sizeof(*opt));
 590         opt->tot_len = sizeof(*opt) + hdrlen;
 591         opt->srcrt = (void*)(opt+1);
 592         opt->opt_nflen = hdrlen;
 593
 594         memcpy(opt->srcrt, hdr, sizeof(*hdr));
 595         irthdr = (struct rt0_hdr*)opt->srcrt;
 596         irthdr->reserved = 0;
 597         opt->srcrt->segments_left = n;
 598         for (i=0; i<n; i++)
 599                 memcpy(irthdr->addr+i, rthdr->addr+(n-1-i), 16);
 600         return opt;
 601 }
 602
 603 EXPORT_SYMBOL_GPL(ipv6_invert_rthdr);
 604
 605 /**********************************
 606   Hop-by-hop options.
 607  **********************************/
 608
 609 /* Router Alert as of RFC 2711 */
 610
 611 static int ipv6_hop_ra(struct sk_buff **skbp, int optoff)
 612 {
 613         struct sk_buff *skb = *skbp;
 614
 615         if (skb->nh.raw[optoff+1] == 2) {
 616                 IP6CB(skb)->ra = optoff;
 617                 return 1;
 618         }
 619         LIMIT_NETDEBUG(KERN_DEBUG "ipv6_hop_ra: wrong RA length %d\n",
 620                        skb->nh.raw[optoff+1]);
 621         kfree_skb(skb);
 622         return 0;
 623 }
 624
 625 /* Jumbo payload */
 626
 627 static int ipv6_hop_jumbo(struct sk_buff **skbp, int optoff)
 628 {
 629         struct sk_buff *skb = *skbp;
 630         u32 pkt_len;
 631
 632         if (skb->nh.raw[optoff+1] != 4 || (optoff&3) != 2) {
 633                 LIMIT_NETDEBUG(KERN_DEBUG "ipv6_hop_jumbo: wrong jumbo opt length/alignment %d\n",
 634                                skb->nh.raw[optoff+1]);
 635                 IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 636                 goto drop;
 637         }
 638
 639         pkt_len = ntohl(*(u32*)(skb->nh.raw+optoff+2));
 640         if (pkt_len <= IPV6_MAXPLEN) {
 641                 IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 642                 icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, optoff+2);
 643                 return 0;
 644         }
 645         if (skb->nh.ipv6h->payload_len) {
 646                 IP6_INC_STATS_BH(IPSTATS_MIB_INHDRERRORS);
 647                 icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, optoff);
 648                 return 0;
 649         }
 650
 651         if (pkt_len > skb->len - sizeof(struct ipv6hdr)) {
 652                 IP6_INC_STATS_BH(IPSTATS_MIB_INTRUNCATEDPKTS);
 653                 goto drop;
 654         }
 655
 656         if (pskb_trim_rcsum(skb, pkt_len + sizeof(struct ipv6hdr)))
 657                 goto drop;
 658
 659         return 1;
 660
 661 drop:
 662         kfree_skb(skb);
 663         return 0;
 664 }
 665
 666 static struct tlvtype_proc tlvprochopopt_lst[] = {
 667         {
 668                 .type   = IPV6_TLV_ROUTERALERT,
 669                 .func   = ipv6_hop_ra,
 670         },
 671         {
 672                 .type   = IPV6_TLV_JUMBO,
 673                 .func   = ipv6_hop_jumbo,
 674         },
 675         { -1, }
 676 };
 677
 678 int ipv6_parse_hopopts(struct sk_buff **skbp)
 679 {
 680         struct sk_buff *skb = *skbp;
 681         struct inet6_skb_parm *opt = IP6CB(skb);
 682
 683         /*
 684          * skb->nh.raw is equal to skb->data, and
 685          * skb->h.raw - skb->nh.raw is always equal to
 686          * sizeof(struct ipv6hdr) by definition of
 687          * hop-by-hop options.
 688          */
 689         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr) + 8) ||
 690             !pskb_may_pull(skb, sizeof(struct ipv6hdr) + ((skb->h.raw[1] + 1) << 3))) {
 691                 kfree_skb(skb);
 692                 return -1;
 693         }
 694
 695         opt->hop = sizeof(struct ipv6hdr);
 696         if (ip6_parse_tlv(tlvprochopopt_lst, skbp)) {
 697                 skb = *skbp;
 698                 skb->h.raw += (skb->h.raw[1]+1)<<3;
 699                 opt = IP6CB(skb);
 700                 opt->nhoff = sizeof(struct ipv6hdr);
 701                 return 1;
 702         }
 703         return -1;
 704 }
 705
 706 /*
 707  *      Creating outbound headers.
 708  *
 709  *      "build" functions work when skb is filled from head to tail (datagram)
 710  *      "push"  functions work when headers are added from tail to head (tcp)
 711  *
 712  *      In both cases we assume, that caller reserved enough room
 713  *      for headers.
 714  */
 715
 716 static void ipv6_push_rthdr(struct sk_buff *skb, u8 *proto,
 717                             struct ipv6_rt_hdr *opt,
 718                             struct in6_addr **addr_p)
 719 {
 720         struct rt0_hdr *phdr, *ihdr;
 721         int hops;
 722
 723         ihdr = (struct rt0_hdr *) opt;
 724
 725         phdr = (struct rt0_hdr *) skb_push(skb, (ihdr->rt_hdr.hdrlen + 1) << 3);
 726         memcpy(phdr, ihdr, sizeof(struct rt0_hdr));
 727
 728         hops = ihdr->rt_hdr.hdrlen >> 1;
 729
 730         if (hops > 1)
 731                 memcpy(phdr->addr, ihdr->addr + 1,
 732                        (hops - 1) * sizeof(struct in6_addr));
 733
 734         ipv6_addr_copy(phdr->addr + (hops - 1), *addr_p);
 735         *addr_p = ihdr->addr;
 736
 737         phdr->rt_hdr.nexthdr = *proto;
 738         *proto = NEXTHDR_ROUTING;
 739 }
 740
 741 static void ipv6_push_exthdr(struct sk_buff *skb, u8 *proto, u8 type, struct ipv6_opt_hdr *opt)
 742 {
 743         struct ipv6_opt_hdr *h = (struct ipv6_opt_hdr *)skb_push(skb, ipv6_optlen(opt));
 744
 745         memcpy(h, opt, ipv6_optlen(opt));
 746         h->nexthdr = *proto;
 747         *proto = type;
 748 }
 749
 750 void ipv6_push_nfrag_opts(struct sk_buff *skb, struct ipv6_txoptions *opt,
 751                           u8 *proto,
 752                           struct in6_addr **daddr)
 753 {
 754         if (opt->srcrt) {
 755                 ipv6_push_rthdr(skb, proto, opt->srcrt, daddr);
 756                 /*
 757                  * IPV6_RTHDRDSTOPTS is ignored
 758                  * unless IPV6_RTHDR is set (RFC3542).
 759                  */
 760                 if (opt->dst0opt)
 761                         ipv6_push_exthdr(skb, proto, NEXTHDR_DEST, opt->dst0opt);
 762         }
 763         if (opt->hopopt)
 764                 ipv6_push_exthdr(skb, proto, NEXTHDR_HOP, opt->hopopt);
 765 }
 766
 767 void ipv6_push_frag_opts(struct sk_buff *skb, struct ipv6_txoptions *opt, u8 *proto)
 768 {
 769         if (opt->dst1opt)
 770                 ipv6_push_exthdr(skb, proto, NEXTHDR_DEST, opt->dst1opt);
 771 }
 772
 773 struct ipv6_txoptions *
 774 ipv6_dup_options(struct sock *sk, struct ipv6_txoptions *opt)
 775 {
 776         struct ipv6_txoptions *opt2;
 777
 778         opt2 = sock_kmalloc(sk, opt->tot_len, GFP_ATOMIC);
 779         if (opt2) {
 780                 long dif = (char*)opt2 - (char*)opt;
 781                 memcpy(opt2, opt, opt->tot_len);
 782                 if (opt2->hopopt)
 783                         *((char**)&opt2->hopopt) += dif;
 784                 if (opt2->dst0opt)
 785                         *((char**)&opt2->dst0opt) += dif;
 786                 if (opt2->dst1opt)
 787                         *((char**)&opt2->dst1opt) += dif;
 788                 if (opt2->srcrt)
 789                         *((char**)&opt2->srcrt) += dif;
 790         }
 791         return opt2;
 792 }
 793
 794 EXPORT_SYMBOL_GPL(ipv6_dup_options);
 795
 796 static int ipv6_renew_option(void *ohdr,
 797                              struct ipv6_opt_hdr __user *newopt, int newoptlen,
 798                              int inherit,
 799                              struct ipv6_opt_hdr **hdr,
 800                              char **p)
 801 {
 802         if (inherit) {
 803                 if (ohdr) {
 804                         memcpy(*p, ohdr, ipv6_optlen((struct ipv6_opt_hdr *)ohdr));
 805                         *hdr = (struct ipv6_opt_hdr *)*p;
 806                         *p += CMSG_ALIGN(ipv6_optlen(*(struct ipv6_opt_hdr **)hdr));
 807                 }
 808         } else {
 809                 if (newopt) {
 810                         if (copy_from_user(*p, newopt, newoptlen))
 811                                 return -EFAULT;
 812                         *hdr = (struct ipv6_opt_hdr *)*p;
 813                         if (ipv6_optlen(*(struct ipv6_opt_hdr **)hdr) > newoptlen)
 814                                 return -EINVAL;
 815                         *p += CMSG_ALIGN(newoptlen);
 816                 }
 817         }
 818         return 0;
 819 }
 820
 821 struct ipv6_txoptions *
 822 ipv6_renew_options(struct sock *sk, struct ipv6_txoptions *opt,
 823                    int newtype,
 824                    struct ipv6_opt_hdr __user *newopt, int newoptlen)
 825 {
 826         int tot_len = 0;
 827         char *p;
 828         struct ipv6_txoptions *opt2;
 829         int err;
 830
 831         if (opt) {
 832                 if (newtype != IPV6_HOPOPTS && opt->hopopt)
 833                         tot_len += CMSG_ALIGN(ipv6_optlen(opt->hopopt));
 834                 if (newtype != IPV6_RTHDRDSTOPTS && opt->dst0opt)
 835                         tot_len += CMSG_ALIGN(ipv6_optlen(opt->dst0opt));
 836                 if (newtype != IPV6_RTHDR && opt->srcrt)
 837                         tot_len += CMSG_ALIGN(ipv6_optlen(opt->srcrt));
 838                 if (newtype != IPV6_DSTOPTS && opt->dst1opt)
 839                         tot_len += CMSG_ALIGN(ipv6_optlen(opt->dst1opt));
 840         }
 841
 842         if (newopt && newoptlen)
 843                 tot_len += CMSG_ALIGN(newoptlen);
 844
 845         if (!tot_len)
 846                 return NULL;
 847
 848         tot_len += sizeof(*opt2);
 849         opt2 = sock_kmalloc(sk, tot_len, GFP_ATOMIC);
 850         if (!opt2)
 851                 return ERR_PTR(-ENOBUFS);
 852
 853         memset(opt2, 0, tot_len);
 854
 855         opt2->tot_len = tot_len;
 856         p = (char *)(opt2 + 1);
 857
 858         err = ipv6_renew_option(opt ? opt->hopopt : NULL, newopt, newoptlen,
 859                                 newtype != IPV6_HOPOPTS,
 860                                 &opt2->hopopt, &p);
 861         if (err)
 862                 goto out;
 863
 864         err = ipv6_renew_option(opt ? opt->dst0opt : NULL, newopt, newoptlen,
 865                                 newtype != IPV6_RTHDRDSTOPTS,
 866                                 &opt2->dst0opt, &p);
 867         if (err)
 868                 goto out;
 869
 870         err = ipv6_renew_option(opt ? opt->srcrt : NULL, newopt, newoptlen,
 871                                 newtype != IPV6_RTHDR,
 872                                 (struct ipv6_opt_hdr **)&opt2->srcrt, &p);
 873         if (err)
 874                 goto out;
 875
 876         err = ipv6_renew_option(opt ? opt->dst1opt : NULL, newopt, newoptlen,
 877                                 newtype != IPV6_DSTOPTS,
 878                                 &opt2->dst1opt, &p);
 879         if (err)
 880                 goto out;
 881
 882         opt2->opt_nflen = (opt2->hopopt ? ipv6_optlen(opt2->hopopt) : 0) +
 883                           (opt2->dst0opt ? ipv6_optlen(opt2->dst0opt) : 0) +
 884                           (opt2->srcrt ? ipv6_optlen(opt2->srcrt) : 0);
 885         opt2->opt_flen = (opt2->dst1opt ? ipv6_optlen(opt2->dst1opt) : 0);
 886
 887         return opt2;
 888 out:
 889         sock_kfree_s(sk, opt2, opt2->tot_len);
 890         return ERR_PTR(err);
 891 }
 892
 893 struct ipv6_txoptions *ipv6_fixup_options(struct ipv6_txoptions *opt_space,
 894                                           struct ipv6_txoptions *opt)
 895 {
 896         /*
 897          * ignore the dest before srcrt unless srcrt is being included.
 898          * --yoshfuji
 899          */
 900         if (opt && opt->dst0opt && !opt->srcrt) {
 901                 if (opt_space != opt) {
 902                         memcpy(opt_space, opt, sizeof(*opt_space));
 903                         opt = opt_space;
 904                 }
 905                 opt->opt_nflen -= ipv6_optlen(opt->dst0opt);
 906                 opt->dst0opt = NULL;
 907         }
 908
 909         return opt;
 910 }
 911