linux/net/ipv6/ip6_input.c
<<
>>
Prefs
   1/*
   2 *      IPv6 input
   3 *      Linux INET6 implementation
   4 *
   5 *      Authors:
   6 *      Pedro Roque             <roque@di.fc.ul.pt>
   7 *      Ian P. Morris           <I.P.Morris@soton.ac.uk>
   8 *
   9 *      Based in linux/net/ipv4/ip_input.c
  10 *
  11 *      This program is free software; you can redistribute it and/or
  12 *      modify it under the terms of the GNU General Public License
  13 *      as published by the Free Software Foundation; either version
  14 *      2 of the License, or (at your option) any later version.
  15 */
  16/* Changes
  17 *
  18 *      Mitsuru KANDA @USAGI and
  19 *      YOSHIFUJI Hideaki @USAGI: Remove ipv6_parse_exthdrs().
  20 */
  21
  22#include <linux/errno.h>
  23#include <linux/types.h>
  24#include <linux/socket.h>
  25#include <linux/sockios.h>
  26#include <linux/net.h>
  27#include <linux/netdevice.h>
  28#include <linux/in6.h>
  29#include <linux/icmpv6.h>
  30#include <linux/mroute6.h>
  31#include <linux/slab.h>
  32
  33#include <linux/netfilter.h>
  34#include <linux/netfilter_ipv6.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#include <net/xfrm.h>
  47
  48
  49
  50int ip6_rcv_finish(struct sk_buff *skb)
  51{
  52        if (sysctl_ip_early_demux && !skb_dst(skb)) {
  53                const struct inet6_protocol *ipprot;
  54
  55                ipprot = rcu_dereference(inet6_protos[ipv6_hdr(skb)->nexthdr]);
  56                if (ipprot && ipprot->early_demux)
  57                        ipprot->early_demux(skb);
  58        }
  59        if (!skb_dst(skb))
  60                ip6_route_input(skb);
  61
  62        return dst_input(skb);
  63}
  64
  65int ipv6_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
  66{
  67        const struct ipv6hdr *hdr;
  68        u32             pkt_len;
  69        struct inet6_dev *idev;
  70        struct net *net = dev_net(skb->dev);
  71
  72        if (skb->pkt_type == PACKET_OTHERHOST) {
  73                kfree_skb(skb);
  74                return NET_RX_DROP;
  75        }
  76
  77        rcu_read_lock();
  78
  79        idev = __in6_dev_get(skb->dev);
  80
  81        IP6_UPD_PO_STATS_BH(net, idev, IPSTATS_MIB_IN, skb->len);
  82
  83        if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL ||
  84            !idev || unlikely(idev->cnf.disable_ipv6)) {
  85                IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_INDISCARDS);
  86                goto drop;
  87        }
  88
  89        memset(IP6CB(skb), 0, sizeof(struct inet6_skb_parm));
  90
  91        /*
  92         * Store incoming device index. When the packet will
  93         * be queued, we cannot refer to skb->dev anymore.
  94         *
  95         * BTW, when we send a packet for our own local address on a
  96         * non-loopback interface (e.g. ethX), it is being delivered
  97         * via the loopback interface (lo) here; skb->dev = loopback_dev.
  98         * It, however, should be considered as if it is being
  99         * arrived via the sending interface (ethX), because of the
 100         * nature of scoping architecture. --yoshfuji
 101         */
 102        IP6CB(skb)->iif = skb_dst(skb) ? ip6_dst_idev(skb_dst(skb))->dev->ifindex : dev->ifindex;
 103
 104        if (unlikely(!pskb_may_pull(skb, sizeof(*hdr))))
 105                goto err;
 106
 107        hdr = ipv6_hdr(skb);
 108
 109        if (hdr->version != 6)
 110                goto err;
 111
 112        /*
 113         * RFC4291 2.5.3
 114         * A packet received on an interface with a destination address
 115         * of loopback must be dropped.
 116         */
 117        if (!(dev->flags & IFF_LOOPBACK) &&
 118            ipv6_addr_loopback(&hdr->daddr))
 119                goto err;
 120
 121        /*
 122         * RFC4291 2.7
 123         * Multicast addresses must not be used as source addresses in IPv6
 124         * packets or appear in any Routing header.
 125         */
 126        if (ipv6_addr_is_multicast(&hdr->saddr))
 127                goto err;
 128
 129        skb->transport_header = skb->network_header + sizeof(*hdr);
 130        IP6CB(skb)->nhoff = offsetof(struct ipv6hdr, nexthdr);
 131
 132        pkt_len = ntohs(hdr->payload_len);
 133
 134        /* pkt_len may be zero if Jumbo payload option is present */
 135        if (pkt_len || hdr->nexthdr != NEXTHDR_HOP) {
 136                if (pkt_len + sizeof(struct ipv6hdr) > skb->len) {
 137                        IP6_INC_STATS_BH(net,
 138                                         idev, IPSTATS_MIB_INTRUNCATEDPKTS);
 139                        goto drop;
 140                }
 141                if (pskb_trim_rcsum(skb, pkt_len + sizeof(struct ipv6hdr))) {
 142                        IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_INHDRERRORS);
 143                        goto drop;
 144                }
 145                hdr = ipv6_hdr(skb);
 146        }
 147
 148        if (hdr->nexthdr == NEXTHDR_HOP) {
 149                if (ipv6_parse_hopopts(skb) < 0) {
 150                        IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_INHDRERRORS);
 151                        rcu_read_unlock();
 152                        return NET_RX_DROP;
 153                }
 154        }
 155
 156        rcu_read_unlock();
 157
 158        /* Must drop socket now because of tproxy. */
 159        skb_orphan(skb);
 160
 161        return NF_HOOK(NFPROTO_IPV6, NF_INET_PRE_ROUTING, skb, dev, NULL,
 162                       ip6_rcv_finish);
 163err:
 164        IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_INHDRERRORS);
 165drop:
 166        rcu_read_unlock();
 167        kfree_skb(skb);
 168        return NET_RX_DROP;
 169}
 170
 171/*
 172 *      Deliver the packet to the host
 173 */
 174
 175
 176static int ip6_input_finish(struct sk_buff *skb)
 177{
 178        struct net *net = dev_net(skb_dst(skb)->dev);
 179        const struct inet6_protocol *ipprot;
 180        struct inet6_dev *idev;
 181        unsigned int nhoff;
 182        int nexthdr;
 183        bool raw;
 184
 185        /*
 186         *      Parse extension headers
 187         */
 188
 189        rcu_read_lock();
 190resubmit:
 191        idev = ip6_dst_idev(skb_dst(skb));
 192        if (!pskb_pull(skb, skb_transport_offset(skb)))
 193                goto discard;
 194        nhoff = IP6CB(skb)->nhoff;
 195        nexthdr = skb_network_header(skb)[nhoff];
 196
 197        raw = raw6_local_deliver(skb, nexthdr);
 198        if ((ipprot = rcu_dereference(inet6_protos[nexthdr])) != NULL) {
 199                int ret;
 200
 201                if (ipprot->flags & INET6_PROTO_FINAL) {
 202                        const struct ipv6hdr *hdr;
 203
 204                        /* Free reference early: we don't need it any more,
 205                           and it may hold ip_conntrack module loaded
 206                           indefinitely. */
 207                        nf_reset(skb);
 208
 209                        skb_postpull_rcsum(skb, skb_network_header(skb),
 210                                           skb_network_header_len(skb));
 211                        hdr = ipv6_hdr(skb);
 212                        if (ipv6_addr_is_multicast(&hdr->daddr) &&
 213                            !ipv6_chk_mcast_addr(skb->dev, &hdr->daddr,
 214                            &hdr->saddr) &&
 215                            !ipv6_is_mld(skb, nexthdr))
 216                                goto discard;
 217                }
 218                if (!(ipprot->flags & INET6_PROTO_NOPOLICY) &&
 219                    !xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
 220                        goto discard;
 221
 222                ret = ipprot->handler(skb);
 223                if (ret > 0)
 224                        goto resubmit;
 225                else if (ret == 0)
 226                        IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_INDELIVERS);
 227        } else {
 228                if (!raw) {
 229                        if (xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
 230                                IP6_INC_STATS_BH(net, idev,
 231                                                 IPSTATS_MIB_INUNKNOWNPROTOS);
 232                                icmpv6_send(skb, ICMPV6_PARAMPROB,
 233                                            ICMPV6_UNK_NEXTHDR, nhoff);
 234                        }
 235                } else
 236                        IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_INDELIVERS);
 237                kfree_skb(skb);
 238        }
 239        rcu_read_unlock();
 240        return 0;
 241
 242discard:
 243        IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_INDISCARDS);
 244        rcu_read_unlock();
 245        kfree_skb(skb);
 246        return 0;
 247}
 248
 249
 250int ip6_input(struct sk_buff *skb)
 251{
 252        return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_IN, skb, skb->dev, NULL,
 253                       ip6_input_finish);
 254}
 255
 256int ip6_mc_input(struct sk_buff *skb)
 257{
 258        const struct ipv6hdr *hdr;
 259        bool deliver;
 260
 261        IP6_UPD_PO_STATS_BH(dev_net(skb_dst(skb)->dev),
 262                         ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_INMCAST,
 263                         skb->len);
 264
 265        hdr = ipv6_hdr(skb);
 266        deliver = ipv6_chk_mcast_addr(skb->dev, &hdr->daddr, NULL);
 267
 268#ifdef CONFIG_IPV6_MROUTE
 269        /*
 270         *      IPv6 multicast router mode is now supported ;)
 271         */
 272        if (dev_net(skb->dev)->ipv6.devconf_all->mc_forwarding &&
 273            !(ipv6_addr_type(&hdr->daddr) & IPV6_ADDR_LINKLOCAL) &&
 274            likely(!(IP6CB(skb)->flags & IP6SKB_FORWARDED))) {
 275                /*
 276                 * Okay, we try to forward - split and duplicate
 277                 * packets.
 278                 */
 279                struct sk_buff *skb2;
 280                struct inet6_skb_parm *opt = IP6CB(skb);
 281
 282                /* Check for MLD */
 283                if (unlikely(opt->ra)) {
 284                        /* Check if this is a mld message */
 285                        u8 *ptr = skb_network_header(skb) + opt->ra;
 286                        struct icmp6hdr *icmp6;
 287                        u8 nexthdr = hdr->nexthdr;
 288                        __be16 frag_off;
 289                        int offset;
 290
 291                        /* Check if the value of Router Alert
 292                         * is for MLD (0x0000).
 293                         */
 294                        if ((ptr[2] | ptr[3]) == 0) {
 295                                deliver = false;
 296
 297                                if (!ipv6_ext_hdr(nexthdr)) {
 298                                        /* BUG */
 299                                        goto out;
 300                                }
 301                                offset = ipv6_skip_exthdr(skb, sizeof(*hdr),
 302                                                          &nexthdr, &frag_off);
 303                                if (offset < 0)
 304                                        goto out;
 305
 306                                if (nexthdr != IPPROTO_ICMPV6)
 307                                        goto out;
 308
 309                                if (!pskb_may_pull(skb, (skb_network_header(skb) +
 310                                                   offset + 1 - skb->data)))
 311                                        goto out;
 312
 313                                icmp6 = (struct icmp6hdr *)(skb_network_header(skb) + offset);
 314
 315                                switch (icmp6->icmp6_type) {
 316                                case ICMPV6_MGM_QUERY:
 317                                case ICMPV6_MGM_REPORT:
 318                                case ICMPV6_MGM_REDUCTION:
 319                                case ICMPV6_MLD2_REPORT:
 320                                        deliver = true;
 321                                        break;
 322                                }
 323                                goto out;
 324                        }
 325                        /* unknown RA - process it normally */
 326                }
 327
 328                if (deliver)
 329                        skb2 = skb_clone(skb, GFP_ATOMIC);
 330                else {
 331                        skb2 = skb;
 332                        skb = NULL;
 333                }
 334
 335                if (skb2) {
 336                        ip6_mr_input(skb2);
 337                }
 338        }
 339out:
 340#endif
 341        if (likely(deliver))
 342                ip6_input(skb);
 343        else {
 344                /* discard */
 345                kfree_skb(skb);
 346        }
 347
 348        return 0;
 349}
 350
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.