Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  RAW sockets for IPv6
0004  *  Linux INET6 implementation
0005  *
0006  *  Authors:
0007  *  Pedro Roque     <roque@di.fc.ul.pt>
0008  *
0009  *  Adapted from linux/net/ipv4/raw.c
0010  *
0011  *  Fixes:
0012  *  Hideaki YOSHIFUJI   :   sin6_scope_id support
0013  *  YOSHIFUJI,H.@USAGI  :   raw checksum (RFC2292(bis) compliance)
0014  *  Kazunori MIYAZAWA @USAGI:   change process style to use ip6_append_data
0015  */
0016 
0017 #include <linux/errno.h>
0018 #include <linux/types.h>
0019 #include <linux/socket.h>
0020 #include <linux/slab.h>
0021 #include <linux/sockios.h>
0022 #include <linux/net.h>
0023 #include <linux/in6.h>
0024 #include <linux/netdevice.h>
0025 #include <linux/if_arp.h>
0026 #include <linux/icmpv6.h>
0027 #include <linux/netfilter.h>
0028 #include <linux/netfilter_ipv6.h>
0029 #include <linux/skbuff.h>
0030 #include <linux/compat.h>
0031 #include <linux/uaccess.h>
0032 #include <asm/ioctls.h>
0033 
0034 #include <net/net_namespace.h>
0035 #include <net/ip.h>
0036 #include <net/sock.h>
0037 #include <net/snmp.h>
0038 
0039 #include <net/ipv6.h>
0040 #include <net/ndisc.h>
0041 #include <net/protocol.h>
0042 #include <net/ip6_route.h>
0043 #include <net/ip6_checksum.h>
0044 #include <net/addrconf.h>
0045 #include <net/transp_v6.h>
0046 #include <net/udp.h>
0047 #include <net/inet_common.h>
0048 #include <net/tcp_states.h>
0049 #if IS_ENABLED(CONFIG_IPV6_MIP6)
0050 #include <net/mip6.h>
0051 #endif
0052 #include <linux/mroute6.h>
0053 
0054 #include <net/raw.h>
0055 #include <net/rawv6.h>
0056 #include <net/xfrm.h>
0057 
0058 #include <linux/proc_fs.h>
0059 #include <linux/seq_file.h>
0060 #include <linux/export.h>
0061 
0062 #define ICMPV6_HDRLEN   4   /* ICMPv6 header, RFC 4443 Section 2.1 */
0063 
0064 struct raw_hashinfo raw_v6_hashinfo;
0065 EXPORT_SYMBOL_GPL(raw_v6_hashinfo);
0066 
0067 bool raw_v6_match(struct net *net, struct sock *sk, unsigned short num,
0068           const struct in6_addr *loc_addr,
0069           const struct in6_addr *rmt_addr, int dif, int sdif)
0070 {
0071     if (inet_sk(sk)->inet_num != num ||
0072         !net_eq(sock_net(sk), net) ||
0073         (!ipv6_addr_any(&sk->sk_v6_daddr) &&
0074          !ipv6_addr_equal(&sk->sk_v6_daddr, rmt_addr)) ||
0075         !raw_sk_bound_dev_eq(net, sk->sk_bound_dev_if,
0076                  dif, sdif))
0077         return false;
0078 
0079     if (ipv6_addr_any(&sk->sk_v6_rcv_saddr) ||
0080         ipv6_addr_equal(&sk->sk_v6_rcv_saddr, loc_addr) ||
0081         (ipv6_addr_is_multicast(loc_addr) &&
0082          inet6_mc_check(sk, loc_addr, rmt_addr)))
0083         return true;
0084 
0085     return false;
0086 }
0087 EXPORT_SYMBOL_GPL(raw_v6_match);
0088 
0089 /*
0090  *  0 - deliver
0091  *  1 - block
0092  */
0093 static int icmpv6_filter(const struct sock *sk, const struct sk_buff *skb)
0094 {
0095     struct icmp6hdr _hdr;
0096     const struct icmp6hdr *hdr;
0097 
0098     /* We require only the four bytes of the ICMPv6 header, not any
0099      * additional bytes of message body in "struct icmp6hdr".
0100      */
0101     hdr = skb_header_pointer(skb, skb_transport_offset(skb),
0102                  ICMPV6_HDRLEN, &_hdr);
0103     if (hdr) {
0104         const __u32 *data = &raw6_sk(sk)->filter.data[0];
0105         unsigned int type = hdr->icmp6_type;
0106 
0107         return (data[type >> 5] & (1U << (type & 31))) != 0;
0108     }
0109     return 1;
0110 }
0111 
0112 #if IS_ENABLED(CONFIG_IPV6_MIP6)
0113 typedef int mh_filter_t(struct sock *sock, struct sk_buff *skb);
0114 
0115 static mh_filter_t __rcu *mh_filter __read_mostly;
0116 
0117 int rawv6_mh_filter_register(mh_filter_t filter)
0118 {
0119     rcu_assign_pointer(mh_filter, filter);
0120     return 0;
0121 }
0122 EXPORT_SYMBOL(rawv6_mh_filter_register);
0123 
0124 int rawv6_mh_filter_unregister(mh_filter_t filter)
0125 {
0126     RCU_INIT_POINTER(mh_filter, NULL);
0127     synchronize_rcu();
0128     return 0;
0129 }
0130 EXPORT_SYMBOL(rawv6_mh_filter_unregister);
0131 
0132 #endif
0133 
0134 /*
0135  *  demultiplex raw sockets.
0136  *  (should consider queueing the skb in the sock receive_queue
0137  *  without calling rawv6.c)
0138  *
0139  *  Caller owns SKB so we must make clones.
0140  */
0141 static bool ipv6_raw_deliver(struct sk_buff *skb, int nexthdr)
0142 {
0143     struct net *net = dev_net(skb->dev);
0144     struct hlist_nulls_head *hlist;
0145     struct hlist_nulls_node *hnode;
0146     const struct in6_addr *saddr;
0147     const struct in6_addr *daddr;
0148     struct sock *sk;
0149     bool delivered = false;
0150     __u8 hash;
0151 
0152     saddr = &ipv6_hdr(skb)->saddr;
0153     daddr = saddr + 1;
0154 
0155     hash = nexthdr & (RAW_HTABLE_SIZE - 1);
0156     hlist = &raw_v6_hashinfo.ht[hash];
0157     rcu_read_lock();
0158     sk_nulls_for_each(sk, hnode, hlist) {
0159         int filtered;
0160 
0161         if (!raw_v6_match(net, sk, nexthdr, daddr, saddr,
0162                   inet6_iif(skb), inet6_sdif(skb)))
0163             continue;
0164         delivered = true;
0165         switch (nexthdr) {
0166         case IPPROTO_ICMPV6:
0167             filtered = icmpv6_filter(sk, skb);
0168             break;
0169 
0170 #if IS_ENABLED(CONFIG_IPV6_MIP6)
0171         case IPPROTO_MH:
0172         {
0173             /* XXX: To validate MH only once for each packet,
0174              * this is placed here. It should be after checking
0175              * xfrm policy, however it doesn't. The checking xfrm
0176              * policy is placed in rawv6_rcv() because it is
0177              * required for each socket.
0178              */
0179             mh_filter_t *filter;
0180 
0181             filter = rcu_dereference(mh_filter);
0182             filtered = filter ? (*filter)(sk, skb) : 0;
0183             break;
0184         }
0185 #endif
0186         default:
0187             filtered = 0;
0188             break;
0189         }
0190 
0191         if (filtered < 0)
0192             break;
0193         if (filtered == 0) {
0194             struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);
0195 
0196             /* Not releasing hash table! */
0197             if (clone) {
0198                 nf_reset_ct(clone);
0199                 rawv6_rcv(sk, clone);
0200             }
0201         }
0202     }
0203     rcu_read_unlock();
0204     return delivered;
0205 }
0206 
0207 bool raw6_local_deliver(struct sk_buff *skb, int nexthdr)
0208 {
0209     return ipv6_raw_deliver(skb, nexthdr);
0210 }
0211 
0212 /* This cleans up af_inet6 a bit. -DaveM */
0213 static int rawv6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
0214 {
0215     struct inet_sock *inet = inet_sk(sk);
0216     struct ipv6_pinfo *np = inet6_sk(sk);
0217     struct sockaddr_in6 *addr = (struct sockaddr_in6 *) uaddr;
0218     __be32 v4addr = 0;
0219     int addr_type;
0220     int err;
0221 
0222     if (addr_len < SIN6_LEN_RFC2133)
0223         return -EINVAL;
0224 
0225     if (addr->sin6_family != AF_INET6)
0226         return -EINVAL;
0227 
0228     addr_type = ipv6_addr_type(&addr->sin6_addr);
0229 
0230     /* Raw sockets are IPv6 only */
0231     if (addr_type == IPV6_ADDR_MAPPED)
0232         return -EADDRNOTAVAIL;
0233 
0234     lock_sock(sk);
0235 
0236     err = -EINVAL;
0237     if (sk->sk_state != TCP_CLOSE)
0238         goto out;
0239 
0240     rcu_read_lock();
0241     /* Check if the address belongs to the host. */
0242     if (addr_type != IPV6_ADDR_ANY) {
0243         struct net_device *dev = NULL;
0244 
0245         if (__ipv6_addr_needs_scope_id(addr_type)) {
0246             if (addr_len >= sizeof(struct sockaddr_in6) &&
0247                 addr->sin6_scope_id) {
0248                 /* Override any existing binding, if another
0249                  * one is supplied by user.
0250                  */
0251                 sk->sk_bound_dev_if = addr->sin6_scope_id;
0252             }
0253 
0254             /* Binding to link-local address requires an interface */
0255             if (!sk->sk_bound_dev_if)
0256                 goto out_unlock;
0257         }
0258 
0259         if (sk->sk_bound_dev_if) {
0260             err = -ENODEV;
0261             dev = dev_get_by_index_rcu(sock_net(sk),
0262                            sk->sk_bound_dev_if);
0263             if (!dev)
0264                 goto out_unlock;
0265         }
0266 
0267         /* ipv4 addr of the socket is invalid.  Only the
0268          * unspecified and mapped address have a v4 equivalent.
0269          */
0270         v4addr = LOOPBACK4_IPV6;
0271         if (!(addr_type & IPV6_ADDR_MULTICAST) &&
0272             !ipv6_can_nonlocal_bind(sock_net(sk), inet)) {
0273             err = -EADDRNOTAVAIL;
0274             if (!ipv6_chk_addr(sock_net(sk), &addr->sin6_addr,
0275                        dev, 0)) {
0276                 goto out_unlock;
0277             }
0278         }
0279     }
0280 
0281     inet->inet_rcv_saddr = inet->inet_saddr = v4addr;
0282     sk->sk_v6_rcv_saddr = addr->sin6_addr;
0283     if (!(addr_type & IPV6_ADDR_MULTICAST))
0284         np->saddr = addr->sin6_addr;
0285     err = 0;
0286 out_unlock:
0287     rcu_read_unlock();
0288 out:
0289     release_sock(sk);
0290     return err;
0291 }
0292 
0293 static void rawv6_err(struct sock *sk, struct sk_buff *skb,
0294            struct inet6_skb_parm *opt,
0295            u8 type, u8 code, int offset, __be32 info)
0296 {
0297     struct inet_sock *inet = inet_sk(sk);
0298     struct ipv6_pinfo *np = inet6_sk(sk);
0299     int err;
0300     int harderr;
0301 
0302     /* Report error on raw socket, if:
0303        1. User requested recverr.
0304        2. Socket is connected (otherwise the error indication
0305           is useless without recverr and error is hard.
0306      */
0307     if (!np->recverr && sk->sk_state != TCP_ESTABLISHED)
0308         return;
0309 
0310     harderr = icmpv6_err_convert(type, code, &err);
0311     if (type == ICMPV6_PKT_TOOBIG) {
0312         ip6_sk_update_pmtu(skb, sk, info);
0313         harderr = (np->pmtudisc == IPV6_PMTUDISC_DO);
0314     }
0315     if (type == NDISC_REDIRECT) {
0316         ip6_sk_redirect(skb, sk);
0317         return;
0318     }
0319     if (np->recverr) {
0320         u8 *payload = skb->data;
0321         if (!inet->hdrincl)
0322             payload += offset;
0323         ipv6_icmp_error(sk, skb, err, 0, ntohl(info), payload);
0324     }
0325 
0326     if (np->recverr || harderr) {
0327         sk->sk_err = err;
0328         sk_error_report(sk);
0329     }
0330 }
0331 
0332 void raw6_icmp_error(struct sk_buff *skb, int nexthdr,
0333         u8 type, u8 code, int inner_offset, __be32 info)
0334 {
0335     struct net *net = dev_net(skb->dev);
0336     struct hlist_nulls_head *hlist;
0337     struct hlist_nulls_node *hnode;
0338     struct sock *sk;
0339     int hash;
0340 
0341     hash = nexthdr & (RAW_HTABLE_SIZE - 1);
0342     hlist = &raw_v6_hashinfo.ht[hash];
0343     rcu_read_lock();
0344     sk_nulls_for_each(sk, hnode, hlist) {
0345         /* Note: ipv6_hdr(skb) != skb->data */
0346         const struct ipv6hdr *ip6h = (const struct ipv6hdr *)skb->data;
0347 
0348         if (!raw_v6_match(net, sk, nexthdr, &ip6h->saddr, &ip6h->daddr,
0349                   inet6_iif(skb), inet6_iif(skb)))
0350             continue;
0351         rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
0352     }
0353     rcu_read_unlock();
0354 }
0355 
0356 static inline int rawv6_rcv_skb(struct sock *sk, struct sk_buff *skb)
0357 {
0358     if ((raw6_sk(sk)->checksum || rcu_access_pointer(sk->sk_filter)) &&
0359         skb_checksum_complete(skb)) {
0360         atomic_inc(&sk->sk_drops);
0361         kfree_skb(skb);
0362         return NET_RX_DROP;
0363     }
0364 
0365     /* Charge it to the socket. */
0366     skb_dst_drop(skb);
0367     if (sock_queue_rcv_skb(sk, skb) < 0) {
0368         kfree_skb(skb);
0369         return NET_RX_DROP;
0370     }
0371 
0372     return 0;
0373 }
0374 
0375 /*
0376  *  This is next to useless...
0377  *  if we demultiplex in network layer we don't need the extra call
0378  *  just to queue the skb...
0379  *  maybe we could have the network decide upon a hint if it
0380  *  should call raw_rcv for demultiplexing
0381  */
0382 int rawv6_rcv(struct sock *sk, struct sk_buff *skb)
0383 {
0384     struct inet_sock *inet = inet_sk(sk);
0385     struct raw6_sock *rp = raw6_sk(sk);
0386 
0387     if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) {
0388         atomic_inc(&sk->sk_drops);
0389         kfree_skb(skb);
0390         return NET_RX_DROP;
0391     }
0392 
0393     if (!rp->checksum)
0394         skb->ip_summed = CHECKSUM_UNNECESSARY;
0395 
0396     if (skb->ip_summed == CHECKSUM_COMPLETE) {
0397         skb_postpull_rcsum(skb, skb_network_header(skb),
0398                    skb_network_header_len(skb));
0399         if (!csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
0400                      &ipv6_hdr(skb)->daddr,
0401                      skb->len, inet->inet_num, skb->csum))
0402             skb->ip_summed = CHECKSUM_UNNECESSARY;
0403     }
0404     if (!skb_csum_unnecessary(skb))
0405         skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
0406                              &ipv6_hdr(skb)->daddr,
0407                              skb->len,
0408                              inet->inet_num, 0));
0409 
0410     if (inet->hdrincl) {
0411         if (skb_checksum_complete(skb)) {
0412             atomic_inc(&sk->sk_drops);
0413             kfree_skb(skb);
0414             return NET_RX_DROP;
0415         }
0416     }
0417 
0418     rawv6_rcv_skb(sk, skb);
0419     return 0;
0420 }
0421 
0422 
0423 /*
0424  *  This should be easy, if there is something there
0425  *  we return it, otherwise we block.
0426  */
0427 
0428 static int rawv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
0429              int flags, int *addr_len)
0430 {
0431     struct ipv6_pinfo *np = inet6_sk(sk);
0432     DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
0433     struct sk_buff *skb;
0434     size_t copied;
0435     int err;
0436 
0437     if (flags & MSG_OOB)
0438         return -EOPNOTSUPP;
0439 
0440     if (flags & MSG_ERRQUEUE)
0441         return ipv6_recv_error(sk, msg, len, addr_len);
0442 
0443     if (np->rxpmtu && np->rxopt.bits.rxpmtu)
0444         return ipv6_recv_rxpmtu(sk, msg, len, addr_len);
0445 
0446     skb = skb_recv_datagram(sk, flags, &err);
0447     if (!skb)
0448         goto out;
0449 
0450     copied = skb->len;
0451     if (copied > len) {
0452         copied = len;
0453         msg->msg_flags |= MSG_TRUNC;
0454     }
0455 
0456     if (skb_csum_unnecessary(skb)) {
0457         err = skb_copy_datagram_msg(skb, 0, msg, copied);
0458     } else if (msg->msg_flags&MSG_TRUNC) {
0459         if (__skb_checksum_complete(skb))
0460             goto csum_copy_err;
0461         err = skb_copy_datagram_msg(skb, 0, msg, copied);
0462     } else {
0463         err = skb_copy_and_csum_datagram_msg(skb, 0, msg);
0464         if (err == -EINVAL)
0465             goto csum_copy_err;
0466     }
0467     if (err)
0468         goto out_free;
0469 
0470     /* Copy the address. */
0471     if (sin6) {
0472         sin6->sin6_family = AF_INET6;
0473         sin6->sin6_port = 0;
0474         sin6->sin6_addr = ipv6_hdr(skb)->saddr;
0475         sin6->sin6_flowinfo = 0;
0476         sin6->sin6_scope_id = ipv6_iface_scope_id(&sin6->sin6_addr,
0477                               inet6_iif(skb));
0478         *addr_len = sizeof(*sin6);
0479     }
0480 
0481     sock_recv_cmsgs(msg, sk, skb);
0482 
0483     if (np->rxopt.all)
0484         ip6_datagram_recv_ctl(sk, msg, skb);
0485 
0486     err = copied;
0487     if (flags & MSG_TRUNC)
0488         err = skb->len;
0489 
0490 out_free:
0491     skb_free_datagram(sk, skb);
0492 out:
0493     return err;
0494 
0495 csum_copy_err:
0496     skb_kill_datagram(sk, skb, flags);
0497 
0498     /* Error for blocking case is chosen to masquerade
0499        as some normal condition.
0500      */
0501     err = (flags&MSG_DONTWAIT) ? -EAGAIN : -EHOSTUNREACH;
0502     goto out;
0503 }
0504 
0505 static int rawv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
0506                      struct raw6_sock *rp)
0507 {
0508     struct sk_buff *skb;
0509     int err = 0;
0510     int offset;
0511     int len;
0512     int total_len;
0513     __wsum tmp_csum;
0514     __sum16 csum;
0515 
0516     if (!rp->checksum)
0517         goto send;
0518 
0519     skb = skb_peek(&sk->sk_write_queue);
0520     if (!skb)
0521         goto out;
0522 
0523     offset = rp->offset;
0524     total_len = inet_sk(sk)->cork.base.length;
0525     if (offset >= total_len - 1) {
0526         err = -EINVAL;
0527         ip6_flush_pending_frames(sk);
0528         goto out;
0529     }
0530 
0531     /* should be check HW csum miyazawa */
0532     if (skb_queue_len(&sk->sk_write_queue) == 1) {
0533         /*
0534          * Only one fragment on the socket.
0535          */
0536         tmp_csum = skb->csum;
0537     } else {
0538         struct sk_buff *csum_skb = NULL;
0539         tmp_csum = 0;
0540 
0541         skb_queue_walk(&sk->sk_write_queue, skb) {
0542             tmp_csum = csum_add(tmp_csum, skb->csum);
0543 
0544             if (csum_skb)
0545                 continue;
0546 
0547             len = skb->len - skb_transport_offset(skb);
0548             if (offset >= len) {
0549                 offset -= len;
0550                 continue;
0551             }
0552 
0553             csum_skb = skb;
0554         }
0555 
0556         skb = csum_skb;
0557     }
0558 
0559     offset += skb_transport_offset(skb);
0560     err = skb_copy_bits(skb, offset, &csum, 2);
0561     if (err < 0) {
0562         ip6_flush_pending_frames(sk);
0563         goto out;
0564     }
0565 
0566     /* in case cksum was not initialized */
0567     if (unlikely(csum))
0568         tmp_csum = csum_sub(tmp_csum, csum_unfold(csum));
0569 
0570     csum = csum_ipv6_magic(&fl6->saddr, &fl6->daddr,
0571                    total_len, fl6->flowi6_proto, tmp_csum);
0572 
0573     if (csum == 0 && fl6->flowi6_proto == IPPROTO_UDP)
0574         csum = CSUM_MANGLED_0;
0575 
0576     BUG_ON(skb_store_bits(skb, offset, &csum, 2));
0577 
0578 send:
0579     err = ip6_push_pending_frames(sk);
0580 out:
0581     return err;
0582 }
0583 
0584 static int rawv6_send_hdrinc(struct sock *sk, struct msghdr *msg, int length,
0585             struct flowi6 *fl6, struct dst_entry **dstp,
0586             unsigned int flags, const struct sockcm_cookie *sockc)
0587 {
0588     struct ipv6_pinfo *np = inet6_sk(sk);
0589     struct net *net = sock_net(sk);
0590     struct ipv6hdr *iph;
0591     struct sk_buff *skb;
0592     int err;
0593     struct rt6_info *rt = (struct rt6_info *)*dstp;
0594     int hlen = LL_RESERVED_SPACE(rt->dst.dev);
0595     int tlen = rt->dst.dev->needed_tailroom;
0596 
0597     if (length > rt->dst.dev->mtu) {
0598         ipv6_local_error(sk, EMSGSIZE, fl6, rt->dst.dev->mtu);
0599         return -EMSGSIZE;
0600     }
0601     if (length < sizeof(struct ipv6hdr))
0602         return -EINVAL;
0603     if (flags&MSG_PROBE)
0604         goto out;
0605 
0606     skb = sock_alloc_send_skb(sk,
0607                   length + hlen + tlen + 15,
0608                   flags & MSG_DONTWAIT, &err);
0609     if (!skb)
0610         goto error;
0611     skb_reserve(skb, hlen);
0612 
0613     skb->protocol = htons(ETH_P_IPV6);
0614     skb->priority = sk->sk_priority;
0615     skb->mark = sockc->mark;
0616     skb->tstamp = sockc->transmit_time;
0617 
0618     skb_put(skb, length);
0619     skb_reset_network_header(skb);
0620     iph = ipv6_hdr(skb);
0621 
0622     skb->ip_summed = CHECKSUM_NONE;
0623 
0624     skb_setup_tx_timestamp(skb, sockc->tsflags);
0625 
0626     if (flags & MSG_CONFIRM)
0627         skb_set_dst_pending_confirm(skb, 1);
0628 
0629     skb->transport_header = skb->network_header;
0630     err = memcpy_from_msg(iph, msg, length);
0631     if (err) {
0632         err = -EFAULT;
0633         kfree_skb(skb);
0634         goto error;
0635     }
0636 
0637     skb_dst_set(skb, &rt->dst);
0638     *dstp = NULL;
0639 
0640     /* if egress device is enslaved to an L3 master device pass the
0641      * skb to its handler for processing
0642      */
0643     skb = l3mdev_ip6_out(sk, skb);
0644     if (unlikely(!skb))
0645         return 0;
0646 
0647     /* Acquire rcu_read_lock() in case we need to use rt->rt6i_idev
0648      * in the error path. Since skb has been freed, the dst could
0649      * have been queued for deletion.
0650      */
0651     rcu_read_lock();
0652     IP6_UPD_PO_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);
0653     err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, net, sk, skb,
0654               NULL, rt->dst.dev, dst_output);
0655     if (err > 0)
0656         err = net_xmit_errno(err);
0657     if (err) {
0658         IP6_INC_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
0659         rcu_read_unlock();
0660         goto error_check;
0661     }
0662     rcu_read_unlock();
0663 out:
0664     return 0;
0665 
0666 error:
0667     IP6_INC_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
0668 error_check:
0669     if (err == -ENOBUFS && !np->recverr)
0670         err = 0;
0671     return err;
0672 }
0673 
0674 struct raw6_frag_vec {
0675     struct msghdr *msg;
0676     int hlen;
0677     char c[4];
0678 };
0679 
0680 static int rawv6_probe_proto_opt(struct raw6_frag_vec *rfv, struct flowi6 *fl6)
0681 {
0682     int err = 0;
0683     switch (fl6->flowi6_proto) {
0684     case IPPROTO_ICMPV6:
0685         rfv->hlen = 2;
0686         err = memcpy_from_msg(rfv->c, rfv->msg, rfv->hlen);
0687         if (!err) {
0688             fl6->fl6_icmp_type = rfv->c[0];
0689             fl6->fl6_icmp_code = rfv->c[1];
0690         }
0691         break;
0692     case IPPROTO_MH:
0693         rfv->hlen = 4;
0694         err = memcpy_from_msg(rfv->c, rfv->msg, rfv->hlen);
0695         if (!err)
0696             fl6->fl6_mh_type = rfv->c[2];
0697     }
0698     return err;
0699 }
0700 
0701 static int raw6_getfrag(void *from, char *to, int offset, int len, int odd,
0702                struct sk_buff *skb)
0703 {
0704     struct raw6_frag_vec *rfv = from;
0705 
0706     if (offset < rfv->hlen) {
0707         int copy = min(rfv->hlen - offset, len);
0708 
0709         if (skb->ip_summed == CHECKSUM_PARTIAL)
0710             memcpy(to, rfv->c + offset, copy);
0711         else
0712             skb->csum = csum_block_add(
0713                 skb->csum,
0714                 csum_partial_copy_nocheck(rfv->c + offset,
0715                               to, copy),
0716                 odd);
0717 
0718         odd = 0;
0719         offset += copy;
0720         to += copy;
0721         len -= copy;
0722 
0723         if (!len)
0724             return 0;
0725     }
0726 
0727     offset -= rfv->hlen;
0728 
0729     return ip_generic_getfrag(rfv->msg, to, offset, len, odd, skb);
0730 }
0731 
0732 static int rawv6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
0733 {
0734     struct ipv6_txoptions *opt_to_free = NULL;
0735     struct ipv6_txoptions opt_space;
0736     DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
0737     struct in6_addr *daddr, *final_p, final;
0738     struct inet_sock *inet = inet_sk(sk);
0739     struct ipv6_pinfo *np = inet6_sk(sk);
0740     struct raw6_sock *rp = raw6_sk(sk);
0741     struct ipv6_txoptions *opt = NULL;
0742     struct ip6_flowlabel *flowlabel = NULL;
0743     struct dst_entry *dst = NULL;
0744     struct raw6_frag_vec rfv;
0745     struct flowi6 fl6;
0746     struct ipcm6_cookie ipc6;
0747     int addr_len = msg->msg_namelen;
0748     int hdrincl;
0749     u16 proto;
0750     int err;
0751 
0752     /* Rough check on arithmetic overflow,
0753        better check is made in ip6_append_data().
0754      */
0755     if (len > INT_MAX)
0756         return -EMSGSIZE;
0757 
0758     /* Mirror BSD error message compatibility */
0759     if (msg->msg_flags & MSG_OOB)
0760         return -EOPNOTSUPP;
0761 
0762     /* hdrincl should be READ_ONCE(inet->hdrincl)
0763      * but READ_ONCE() doesn't work with bit fields.
0764      * Doing this indirectly yields the same result.
0765      */
0766     hdrincl = inet->hdrincl;
0767     hdrincl = READ_ONCE(hdrincl);
0768 
0769     /*
0770      *  Get and verify the address.
0771      */
0772     memset(&fl6, 0, sizeof(fl6));
0773 
0774     fl6.flowi6_mark = sk->sk_mark;
0775     fl6.flowi6_uid = sk->sk_uid;
0776 
0777     ipcm6_init(&ipc6);
0778     ipc6.sockc.tsflags = sk->sk_tsflags;
0779     ipc6.sockc.mark = sk->sk_mark;
0780 
0781     if (sin6) {
0782         if (addr_len < SIN6_LEN_RFC2133)
0783             return -EINVAL;
0784 
0785         if (sin6->sin6_family && sin6->sin6_family != AF_INET6)
0786             return -EAFNOSUPPORT;
0787 
0788         /* port is the proto value [0..255] carried in nexthdr */
0789         proto = ntohs(sin6->sin6_port);
0790 
0791         if (!proto)
0792             proto = inet->inet_num;
0793         else if (proto != inet->inet_num)
0794             return -EINVAL;
0795 
0796         if (proto > 255)
0797             return -EINVAL;
0798 
0799         daddr = &sin6->sin6_addr;
0800         if (np->sndflow) {
0801             fl6.flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
0802             if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
0803                 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
0804                 if (IS_ERR(flowlabel))
0805                     return -EINVAL;
0806             }
0807         }
0808 
0809         /*
0810          * Otherwise it will be difficult to maintain
0811          * sk->sk_dst_cache.
0812          */
0813         if (sk->sk_state == TCP_ESTABLISHED &&
0814             ipv6_addr_equal(daddr, &sk->sk_v6_daddr))
0815             daddr = &sk->sk_v6_daddr;
0816 
0817         if (addr_len >= sizeof(struct sockaddr_in6) &&
0818             sin6->sin6_scope_id &&
0819             __ipv6_addr_needs_scope_id(__ipv6_addr_type(daddr)))
0820             fl6.flowi6_oif = sin6->sin6_scope_id;
0821     } else {
0822         if (sk->sk_state != TCP_ESTABLISHED)
0823             return -EDESTADDRREQ;
0824 
0825         proto = inet->inet_num;
0826         daddr = &sk->sk_v6_daddr;
0827         fl6.flowlabel = np->flow_label;
0828     }
0829 
0830     if (fl6.flowi6_oif == 0)
0831         fl6.flowi6_oif = sk->sk_bound_dev_if;
0832 
0833     if (msg->msg_controllen) {
0834         opt = &opt_space;
0835         memset(opt, 0, sizeof(struct ipv6_txoptions));
0836         opt->tot_len = sizeof(struct ipv6_txoptions);
0837         ipc6.opt = opt;
0838 
0839         err = ip6_datagram_send_ctl(sock_net(sk), sk, msg, &fl6, &ipc6);
0840         if (err < 0) {
0841             fl6_sock_release(flowlabel);
0842             return err;
0843         }
0844         if ((fl6.flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
0845             flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
0846             if (IS_ERR(flowlabel))
0847                 return -EINVAL;
0848         }
0849         if (!(opt->opt_nflen|opt->opt_flen))
0850             opt = NULL;
0851     }
0852     if (!opt) {
0853         opt = txopt_get(np);
0854         opt_to_free = opt;
0855     }
0856     if (flowlabel)
0857         opt = fl6_merge_options(&opt_space, flowlabel, opt);
0858     opt = ipv6_fixup_options(&opt_space, opt);
0859 
0860     fl6.flowi6_proto = proto;
0861     fl6.flowi6_mark = ipc6.sockc.mark;
0862 
0863     if (!hdrincl) {
0864         rfv.msg = msg;
0865         rfv.hlen = 0;
0866         err = rawv6_probe_proto_opt(&rfv, &fl6);
0867         if (err)
0868             goto out;
0869     }
0870 
0871     if (!ipv6_addr_any(daddr))
0872         fl6.daddr = *daddr;
0873     else
0874         fl6.daddr.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
0875     if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
0876         fl6.saddr = np->saddr;
0877 
0878     final_p = fl6_update_dst(&fl6, opt, &final);
0879 
0880     if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
0881         fl6.flowi6_oif = np->mcast_oif;
0882     else if (!fl6.flowi6_oif)
0883         fl6.flowi6_oif = np->ucast_oif;
0884     security_sk_classify_flow(sk, flowi6_to_flowi_common(&fl6));
0885 
0886     if (hdrincl)
0887         fl6.flowi6_flags |= FLOWI_FLAG_KNOWN_NH;
0888 
0889     if (ipc6.tclass < 0)
0890         ipc6.tclass = np->tclass;
0891 
0892     fl6.flowlabel = ip6_make_flowinfo(ipc6.tclass, fl6.flowlabel);
0893 
0894     dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
0895     if (IS_ERR(dst)) {
0896         err = PTR_ERR(dst);
0897         goto out;
0898     }
0899     if (ipc6.hlimit < 0)
0900         ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
0901 
0902     if (ipc6.dontfrag < 0)
0903         ipc6.dontfrag = np->dontfrag;
0904 
0905     if (msg->msg_flags&MSG_CONFIRM)
0906         goto do_confirm;
0907 
0908 back_from_confirm:
0909     if (hdrincl)
0910         err = rawv6_send_hdrinc(sk, msg, len, &fl6, &dst,
0911                     msg->msg_flags, &ipc6.sockc);
0912     else {
0913         ipc6.opt = opt;
0914         lock_sock(sk);
0915         err = ip6_append_data(sk, raw6_getfrag, &rfv,
0916             len, 0, &ipc6, &fl6, (struct rt6_info *)dst,
0917             msg->msg_flags);
0918 
0919         if (err)
0920             ip6_flush_pending_frames(sk);
0921         else if (!(msg->msg_flags & MSG_MORE))
0922             err = rawv6_push_pending_frames(sk, &fl6, rp);
0923         release_sock(sk);
0924     }
0925 done:
0926     dst_release(dst);
0927 out:
0928     fl6_sock_release(flowlabel);
0929     txopt_put(opt_to_free);
0930     return err < 0 ? err : len;
0931 do_confirm:
0932     if (msg->msg_flags & MSG_PROBE)
0933         dst_confirm_neigh(dst, &fl6.daddr);
0934     if (!(msg->msg_flags & MSG_PROBE) || len)
0935         goto back_from_confirm;
0936     err = 0;
0937     goto done;
0938 }
0939 
0940 static int rawv6_seticmpfilter(struct sock *sk, int level, int optname,
0941                    sockptr_t optval, int optlen)
0942 {
0943     switch (optname) {
0944     case ICMPV6_FILTER:
0945         if (optlen > sizeof(struct icmp6_filter))
0946             optlen = sizeof(struct icmp6_filter);
0947         if (copy_from_sockptr(&raw6_sk(sk)->filter, optval, optlen))
0948             return -EFAULT;
0949         return 0;
0950     default:
0951         return -ENOPROTOOPT;
0952     }
0953 
0954     return 0;
0955 }
0956 
0957 static int rawv6_geticmpfilter(struct sock *sk, int level, int optname,
0958                    char __user *optval, int __user *optlen)
0959 {
0960     int len;
0961 
0962     switch (optname) {
0963     case ICMPV6_FILTER:
0964         if (get_user(len, optlen))
0965             return -EFAULT;
0966         if (len < 0)
0967             return -EINVAL;
0968         if (len > sizeof(struct icmp6_filter))
0969             len = sizeof(struct icmp6_filter);
0970         if (put_user(len, optlen))
0971             return -EFAULT;
0972         if (copy_to_user(optval, &raw6_sk(sk)->filter, len))
0973             return -EFAULT;
0974         return 0;
0975     default:
0976         return -ENOPROTOOPT;
0977     }
0978 
0979     return 0;
0980 }
0981 
0982 
0983 static int do_rawv6_setsockopt(struct sock *sk, int level, int optname,
0984                    sockptr_t optval, unsigned int optlen)
0985 {
0986     struct raw6_sock *rp = raw6_sk(sk);
0987     int val;
0988 
0989     if (optlen < sizeof(val))
0990         return -EINVAL;
0991 
0992     if (copy_from_sockptr(&val, optval, sizeof(val)))
0993         return -EFAULT;
0994 
0995     switch (optname) {
0996     case IPV6_HDRINCL:
0997         if (sk->sk_type != SOCK_RAW)
0998             return -EINVAL;
0999         inet_sk(sk)->hdrincl = !!val;
1000         return 0;
1001     case IPV6_CHECKSUM:
1002         if (inet_sk(sk)->inet_num == IPPROTO_ICMPV6 &&
1003             level == IPPROTO_IPV6) {
1004             /*
1005              * RFC3542 tells that IPV6_CHECKSUM socket
1006              * option in the IPPROTO_IPV6 level is not
1007              * allowed on ICMPv6 sockets.
1008              * If you want to set it, use IPPROTO_RAW
1009              * level IPV6_CHECKSUM socket option
1010              * (Linux extension).
1011              */
1012             return -EINVAL;
1013         }
1014 
1015         /* You may get strange result with a positive odd offset;
1016            RFC2292bis agrees with me. */
1017         if (val > 0 && (val&1))
1018             return -EINVAL;
1019         if (val < 0) {
1020             rp->checksum = 0;
1021         } else {
1022             rp->checksum = 1;
1023             rp->offset = val;
1024         }
1025 
1026         return 0;
1027 
1028     default:
1029         return -ENOPROTOOPT;
1030     }
1031 }
1032 
1033 static int rawv6_setsockopt(struct sock *sk, int level, int optname,
1034                 sockptr_t optval, unsigned int optlen)
1035 {
1036     switch (level) {
1037     case SOL_RAW:
1038         break;
1039 
1040     case SOL_ICMPV6:
1041         if (inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1042             return -EOPNOTSUPP;
1043         return rawv6_seticmpfilter(sk, level, optname, optval, optlen);
1044     case SOL_IPV6:
1045         if (optname == IPV6_CHECKSUM ||
1046             optname == IPV6_HDRINCL)
1047             break;
1048         fallthrough;
1049     default:
1050         return ipv6_setsockopt(sk, level, optname, optval, optlen);
1051     }
1052 
1053     return do_rawv6_setsockopt(sk, level, optname, optval, optlen);
1054 }
1055 
1056 static int do_rawv6_getsockopt(struct sock *sk, int level, int optname,
1057                 char __user *optval, int __user *optlen)
1058 {
1059     struct raw6_sock *rp = raw6_sk(sk);
1060     int val, len;
1061 
1062     if (get_user(len, optlen))
1063         return -EFAULT;
1064 
1065     switch (optname) {
1066     case IPV6_HDRINCL:
1067         val = inet_sk(sk)->hdrincl;
1068         break;
1069     case IPV6_CHECKSUM:
1070         /*
1071          * We allow getsockopt() for IPPROTO_IPV6-level
1072          * IPV6_CHECKSUM socket option on ICMPv6 sockets
1073          * since RFC3542 is silent about it.
1074          */
1075         if (rp->checksum == 0)
1076             val = -1;
1077         else
1078             val = rp->offset;
1079         break;
1080 
1081     default:
1082         return -ENOPROTOOPT;
1083     }
1084 
1085     len = min_t(unsigned int, sizeof(int), len);
1086 
1087     if (put_user(len, optlen))
1088         return -EFAULT;
1089     if (copy_to_user(optval, &val, len))
1090         return -EFAULT;
1091     return 0;
1092 }
1093 
1094 static int rawv6_getsockopt(struct sock *sk, int level, int optname,
1095               char __user *optval, int __user *optlen)
1096 {
1097     switch (level) {
1098     case SOL_RAW:
1099         break;
1100 
1101     case SOL_ICMPV6:
1102         if (inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1103             return -EOPNOTSUPP;
1104         return rawv6_geticmpfilter(sk, level, optname, optval, optlen);
1105     case SOL_IPV6:
1106         if (optname == IPV6_CHECKSUM ||
1107             optname == IPV6_HDRINCL)
1108             break;
1109         fallthrough;
1110     default:
1111         return ipv6_getsockopt(sk, level, optname, optval, optlen);
1112     }
1113 
1114     return do_rawv6_getsockopt(sk, level, optname, optval, optlen);
1115 }
1116 
1117 static int rawv6_ioctl(struct sock *sk, int cmd, unsigned long arg)
1118 {
1119     switch (cmd) {
1120     case SIOCOUTQ: {
1121         int amount = sk_wmem_alloc_get(sk);
1122 
1123         return put_user(amount, (int __user *)arg);
1124     }
1125     case SIOCINQ: {
1126         struct sk_buff *skb;
1127         int amount = 0;
1128 
1129         spin_lock_bh(&sk->sk_receive_queue.lock);
1130         skb = skb_peek(&sk->sk_receive_queue);
1131         if (skb)
1132             amount = skb->len;
1133         spin_unlock_bh(&sk->sk_receive_queue.lock);
1134         return put_user(amount, (int __user *)arg);
1135     }
1136 
1137     default:
1138 #ifdef CONFIG_IPV6_MROUTE
1139         return ip6mr_ioctl(sk, cmd, (void __user *)arg);
1140 #else
1141         return -ENOIOCTLCMD;
1142 #endif
1143     }
1144 }
1145 
1146 #ifdef CONFIG_COMPAT
1147 static int compat_rawv6_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
1148 {
1149     switch (cmd) {
1150     case SIOCOUTQ:
1151     case SIOCINQ:
1152         return -ENOIOCTLCMD;
1153     default:
1154 #ifdef CONFIG_IPV6_MROUTE
1155         return ip6mr_compat_ioctl(sk, cmd, compat_ptr(arg));
1156 #else
1157         return -ENOIOCTLCMD;
1158 #endif
1159     }
1160 }
1161 #endif
1162 
1163 static void rawv6_close(struct sock *sk, long timeout)
1164 {
1165     if (inet_sk(sk)->inet_num == IPPROTO_RAW)
1166         ip6_ra_control(sk, -1);
1167     ip6mr_sk_done(sk);
1168     sk_common_release(sk);
1169 }
1170 
1171 static void raw6_destroy(struct sock *sk)
1172 {
1173     lock_sock(sk);
1174     ip6_flush_pending_frames(sk);
1175     release_sock(sk);
1176 
1177     inet6_destroy_sock(sk);
1178 }
1179 
1180 static int rawv6_init_sk(struct sock *sk)
1181 {
1182     struct raw6_sock *rp = raw6_sk(sk);
1183 
1184     switch (inet_sk(sk)->inet_num) {
1185     case IPPROTO_ICMPV6:
1186         rp->checksum = 1;
1187         rp->offset   = 2;
1188         break;
1189     case IPPROTO_MH:
1190         rp->checksum = 1;
1191         rp->offset   = 4;
1192         break;
1193     default:
1194         break;
1195     }
1196     return 0;
1197 }
1198 
1199 struct proto rawv6_prot = {
1200     .name          = "RAWv6",
1201     .owner         = THIS_MODULE,
1202     .close         = rawv6_close,
1203     .destroy       = raw6_destroy,
1204     .connect       = ip6_datagram_connect_v6_only,
1205     .disconnect    = __udp_disconnect,
1206     .ioctl         = rawv6_ioctl,
1207     .init          = rawv6_init_sk,
1208     .setsockopt    = rawv6_setsockopt,
1209     .getsockopt    = rawv6_getsockopt,
1210     .sendmsg       = rawv6_sendmsg,
1211     .recvmsg       = rawv6_recvmsg,
1212     .bind          = rawv6_bind,
1213     .backlog_rcv       = rawv6_rcv_skb,
1214     .hash          = raw_hash_sk,
1215     .unhash        = raw_unhash_sk,
1216     .obj_size      = sizeof(struct raw6_sock),
1217     .useroffset    = offsetof(struct raw6_sock, filter),
1218     .usersize      = sizeof_field(struct raw6_sock, filter),
1219     .h.raw_hash    = &raw_v6_hashinfo,
1220 #ifdef CONFIG_COMPAT
1221     .compat_ioctl      = compat_rawv6_ioctl,
1222 #endif
1223     .diag_destroy      = raw_abort,
1224 };
1225 
1226 #ifdef CONFIG_PROC_FS
1227 static int raw6_seq_show(struct seq_file *seq, void *v)
1228 {
1229     if (v == SEQ_START_TOKEN) {
1230         seq_puts(seq, IPV6_SEQ_DGRAM_HEADER);
1231     } else {
1232         struct sock *sp = v;
1233         __u16 srcp  = inet_sk(sp)->inet_num;
1234         ip6_dgram_sock_seq_show(seq, v, srcp, 0,
1235                     raw_seq_private(seq)->bucket);
1236     }
1237     return 0;
1238 }
1239 
1240 static const struct seq_operations raw6_seq_ops = {
1241     .start =    raw_seq_start,
1242     .next =     raw_seq_next,
1243     .stop =     raw_seq_stop,
1244     .show =     raw6_seq_show,
1245 };
1246 
1247 static int __net_init raw6_init_net(struct net *net)
1248 {
1249     if (!proc_create_net_data("raw6", 0444, net->proc_net, &raw6_seq_ops,
1250             sizeof(struct raw_iter_state), &raw_v6_hashinfo))
1251         return -ENOMEM;
1252 
1253     return 0;
1254 }
1255 
1256 static void __net_exit raw6_exit_net(struct net *net)
1257 {
1258     remove_proc_entry("raw6", net->proc_net);
1259 }
1260 
1261 static struct pernet_operations raw6_net_ops = {
1262     .init = raw6_init_net,
1263     .exit = raw6_exit_net,
1264 };
1265 
1266 int __init raw6_proc_init(void)
1267 {
1268     return register_pernet_subsys(&raw6_net_ops);
1269 }
1270 
1271 void raw6_proc_exit(void)
1272 {
1273     unregister_pernet_subsys(&raw6_net_ops);
1274 }
1275 #endif  /* CONFIG_PROC_FS */
1276 
1277 /* Same as inet6_dgram_ops, sans udp_poll.  */
1278 const struct proto_ops inet6_sockraw_ops = {
1279     .family        = PF_INET6,
1280     .owner         = THIS_MODULE,
1281     .release       = inet6_release,
1282     .bind          = inet6_bind,
1283     .connect       = inet_dgram_connect,    /* ok       */
1284     .socketpair    = sock_no_socketpair,    /* a do nothing */
1285     .accept        = sock_no_accept,        /* a do nothing */
1286     .getname       = inet6_getname,
1287     .poll          = datagram_poll,     /* ok       */
1288     .ioctl         = inet6_ioctl,       /* must change  */
1289     .gettstamp     = sock_gettstamp,
1290     .listen        = sock_no_listen,        /* ok       */
1291     .shutdown      = inet_shutdown,     /* ok       */
1292     .setsockopt    = sock_common_setsockopt,    /* ok       */
1293     .getsockopt    = sock_common_getsockopt,    /* ok       */
1294     .sendmsg       = inet_sendmsg,      /* ok       */
1295     .recvmsg       = sock_common_recvmsg,   /* ok       */
1296     .mmap          = sock_no_mmap,
1297     .sendpage      = sock_no_sendpage,
1298 #ifdef CONFIG_COMPAT
1299     .compat_ioctl      = inet6_compat_ioctl,
1300 #endif
1301 };
1302 
1303 static struct inet_protosw rawv6_protosw = {
1304     .type       = SOCK_RAW,
1305     .protocol   = IPPROTO_IP,   /* wild card */
1306     .prot       = &rawv6_prot,
1307     .ops        = &inet6_sockraw_ops,
1308     .flags      = INET_PROTOSW_REUSE,
1309 };
1310 
1311 int __init rawv6_init(void)
1312 {
1313     return inet6_register_protosw(&rawv6_protosw);
1314 }
1315 
1316 void rawv6_exit(void)
1317 {
1318     inet6_unregister_protosw(&rawv6_protosw);
1319 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!