~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv6/icmp.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *      Internet Control Message Protocol (ICMPv6)
  3  *      Linux INET6 implementation
  4  *
  5  *      Authors:
  6  *      Pedro Roque             <roque@di.fc.ul.pt>
  7  *
  8  *      Based on net/ipv4/icmp.c
  9  *
 10  *      RFC 1885
 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 /*
 19  *      Changes:
 20  *
 21  *      Andi Kleen              :       exception handling
 22  *      Andi Kleen                      add rate limits. never reply to a icmp.
 23  *                                      add more length checks and other fixes.
 24  *      yoshfuji                :       ensure to sent parameter problem for
 25  *                                      fragments.
 26  *      YOSHIFUJI Hideaki @USAGI:       added sysctl for icmp rate limit.
 27  *      Randy Dunlap and
 28  *      YOSHIFUJI Hideaki @USAGI:       Per-interface statistics support
 29  *      Kazunori MIYAZAWA @USAGI:       change output process to use ip6_append_data
 30  */
 31 
 32 #define pr_fmt(fmt) "IPv6: " fmt
 33 
 34 #include <linux/module.h>
 35 #include <linux/errno.h>
 36 #include <linux/types.h>
 37 #include <linux/socket.h>
 38 #include <linux/in.h>
 39 #include <linux/kernel.h>
 40 #include <linux/sockios.h>
 41 #include <linux/net.h>
 42 #include <linux/skbuff.h>
 43 #include <linux/init.h>
 44 #include <linux/netfilter.h>
 45 #include <linux/slab.h>
 46 
 47 #ifdef CONFIG_SYSCTL
 48 #include <linux/sysctl.h>
 49 #endif
 50 
 51 #include <linux/inet.h>
 52 #include <linux/netdevice.h>
 53 #include <linux/icmpv6.h>
 54 
 55 #include <net/ip.h>
 56 #include <net/sock.h>
 57 
 58 #include <net/ipv6.h>
 59 #include <net/ip6_checksum.h>
 60 #include <net/ping.h>
 61 #include <net/protocol.h>
 62 #include <net/raw.h>
 63 #include <net/rawv6.h>
 64 #include <net/transp_v6.h>
 65 #include <net/ip6_route.h>
 66 #include <net/addrconf.h>
 67 #include <net/icmp.h>
 68 #include <net/xfrm.h>
 69 #include <net/inet_common.h>
 70 #include <net/dsfield.h>
 71 #include <net/l3mdev.h>
 72 
 73 #include <asm/uaccess.h>
 74 
 75 /*
 76  *      The ICMP socket(s). This is the most convenient way to flow control
 77  *      our ICMP output as well as maintain a clean interface throughout
 78  *      all layers. All Socketless IP sends will soon be gone.
 79  *
 80  *      On SMP we have one ICMP socket per-cpu.
 81  */
 82 static inline struct sock *icmpv6_sk(struct net *net)
 83 {
 84         return net->ipv6.icmp_sk[smp_processor_id()];
 85 }
 86 
 87 static void icmpv6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
 88                        u8 type, u8 code, int offset, __be32 info)
 89 {
 90         /* icmpv6_notify checks 8 bytes can be pulled, icmp6hdr is 8 bytes */
 91         struct icmp6hdr *icmp6 = (struct icmp6hdr *) (skb->data + offset);
 92         struct net *net = dev_net(skb->dev);
 93 
 94         if (type == ICMPV6_PKT_TOOBIG)
 95                 ip6_update_pmtu(skb, net, info, 0, 0);
 96         else if (type == NDISC_REDIRECT)
 97                 ip6_redirect(skb, net, skb->dev->ifindex, 0);
 98 
 99         if (!(type & ICMPV6_INFOMSG_MASK))
100                 if (icmp6->icmp6_type == ICMPV6_ECHO_REQUEST)
101                         ping_err(skb, offset, ntohl(info));
102 }
103 
104 static int icmpv6_rcv(struct sk_buff *skb);
105 
106 static const struct inet6_protocol icmpv6_protocol = {
107         .handler        =       icmpv6_rcv,
108         .err_handler    =       icmpv6_err,
109         .flags          =       INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
110 };
111 
112 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
113 {
114         struct sock *sk;
115 
116         local_bh_disable();
117 
118         sk = icmpv6_sk(net);
119         if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
120                 /* This can happen if the output path (f.e. SIT or
121                  * ip6ip6 tunnel) signals dst_link_failure() for an
122                  * outgoing ICMP6 packet.
123                  */
124                 local_bh_enable();
125                 return NULL;
126         }
127         return sk;
128 }
129 
130 static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
131 {
132         spin_unlock_bh(&sk->sk_lock.slock);
133 }
134 
135 /*
136  * Figure out, may we reply to this packet with icmp error.
137  *
138  * We do not reply, if:
139  *      - it was icmp error message.
140  *      - it is truncated, so that it is known, that protocol is ICMPV6
141  *        (i.e. in the middle of some exthdr)
142  *
143  *      --ANK (980726)
144  */
145 
146 static bool is_ineligible(const struct sk_buff *skb)
147 {
148         int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
149         int len = skb->len - ptr;
150         __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
151         __be16 frag_off;
152 
153         if (len < 0)
154                 return true;
155 
156         ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
157         if (ptr < 0)
158                 return false;
159         if (nexthdr == IPPROTO_ICMPV6) {
160                 u8 _type, *tp;
161                 tp = skb_header_pointer(skb,
162                         ptr+offsetof(struct icmp6hdr, icmp6_type),
163                         sizeof(_type), &_type);
164                 if (!tp || !(*tp & ICMPV6_INFOMSG_MASK))
165                         return true;
166         }
167         return false;
168 }
169 
170 /*
171  * Check the ICMP output rate limit
172  */
173 static bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
174                                struct flowi6 *fl6)
175 {
176         struct net *net = sock_net(sk);
177         struct dst_entry *dst;
178         bool res = false;
179 
180         /* Informational messages are not limited. */
181         if (type & ICMPV6_INFOMSG_MASK)
182                 return true;
183 
184         /* Do not limit pmtu discovery, it would break it. */
185         if (type == ICMPV6_PKT_TOOBIG)
186                 return true;
187 
188         /*
189          * Look up the output route.
190          * XXX: perhaps the expire for routing entries cloned by
191          * this lookup should be more aggressive (not longer than timeout).
192          */
193         dst = ip6_route_output(net, sk, fl6);
194         if (dst->error) {
195                 IP6_INC_STATS(net, ip6_dst_idev(dst),
196                               IPSTATS_MIB_OUTNOROUTES);
197         } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
198                 res = true;
199         } else {
200                 struct rt6_info *rt = (struct rt6_info *)dst;
201                 int tmo = net->ipv6.sysctl.icmpv6_time;
202 
203                 /* Give more bandwidth to wider prefixes. */
204                 if (rt->rt6i_dst.plen < 128)
205                         tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
206 
207                 if (icmp_global_allow()) {
208                         struct inet_peer *peer;
209 
210                         peer = inet_getpeer_v6(net->ipv6.peers,
211                                                &fl6->daddr, 1);
212                         res = inet_peer_xrlim_allow(peer, tmo);
213                         if (peer)
214                                 inet_putpeer(peer);
215                 }
216         }
217         dst_release(dst);
218         return res;
219 }
220 
221 /*
222  *      an inline helper for the "simple" if statement below
223  *      checks if parameter problem report is caused by an
224  *      unrecognized IPv6 option that has the Option Type
225  *      highest-order two bits set to 10
226  */
227 
228 static bool opt_unrec(struct sk_buff *skb, __u32 offset)
229 {
230         u8 _optval, *op;
231 
232         offset += skb_network_offset(skb);
233         op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
234         if (!op)
235                 return true;
236         return (*op & 0xC0) == 0x80;
237 }
238 
239 int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
240                                struct icmp6hdr *thdr, int len)
241 {
242         struct sk_buff *skb;
243         struct icmp6hdr *icmp6h;
244         int err = 0;
245 
246         skb = skb_peek(&sk->sk_write_queue);
247         if (!skb)
248                 goto out;
249 
250         icmp6h = icmp6_hdr(skb);
251         memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
252         icmp6h->icmp6_cksum = 0;
253 
254         if (skb_queue_len(&sk->sk_write_queue) == 1) {
255                 skb->csum = csum_partial(icmp6h,
256                                         sizeof(struct icmp6hdr), skb->csum);
257                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
258                                                       &fl6->daddr,
259                                                       len, fl6->flowi6_proto,
260                                                       skb->csum);
261         } else {
262                 __wsum tmp_csum = 0;
263 
264                 skb_queue_walk(&sk->sk_write_queue, skb) {
265                         tmp_csum = csum_add(tmp_csum, skb->csum);
266                 }
267 
268                 tmp_csum = csum_partial(icmp6h,
269                                         sizeof(struct icmp6hdr), tmp_csum);
270                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
271                                                       &fl6->daddr,
272                                                       len, fl6->flowi6_proto,
273                                                       tmp_csum);
274         }
275         ip6_push_pending_frames(sk);
276 out:
277         return err;
278 }
279 
280 struct icmpv6_msg {
281         struct sk_buff  *skb;
282         int             offset;
283         uint8_t         type;
284 };
285 
286 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
287 {
288         struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
289         struct sk_buff *org_skb = msg->skb;
290         __wsum csum = 0;
291 
292         csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
293                                       to, len, csum);
294         skb->csum = csum_block_add(skb->csum, csum, odd);
295         if (!(msg->type & ICMPV6_INFOMSG_MASK))
296                 nf_ct_attach(skb, org_skb);
297         return 0;
298 }
299 
300 #if IS_ENABLED(CONFIG_IPV6_MIP6)
301 static void mip6_addr_swap(struct sk_buff *skb)
302 {
303         struct ipv6hdr *iph = ipv6_hdr(skb);
304         struct inet6_skb_parm *opt = IP6CB(skb);
305         struct ipv6_destopt_hao *hao;
306         struct in6_addr tmp;
307         int off;
308 
309         if (opt->dsthao) {
310                 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
311                 if (likely(off >= 0)) {
312                         hao = (struct ipv6_destopt_hao *)
313                                         (skb_network_header(skb) + off);
314                         tmp = iph->saddr;
315                         iph->saddr = hao->addr;
316                         hao->addr = tmp;
317                 }
318         }
319 }
320 #else
321 static inline void mip6_addr_swap(struct sk_buff *skb) {}
322 #endif
323 
324 static struct dst_entry *icmpv6_route_lookup(struct net *net,
325                                              struct sk_buff *skb,
326                                              struct sock *sk,
327                                              struct flowi6 *fl6)
328 {
329         struct dst_entry *dst, *dst2;
330         struct flowi6 fl2;
331         int err;
332 
333         err = ip6_dst_lookup(net, sk, &dst, fl6);
334         if (err)
335                 return ERR_PTR(err);
336 
337         /*
338          * We won't send icmp if the destination is known
339          * anycast.
340          */
341         if (ipv6_anycast_destination(dst, &fl6->daddr)) {
342                 net_dbg_ratelimited("icmp6_send: acast source\n");
343                 dst_release(dst);
344                 return ERR_PTR(-EINVAL);
345         }
346 
347         /* No need to clone since we're just using its address. */
348         dst2 = dst;
349 
350         dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
351         if (!IS_ERR(dst)) {
352                 if (dst != dst2)
353                         return dst;
354         } else {
355                 if (PTR_ERR(dst) == -EPERM)
356                         dst = NULL;
357                 else
358                         return dst;
359         }
360 
361         err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
362         if (err)
363                 goto relookup_failed;
364 
365         err = ip6_dst_lookup(net, sk, &dst2, &fl2);
366         if (err)
367                 goto relookup_failed;
368 
369         dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
370         if (!IS_ERR(dst2)) {
371                 dst_release(dst);
372                 dst = dst2;
373         } else {
374                 err = PTR_ERR(dst2);
375                 if (err == -EPERM) {
376                         dst_release(dst);
377                         return dst2;
378                 } else
379                         goto relookup_failed;
380         }
381 
382 relookup_failed:
383         if (dst)
384                 return dst;
385         return ERR_PTR(err);
386 }
387 
388 /*
389  *      Send an ICMP message in response to a packet in error
390  */
391 static void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
392 {
393         struct net *net = dev_net(skb->dev);
394         struct inet6_dev *idev = NULL;
395         struct ipv6hdr *hdr = ipv6_hdr(skb);
396         struct sock *sk;
397         struct ipv6_pinfo *np;
398         const struct in6_addr *saddr = NULL;
399         struct dst_entry *dst;
400         struct icmp6hdr tmp_hdr;
401         struct flowi6 fl6;
402         struct icmpv6_msg msg;
403         struct sockcm_cookie sockc_unused = {0};
404         struct ipcm6_cookie ipc6;
405         int iif = 0;
406         int addr_type = 0;
407         int len;
408         int err = 0;
409         u32 mark = IP6_REPLY_MARK(net, skb->mark);
410 
411         if ((u8 *)hdr < skb->head ||
412             (skb_network_header(skb) + sizeof(*hdr)) > skb_tail_pointer(skb))
413                 return;
414 
415         /*
416          *      Make sure we respect the rules
417          *      i.e. RFC 1885 2.4(e)
418          *      Rule (e.1) is enforced by not using icmp6_send
419          *      in any code that processes icmp errors.
420          */
421         addr_type = ipv6_addr_type(&hdr->daddr);
422 
423         if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0) ||
424             ipv6_chk_acast_addr_src(net, skb->dev, &hdr->daddr))
425                 saddr = &hdr->daddr;
426 
427         /*
428          *      Dest addr check
429          */
430 
431         if (addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST) {
432                 if (type != ICMPV6_PKT_TOOBIG &&
433                     !(type == ICMPV6_PARAMPROB &&
434                       code == ICMPV6_UNK_OPTION &&
435                       (opt_unrec(skb, info))))
436                         return;
437 
438                 saddr = NULL;
439         }
440 
441         addr_type = ipv6_addr_type(&hdr->saddr);
442 
443         /*
444          *      Source addr check
445          */
446 
447         if (__ipv6_addr_needs_scope_id(addr_type))
448                 iif = skb->dev->ifindex;
449         else
450                 iif = l3mdev_master_ifindex(skb->dev);
451 
452         /*
453          *      Must not send error if the source does not uniquely
454          *      identify a single node (RFC2463 Section 2.4).
455          *      We check unspecified / multicast addresses here,
456          *      and anycast addresses will be checked later.
457          */
458         if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
459                 net_dbg_ratelimited("icmp6_send: addr_any/mcast source [%pI6c > %pI6c]\n",
460                                     &hdr->saddr, &hdr->daddr);
461                 return;
462         }
463 
464         /*
465          *      Never answer to a ICMP packet.
466          */
467         if (is_ineligible(skb)) {
468                 net_dbg_ratelimited("icmp6_send: no reply to icmp error [%pI6c > %pI6c]\n",
469                                     &hdr->saddr, &hdr->daddr);
470                 return;
471         }
472 
473         mip6_addr_swap(skb);
474 
475         memset(&fl6, 0, sizeof(fl6));
476         fl6.flowi6_proto = IPPROTO_ICMPV6;
477         fl6.daddr = hdr->saddr;
478         if (saddr)
479                 fl6.saddr = *saddr;
480         fl6.flowi6_mark = mark;
481         fl6.flowi6_oif = iif;
482         fl6.fl6_icmp_type = type;
483         fl6.fl6_icmp_code = code;
484         security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
485 
486         sk = icmpv6_xmit_lock(net);
487         if (!sk)
488                 return;
489         sk->sk_mark = mark;
490         np = inet6_sk(sk);
491 
492         if (!icmpv6_xrlim_allow(sk, type, &fl6))
493                 goto out;
494 
495         tmp_hdr.icmp6_type = type;
496         tmp_hdr.icmp6_code = code;
497         tmp_hdr.icmp6_cksum = 0;
498         tmp_hdr.icmp6_pointer = htonl(info);
499 
500         if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
501                 fl6.flowi6_oif = np->mcast_oif;
502         else if (!fl6.flowi6_oif)
503                 fl6.flowi6_oif = np->ucast_oif;
504 
505         dst = icmpv6_route_lookup(net, skb, sk, &fl6);
506         if (IS_ERR(dst))
507                 goto out;
508 
509         ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
510         ipc6.tclass = np->tclass;
511         ipc6.dontfrag = np->dontfrag;
512         ipc6.opt = NULL;
513 
514         msg.skb = skb;
515         msg.offset = skb_network_offset(skb);
516         msg.type = type;
517 
518         len = skb->len - msg.offset;
519         len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(struct icmp6hdr));
520         if (len < 0) {
521                 net_dbg_ratelimited("icmp: len problem [%pI6c > %pI6c]\n",
522                                     &hdr->saddr, &hdr->daddr);
523                 goto out_dst_release;
524         }
525 
526         rcu_read_lock();
527         idev = __in6_dev_get(skb->dev);
528 
529         err = ip6_append_data(sk, icmpv6_getfrag, &msg,
530                               len + sizeof(struct icmp6hdr),
531                               sizeof(struct icmp6hdr),
532                               &ipc6, &fl6, (struct rt6_info *)dst,
533                               MSG_DONTWAIT, &sockc_unused);
534         if (err) {
535                 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
536                 ip6_flush_pending_frames(sk);
537         } else {
538                 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
539                                                  len + sizeof(struct icmp6hdr));
540         }
541         rcu_read_unlock();
542 out_dst_release:
543         dst_release(dst);
544 out:
545         icmpv6_xmit_unlock(sk);
546 }
547 
548 /* Slightly more convenient version of icmp6_send.
549  */
550 void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
551 {
552         icmp6_send(skb, ICMPV6_PARAMPROB, code, pos);
553         kfree_skb(skb);
554 }
555 
556 static void icmpv6_echo_reply(struct sk_buff *skb)
557 {
558         struct net *net = dev_net(skb->dev);
559         struct sock *sk;
560         struct inet6_dev *idev;
561         struct ipv6_pinfo *np;
562         const struct in6_addr *saddr = NULL;
563         struct icmp6hdr *icmph = icmp6_hdr(skb);
564         struct icmp6hdr tmp_hdr;
565         struct flowi6 fl6;
566         struct icmpv6_msg msg;
567         struct dst_entry *dst;
568         struct ipcm6_cookie ipc6;
569         int err = 0;
570         u32 mark = IP6_REPLY_MARK(net, skb->mark);
571         struct sockcm_cookie sockc_unused = {0};
572 
573         saddr = &ipv6_hdr(skb)->daddr;
574 
575         if (!ipv6_unicast_destination(skb) &&
576             !(net->ipv6.sysctl.anycast_src_echo_reply &&
577               ipv6_anycast_destination(skb_dst(skb), saddr)))
578                 saddr = NULL;
579 
580         memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
581         tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
582 
583         memset(&fl6, 0, sizeof(fl6));
584         fl6.flowi6_proto = IPPROTO_ICMPV6;
585         fl6.daddr = ipv6_hdr(skb)->saddr;
586         if (saddr)
587                 fl6.saddr = *saddr;
588         fl6.flowi6_oif = l3mdev_fib_oif(skb->dev);
589         fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
590         fl6.flowi6_mark = mark;
591         security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
592 
593         sk = icmpv6_xmit_lock(net);
594         if (!sk)
595                 return;
596         sk->sk_mark = mark;
597         np = inet6_sk(sk);
598 
599         if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
600                 fl6.flowi6_oif = np->mcast_oif;
601         else if (!fl6.flowi6_oif)
602                 fl6.flowi6_oif = np->ucast_oif;
603 
604         err = ip6_dst_lookup(net, sk, &dst, &fl6);
605         if (err)
606                 goto out;
607         dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
608         if (IS_ERR(dst))
609                 goto out;
610 
611         idev = __in6_dev_get(skb->dev);
612 
613         msg.skb = skb;
614         msg.offset = 0;
615         msg.type = ICMPV6_ECHO_REPLY;
616 
617         ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
618         ipc6.tclass = ipv6_get_dsfield(ipv6_hdr(skb));
619         ipc6.dontfrag = np->dontfrag;
620         ipc6.opt = NULL;
621 
622         err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
623                                 sizeof(struct icmp6hdr), &ipc6, &fl6,
624                                 (struct rt6_info *)dst, MSG_DONTWAIT,
625                                 &sockc_unused);
626 
627         if (err) {
628                 __ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
629                 ip6_flush_pending_frames(sk);
630         } else {
631                 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
632                                                  skb->len + sizeof(struct icmp6hdr));
633         }
634         dst_release(dst);
635 out:
636         icmpv6_xmit_unlock(sk);
637 }
638 
639 void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
640 {
641         const struct inet6_protocol *ipprot;
642         int inner_offset;
643         __be16 frag_off;
644         u8 nexthdr;
645         struct net *net = dev_net(skb->dev);
646 
647         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
648                 goto out;
649 
650         nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
651         if (ipv6_ext_hdr(nexthdr)) {
652                 /* now skip over extension headers */
653                 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
654                                                 &nexthdr, &frag_off);
655                 if (inner_offset < 0)
656                         goto out;
657         } else {
658                 inner_offset = sizeof(struct ipv6hdr);
659         }
660 
661         /* Checkin header including 8 bytes of inner protocol header. */
662         if (!pskb_may_pull(skb, inner_offset+8))
663                 goto out;
664 
665         /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
666            Without this we will not able f.e. to make source routed
667            pmtu discovery.
668            Corresponding argument (opt) to notifiers is already added.
669            --ANK (980726)
670          */
671 
672         ipprot = rcu_dereference(inet6_protos[nexthdr]);
673         if (ipprot && ipprot->err_handler)
674                 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
675 
676         raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
677         return;
678 
679 out:
680         __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
681 }
682 
683 /*
684  *      Handle icmp messages
685  */
686 
687 static int icmpv6_rcv(struct sk_buff *skb)
688 {
689         struct net_device *dev = skb->dev;
690         struct inet6_dev *idev = __in6_dev_get(dev);
691         const struct in6_addr *saddr, *daddr;
692         struct icmp6hdr *hdr;
693         u8 type;
694         bool success = false;
695 
696         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
697                 struct sec_path *sp = skb_sec_path(skb);
698                 int nh;
699 
700                 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
701                                  XFRM_STATE_ICMP))
702                         goto drop_no_count;
703 
704                 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
705                         goto drop_no_count;
706 
707                 nh = skb_network_offset(skb);
708                 skb_set_network_header(skb, sizeof(*hdr));
709 
710                 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
711                         goto drop_no_count;
712 
713                 skb_set_network_header(skb, nh);
714         }
715 
716         __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INMSGS);
717 
718         saddr = &ipv6_hdr(skb)->saddr;
719         daddr = &ipv6_hdr(skb)->daddr;
720 
721         if (skb_checksum_validate(skb, IPPROTO_ICMPV6, ip6_compute_pseudo)) {
722                 net_dbg_ratelimited("ICMPv6 checksum failed [%pI6c > %pI6c]\n",
723                                     saddr, daddr);
724                 goto csum_error;
725         }
726 
727         if (!pskb_pull(skb, sizeof(*hdr)))
728                 goto discard_it;
729 
730         hdr = icmp6_hdr(skb);
731 
732         type = hdr->icmp6_type;
733 
734         ICMP6MSGIN_INC_STATS(dev_net(dev), idev, type);
735 
736         switch (type) {
737         case ICMPV6_ECHO_REQUEST:
738                 icmpv6_echo_reply(skb);
739                 break;
740 
741         case ICMPV6_ECHO_REPLY:
742                 success = ping_rcv(skb);
743                 break;
744 
745         case ICMPV6_PKT_TOOBIG:
746                 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
747                    standard destination cache. Seems, only "advanced"
748                    destination cache will allow to solve this problem
749                    --ANK (980726)
750                  */
751                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
752                         goto discard_it;
753                 hdr = icmp6_hdr(skb);
754 
755                 /*
756                  *      Drop through to notify
757                  */
758 
759         case ICMPV6_DEST_UNREACH:
760         case ICMPV6_TIME_EXCEED:
761         case ICMPV6_PARAMPROB:
762                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
763                 break;
764 
765         case NDISC_ROUTER_SOLICITATION:
766         case NDISC_ROUTER_ADVERTISEMENT:
767         case NDISC_NEIGHBOUR_SOLICITATION:
768         case NDISC_NEIGHBOUR_ADVERTISEMENT:
769         case NDISC_REDIRECT:
770                 ndisc_rcv(skb);
771                 break;
772 
773         case ICMPV6_MGM_QUERY:
774                 igmp6_event_query(skb);
775                 break;
776 
777         case ICMPV6_MGM_REPORT:
778                 igmp6_event_report(skb);
779                 break;
780 
781         case ICMPV6_MGM_REDUCTION:
782         case ICMPV6_NI_QUERY:
783         case ICMPV6_NI_REPLY:
784         case ICMPV6_MLD2_REPORT:
785         case ICMPV6_DHAAD_REQUEST:
786         case ICMPV6_DHAAD_REPLY:
787         case ICMPV6_MOBILE_PREFIX_SOL:
788         case ICMPV6_MOBILE_PREFIX_ADV:
789                 break;
790 
791         default:
792                 /* informational */
793                 if (type & ICMPV6_INFOMSG_MASK)
794                         break;
795 
796                 net_dbg_ratelimited("icmpv6: msg of unknown type [%pI6c > %pI6c]\n",
797                                     saddr, daddr);
798 
799                 /*
800                  * error of unknown type.
801                  * must pass to upper level
802                  */
803 
804                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
805         }
806 
807         /* until the v6 path can be better sorted assume failure and
808          * preserve the status quo behaviour for the rest of the paths to here
809          */
810         if (success)
811                 consume_skb(skb);
812         else
813                 kfree_skb(skb);
814 
815         return 0;
816 
817 csum_error:
818         __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_CSUMERRORS);
819 discard_it:
820         __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INERRORS);
821 drop_no_count:
822         kfree_skb(skb);
823         return 0;
824 }
825 
826 void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
827                       u8 type,
828                       const struct in6_addr *saddr,
829                       const struct in6_addr *daddr,
830                       int oif)
831 {
832         memset(fl6, 0, sizeof(*fl6));
833         fl6->saddr = *saddr;
834         fl6->daddr = *daddr;
835         fl6->flowi6_proto       = IPPROTO_ICMPV6;
836         fl6->fl6_icmp_type      = type;
837         fl6->fl6_icmp_code      = 0;
838         fl6->flowi6_oif         = oif;
839         security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
840 }
841 
842 static int __net_init icmpv6_sk_init(struct net *net)
843 {
844         struct sock *sk;
845         int err, i, j;
846 
847         net->ipv6.icmp_sk =
848                 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
849         if (!net->ipv6.icmp_sk)
850                 return -ENOMEM;
851 
852         for_each_possible_cpu(i) {
853                 err = inet_ctl_sock_create(&sk, PF_INET6,
854                                            SOCK_RAW, IPPROTO_ICMPV6, net);
855                 if (err < 0) {
856                         pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
857                                err);
858                         goto fail;
859                 }
860 
861                 net->ipv6.icmp_sk[i] = sk;
862 
863                 /* Enough space for 2 64K ICMP packets, including
864                  * sk_buff struct overhead.
865                  */
866                 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
867         }
868         return 0;
869 
870  fail:
871         for (j = 0; j < i; j++)
872                 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
873         kfree(net->ipv6.icmp_sk);
874         return err;
875 }
876 
877 static void __net_exit icmpv6_sk_exit(struct net *net)
878 {
879         int i;
880 
881         for_each_possible_cpu(i) {
882                 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
883         }
884         kfree(net->ipv6.icmp_sk);
885 }
886 
887 static struct pernet_operations icmpv6_sk_ops = {
888         .init = icmpv6_sk_init,
889         .exit = icmpv6_sk_exit,
890 };
891 
892 int __init icmpv6_init(void)
893 {
894         int err;
895 
896         err = register_pernet_subsys(&icmpv6_sk_ops);
897         if (err < 0)
898                 return err;
899 
900         err = -EAGAIN;
901         if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
902                 goto fail;
903 
904         err = inet6_register_icmp_sender(icmp6_send);
905         if (err)
906                 goto sender_reg_err;
907         return 0;
908 
909 sender_reg_err:
910         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
911 fail:
912         pr_err("Failed to register ICMP6 protocol\n");
913         unregister_pernet_subsys(&icmpv6_sk_ops);
914         return err;
915 }
916 
917 void icmpv6_cleanup(void)
918 {
919         inet6_unregister_icmp_sender(icmp6_send);
920         unregister_pernet_subsys(&icmpv6_sk_ops);
921         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
922 }
923 
924 
925 static const struct icmp6_err {
926         int err;
927         int fatal;
928 } tab_unreach[] = {
929         {       /* NOROUTE */
930                 .err    = ENETUNREACH,
931                 .fatal  = 0,
932         },
933         {       /* ADM_PROHIBITED */
934                 .err    = EACCES,
935                 .fatal  = 1,
936         },
937         {       /* Was NOT_NEIGHBOUR, now reserved */
938                 .err    = EHOSTUNREACH,
939                 .fatal  = 0,
940         },
941         {       /* ADDR_UNREACH */
942                 .err    = EHOSTUNREACH,
943                 .fatal  = 0,
944         },
945         {       /* PORT_UNREACH */
946                 .err    = ECONNREFUSED,
947                 .fatal  = 1,
948         },
949         {       /* POLICY_FAIL */
950                 .err    = EACCES,
951                 .fatal  = 1,
952         },
953         {       /* REJECT_ROUTE */
954                 .err    = EACCES,
955                 .fatal  = 1,
956         },
957 };
958 
959 int icmpv6_err_convert(u8 type, u8 code, int *err)
960 {
961         int fatal = 0;
962 
963         *err = EPROTO;
964 
965         switch (type) {
966         case ICMPV6_DEST_UNREACH:
967                 fatal = 1;
968                 if (code < ARRAY_SIZE(tab_unreach)) {
969                         *err  = tab_unreach[code].err;
970                         fatal = tab_unreach[code].fatal;
971                 }
972                 break;
973 
974         case ICMPV6_PKT_TOOBIG:
975                 *err = EMSGSIZE;
976                 break;
977 
978         case ICMPV6_PARAMPROB:
979                 *err = EPROTO;
980                 fatal = 1;
981                 break;
982 
983         case ICMPV6_TIME_EXCEED:
984                 *err = EHOSTUNREACH;
985                 break;
986         }
987 
988         return fatal;
989 }
990 EXPORT_SYMBOL(icmpv6_err_convert);
991 
992 #ifdef CONFIG_SYSCTL
993 static struct ctl_table ipv6_icmp_table_template[] = {
994         {
995                 .procname       = "ratelimit",
996                 .data           = &init_net.ipv6.sysctl.icmpv6_time,
997                 .maxlen         = sizeof(int),
998                 .mode           = 0644,
999                 .proc_handler   = proc_dointvec_ms_jiffies,
1000         },
1001         { },
1002 };
1003 
1004 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
1005 {
1006         struct ctl_table *table;
1007 
1008         table = kmemdup(ipv6_icmp_table_template,
1009                         sizeof(ipv6_icmp_table_template),
1010                         GFP_KERNEL);
1011 
1012         if (table)
1013                 table[0].data = &net->ipv6.sysctl.icmpv6_time;
1014 
1015         return table;
1016 }
1017 #endif
1018 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp