?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mfd: wm8350-i2c: Make sure the i2c regmap functions are compiled
[linux/fpc-iii.git] / net / ipv4 / ping.c
blob716dff49d0b9eb8f64d267aa024d4f431e71fd8b
1 /*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * "Ping" sockets
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 *
13 * Based on ipv4/udp.c code.
14 *
15 * Authors: Vasiliy Kulikov / Openwall (for Linux 2.6),
16 * Pavel Kankovsky (for Linux 2.4.32)
17 *
18 * Pavel gave all rights to bugs to Vasiliy,
19 * none of the bugs are Pavel's now.
20 *
21 */
22
23 #include <linux/uaccess.h>
24 #include <linux/types.h>
25 #include <linux/fcntl.h>
26 #include <linux/socket.h>
27 #include <linux/sockios.h>
28 #include <linux/in.h>
29 #include <linux/errno.h>
30 #include <linux/timer.h>
31 #include <linux/mm.h>
32 #include <linux/inet.h>
33 #include <linux/netdevice.h>
34 #include <net/snmp.h>
35 #include <net/ip.h>
36 #include <net/icmp.h>
37 #include <net/protocol.h>
38 #include <linux/skbuff.h>
39 #include <linux/proc_fs.h>
40 #include <linux/export.h>
41 #include <net/sock.h>
42 #include <net/ping.h>
43 #include <net/udp.h>
44 #include <net/route.h>
45 #include <net/inet_common.h>
46 #include <net/checksum.h>
47
48 #if IS_ENABLED(CONFIG_IPV6)
49 #include <linux/in6.h>
50 #include <linux/icmpv6.h>
51 #include <net/addrconf.h>
52 #include <net/ipv6.h>
53 #include <net/transp_v6.h>
54 #endif
55
56
57 struct ping_table ping_table;
58 struct pingv6_ops pingv6_ops;
59 EXPORT_SYMBOL_GPL(pingv6_ops);
60
61 static u16 ping_port_rover;
62
63 static inline int ping_hashfn(struct net *net, unsigned int num, unsigned int mask)
64 {
65 int res = (num + net_hash_mix(net)) & mask;
66
67 pr_debug("hash(%d) = %d\n", num, res);
68 return res;
69 }
70 EXPORT_SYMBOL_GPL(ping_hash);
71
72 static inline struct hlist_nulls_head *ping_hashslot(struct ping_table *table,
73 struct net *net, unsigned int num)
74 {
75 return &table->hash[ping_hashfn(net, num, PING_HTABLE_MASK)];
76 }
77
78 int ping_get_port(struct sock *sk, unsigned short ident)
79 {
80 struct hlist_nulls_node *node;
81 struct hlist_nulls_head *hlist;
82 struct inet_sock *isk, *isk2;
83 struct sock *sk2 = NULL;
84
85 isk = inet_sk(sk);
86 write_lock_bh(&ping_table.lock);
87 if (ident == 0) {
88 u32 i;
89 u16 result = ping_port_rover + 1;
90
91 for (i = 0; i < (1L << 16); i++, result++) {
92 if (!result)
93 result++; /* avoid zero */
94 hlist = ping_hashslot(&ping_table, sock_net(sk),
95 result);
96 ping_portaddr_for_each_entry(sk2, node, hlist) {
97 isk2 = inet_sk(sk2);
98
99 if (isk2->inet_num == result)
100 goto next_port;
101 }
102
103 /* found */
104 ping_port_rover = ident = result;
105 break;
106 next_port:
107 ;
108 }
109 if (i >= (1L << 16))
110 goto fail;
111 } else {
112 hlist = ping_hashslot(&ping_table, sock_net(sk), ident);
113 ping_portaddr_for_each_entry(sk2, node, hlist) {
114 isk2 = inet_sk(sk2);
115
116 /* BUG? Why is this reuse and not reuseaddr? ping.c
117 * doesn't turn off SO_REUSEADDR, and it doesn't expect
118 * that other ping processes can steal its packets.
119 */
120 if ((isk2->inet_num == ident) &&
121 (sk2 != sk) &&
122 (!sk2->sk_reuse || !sk->sk_reuse))
123 goto fail;
124 }
125 }
126
127 pr_debug("found port/ident = %d\n", ident);
128 isk->inet_num = ident;
129 if (sk_unhashed(sk)) {
130 pr_debug("was not hashed\n");
131 sock_hold(sk);
132 hlist_nulls_add_head(&sk->sk_nulls_node, hlist);
133 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
134 }
135 write_unlock_bh(&ping_table.lock);
136 return 0;
137
138 fail:
139 write_unlock_bh(&ping_table.lock);
140 return 1;
141 }
142 EXPORT_SYMBOL_GPL(ping_get_port);
143
144 void ping_hash(struct sock *sk)
145 {
146 pr_debug("ping_hash(sk->port=%u)\n", inet_sk(sk)->inet_num);
147 BUG(); /* "Please do not press this button again." */
148 }
149
150 void ping_unhash(struct sock *sk)
151 {
152 struct inet_sock *isk = inet_sk(sk);
153 pr_debug("ping_unhash(isk=%p,isk->num=%u)\n", isk, isk->inet_num);
154 if (sk_hashed(sk)) {
155 write_lock_bh(&ping_table.lock);
156 hlist_nulls_del(&sk->sk_nulls_node);
157 sk_nulls_node_init(&sk->sk_nulls_node);
158 sock_put(sk);
159 isk->inet_num = 0;
160 isk->inet_sport = 0;
161 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
162 write_unlock_bh(&ping_table.lock);
163 }
164 }
165 EXPORT_SYMBOL_GPL(ping_unhash);
166
167 static struct sock *ping_lookup(struct net *net, struct sk_buff *skb, u16 ident)
168 {
169 struct hlist_nulls_head *hslot = ping_hashslot(&ping_table, net, ident);
170 struct sock *sk = NULL;
171 struct inet_sock *isk;
172 struct hlist_nulls_node *hnode;
173 int dif = skb->dev->ifindex;
174
175 if (skb->protocol == htons(ETH_P_IP)) {
176 pr_debug("try to find: num = %d, daddr = %pI4, dif = %d\n",
177 (int)ident, &ip_hdr(skb)->daddr, dif);
178 #if IS_ENABLED(CONFIG_IPV6)
179 } else if (skb->protocol == htons(ETH_P_IPV6)) {
180 pr_debug("try to find: num = %d, daddr = %pI6c, dif = %d\n",
181 (int)ident, &ipv6_hdr(skb)->daddr, dif);
182 #endif
183 }
184
185 read_lock_bh(&ping_table.lock);
186
187 ping_portaddr_for_each_entry(sk, hnode, hslot) {
188 isk = inet_sk(sk);
189
190 pr_debug("iterate\n");
191 if (isk->inet_num != ident)
192 continue;
193
194 if (skb->protocol == htons(ETH_P_IP) &&
195 sk->sk_family == AF_INET) {
196 pr_debug("found: %p: num=%d, daddr=%pI4, dif=%d\n", sk,
197 (int) isk->inet_num, &isk->inet_rcv_saddr,
198 sk->sk_bound_dev_if);
199
200 if (isk->inet_rcv_saddr &&
201 isk->inet_rcv_saddr != ip_hdr(skb)->daddr)
202 continue;
203 #if IS_ENABLED(CONFIG_IPV6)
204 } else if (skb->protocol == htons(ETH_P_IPV6) &&
205 sk->sk_family == AF_INET6) {
206 struct ipv6_pinfo *np = inet6_sk(sk);
207
208 pr_debug("found: %p: num=%d, daddr=%pI6c, dif=%d\n", sk,
209 (int) isk->inet_num,
210 &inet6_sk(sk)->rcv_saddr,
211 sk->sk_bound_dev_if);
212
213 if (!ipv6_addr_any(&np->rcv_saddr) &&
214 !ipv6_addr_equal(&np->rcv_saddr,
215 &ipv6_hdr(skb)->daddr))
216 continue;
217 #endif
218 } else {
219 continue;
220 }
221
222 if (sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif)
223 continue;
224
225 sock_hold(sk);
226 goto exit;
227 }
228
229 sk = NULL;
230 exit:
231 read_unlock_bh(&ping_table.lock);
232
233 return sk;
234 }
235
236 static void inet_get_ping_group_range_net(struct net *net, kgid_t *low,
237 kgid_t *high)
238 {
239 kgid_t *data = net->ipv4.sysctl_ping_group_range;
240 unsigned int seq;
241
242 do {
243 seq = read_seqbegin(&sysctl_local_ports.lock);
244
245 *low = data[0];
246 *high = data[1];
247 } while (read_seqretry(&sysctl_local_ports.lock, seq));
248 }
249
250
251 int ping_init_sock(struct sock *sk)
252 {
253 struct net *net = sock_net(sk);
254 kgid_t group = current_egid();
255 struct group_info *group_info;
256 int i, j, count;
257 kgid_t low, high;
258 int ret = 0;
259
260 #if IS_ENABLED(CONFIG_IPV6)
261 if (sk->sk_family == AF_INET6)
262 inet6_sk(sk)->ipv6only = 1;
263 #endif
264 inet_get_ping_group_range_net(net, &low, &high);
265 if (gid_lte(low, group) && gid_lte(group, high))
266 return 0;
267
268 group_info = get_current_groups();
269 count = group_info->ngroups;
270 for (i = 0; i < group_info->nblocks; i++) {
271 int cp_count = min_t(int, NGROUPS_PER_BLOCK, count);
272 for (j = 0; j < cp_count; j++) {
273 kgid_t gid = group_info->blocks[i][j];
274 if (gid_lte(low, gid) && gid_lte(gid, high))
275 goto out_release_group;
276 }
277
278 count -= cp_count;
279 }
280
281 ret = -EACCES;
282
283 out_release_group:
284 put_group_info(group_info);
285 return ret;
286 }
287 EXPORT_SYMBOL_GPL(ping_init_sock);
288
289 void ping_close(struct sock *sk, long timeout)
290 {
291 pr_debug("ping_close(sk=%p,sk->num=%u)\n",
292 inet_sk(sk), inet_sk(sk)->inet_num);
293 pr_debug("isk->refcnt = %d\n", sk->sk_refcnt.counter);
294
295 sk_common_release(sk);
296 }
297 EXPORT_SYMBOL_GPL(ping_close);
298
299 /* Checks the bind address and possibly modifies sk->sk_bound_dev_if. */
300 static int ping_check_bind_addr(struct sock *sk, struct inet_sock *isk,
301 struct sockaddr *uaddr, int addr_len) {
302 struct net *net = sock_net(sk);
303 if (sk->sk_family == AF_INET) {
304 struct sockaddr_in *addr = (struct sockaddr_in *) uaddr;
305 int chk_addr_ret;
306
307 if (addr_len < sizeof(*addr))
308 return -EINVAL;
309
310 if (addr->sin_family != AF_INET &&
311 !(addr->sin_family == AF_UNSPEC &&
312 addr->sin_addr.s_addr == htonl(INADDR_ANY)))
313 return -EAFNOSUPPORT;
314
315 pr_debug("ping_check_bind_addr(sk=%p,addr=%pI4,port=%d)\n",
316 sk, &addr->sin_addr.s_addr, ntohs(addr->sin_port));
317
318 chk_addr_ret = inet_addr_type(net, addr->sin_addr.s_addr);
319
320 if (addr->sin_addr.s_addr == htonl(INADDR_ANY))
321 chk_addr_ret = RTN_LOCAL;
322
323 if ((sysctl_ip_nonlocal_bind == 0 &&
324 isk->freebind == 0 && isk->transparent == 0 &&
325 chk_addr_ret != RTN_LOCAL) ||
326 chk_addr_ret == RTN_MULTICAST ||
327 chk_addr_ret == RTN_BROADCAST)
328 return -EADDRNOTAVAIL;
329
330 #if IS_ENABLED(CONFIG_IPV6)
331 } else if (sk->sk_family == AF_INET6) {
332 struct sockaddr_in6 *addr = (struct sockaddr_in6 *) uaddr;
333 int addr_type, scoped, has_addr;
334 struct net_device *dev = NULL;
335
336 if (addr_len < sizeof(*addr))
337 return -EINVAL;
338
339 if (addr->sin6_family != AF_INET6)
340 return -EAFNOSUPPORT;
341
342 pr_debug("ping_check_bind_addr(sk=%p,addr=%pI6c,port=%d)\n",
343 sk, addr->sin6_addr.s6_addr, ntohs(addr->sin6_port));
344
345 addr_type = ipv6_addr_type(&addr->sin6_addr);
346 scoped = __ipv6_addr_needs_scope_id(addr_type);
347 if ((addr_type != IPV6_ADDR_ANY &&
348 !(addr_type & IPV6_ADDR_UNICAST)) ||
349 (scoped && !addr->sin6_scope_id))
350 return -EINVAL;
351
352 rcu_read_lock();
353 if (addr->sin6_scope_id) {
354 dev = dev_get_by_index_rcu(net, addr->sin6_scope_id);
355 if (!dev) {
356 rcu_read_unlock();
357 return -ENODEV;
358 }
359 }
360 has_addr = pingv6_ops.ipv6_chk_addr(net, &addr->sin6_addr, dev,
361 scoped);
362 rcu_read_unlock();
363
364 if (!(isk->freebind || isk->transparent || has_addr ||
365 addr_type == IPV6_ADDR_ANY))
366 return -EADDRNOTAVAIL;
367
368 if (scoped)
369 sk->sk_bound_dev_if = addr->sin6_scope_id;
370 #endif
371 } else {
372 return -EAFNOSUPPORT;
373 }
374 return 0;
375 }
376
377 static void ping_set_saddr(struct sock *sk, struct sockaddr *saddr)
378 {
379 if (saddr->sa_family == AF_INET) {
380 struct inet_sock *isk = inet_sk(sk);
381 struct sockaddr_in *addr = (struct sockaddr_in *) saddr;
382 isk->inet_rcv_saddr = isk->inet_saddr = addr->sin_addr.s_addr;
383 #if IS_ENABLED(CONFIG_IPV6)
384 } else if (saddr->sa_family == AF_INET6) {
385 struct sockaddr_in6 *addr = (struct sockaddr_in6 *) saddr;
386 struct ipv6_pinfo *np = inet6_sk(sk);
387 np->rcv_saddr = np->saddr = addr->sin6_addr;
388 #endif
389 }
390 }
391
392 static void ping_clear_saddr(struct sock *sk, int dif)
393 {
394 sk->sk_bound_dev_if = dif;
395 if (sk->sk_family == AF_INET) {
396 struct inet_sock *isk = inet_sk(sk);
397 isk->inet_rcv_saddr = isk->inet_saddr = 0;
398 #if IS_ENABLED(CONFIG_IPV6)
399 } else if (sk->sk_family == AF_INET6) {
400 struct ipv6_pinfo *np = inet6_sk(sk);
401 memset(&np->rcv_saddr, 0, sizeof(np->rcv_saddr));
402 memset(&np->saddr, 0, sizeof(np->saddr));
403 #endif
404 }
405 }
406 /*
407 * We need our own bind because there are no privileged id's == local ports.
408 * Moreover, we don't allow binding to multi- and broadcast addresses.
409 */
410
411 int ping_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
412 {
413 struct inet_sock *isk = inet_sk(sk);
414 unsigned short snum;
415 int err;
416 int dif = sk->sk_bound_dev_if;
417
418 err = ping_check_bind_addr(sk, isk, uaddr, addr_len);
419 if (err)
420 return err;
421
422 lock_sock(sk);
423
424 err = -EINVAL;
425 if (isk->inet_num != 0)
426 goto out;
427
428 err = -EADDRINUSE;
429 ping_set_saddr(sk, uaddr);
430 snum = ntohs(((struct sockaddr_in *)uaddr)->sin_port);
431 if (ping_get_port(sk, snum) != 0) {
432 ping_clear_saddr(sk, dif);
433 goto out;
434 }
435
436 pr_debug("after bind(): num = %d, dif = %d\n",
437 (int)isk->inet_num,
438 (int)sk->sk_bound_dev_if);
439
440 err = 0;
441 if ((sk->sk_family == AF_INET && isk->inet_rcv_saddr) ||
442 (sk->sk_family == AF_INET6 &&
443 !ipv6_addr_any(&inet6_sk(sk)->rcv_saddr)))
444 sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
445
446 if (snum)
447 sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
448 isk->inet_sport = htons(isk->inet_num);
449 isk->inet_daddr = 0;
450 isk->inet_dport = 0;
451
452 #if IS_ENABLED(CONFIG_IPV6)
453 if (sk->sk_family == AF_INET6)
454 memset(&inet6_sk(sk)->daddr, 0, sizeof(inet6_sk(sk)->daddr));
455 #endif
456
457 sk_dst_reset(sk);
458 out:
459 release_sock(sk);
460 pr_debug("ping_v4_bind -> %d\n", err);
461 return err;
462 }
463 EXPORT_SYMBOL_GPL(ping_bind);
464
465 /*
466 * Is this a supported type of ICMP message?
467 */
468
469 static inline int ping_supported(int family, int type, int code)
470 {
471 return (family == AF_INET && type == ICMP_ECHO && code == 0) ||
472 (family == AF_INET6 && type == ICMPV6_ECHO_REQUEST && code == 0);
473 }
474
475 /*
476 * This routine is called by the ICMP module when it gets some
477 * sort of error condition.
478 */
479
480 void ping_err(struct sk_buff *skb, int offset, u32 info)
481 {
482 int family;
483 struct icmphdr *icmph;
484 struct inet_sock *inet_sock;
485 int type;
486 int code;
487 struct net *net = dev_net(skb->dev);
488 struct sock *sk;
489 int harderr;
490 int err;
491
492 if (skb->protocol == htons(ETH_P_IP)) {
493 family = AF_INET;
494 type = icmp_hdr(skb)->type;
495 code = icmp_hdr(skb)->code;
496 icmph = (struct icmphdr *)(skb->data + offset);
497 } else if (skb->protocol == htons(ETH_P_IPV6)) {
498 family = AF_INET6;
499 type = icmp6_hdr(skb)->icmp6_type;
500 code = icmp6_hdr(skb)->icmp6_code;
501 icmph = (struct icmphdr *) (skb->data + offset);
502 } else {
503 BUG();
504 }
505
506 /* We assume the packet has already been checked by icmp_unreach */
507
508 if (!ping_supported(family, icmph->type, icmph->code))
509 return;
510
511 pr_debug("ping_err(proto=0x%x,type=%d,code=%d,id=%04x,seq=%04x)\n",
512 skb->protocol, type, code, ntohs(icmph->un.echo.id),
513 ntohs(icmph->un.echo.sequence));
514
515 sk = ping_lookup(net, skb, ntohs(icmph->un.echo.id));
516 if (sk == NULL) {
517 pr_debug("no socket, dropping\n");
518 return; /* No socket for error */
519 }
520 pr_debug("err on socket %p\n", sk);
521
522 err = 0;
523 harderr = 0;
524 inet_sock = inet_sk(sk);
525
526 if (skb->protocol == htons(ETH_P_IP)) {
527 switch (type) {
528 default:
529 case ICMP_TIME_EXCEEDED:
530 err = EHOSTUNREACH;
531 break;
532 case ICMP_SOURCE_QUENCH:
533 /* This is not a real error but ping wants to see it.
534 * Report it with some fake errno.
535 */
536 err = EREMOTEIO;
537 break;
538 case ICMP_PARAMETERPROB:
539 err = EPROTO;
540 harderr = 1;
541 break;
542 case ICMP_DEST_UNREACH:
543 if (code == ICMP_FRAG_NEEDED) { /* Path MTU discovery */
544 ipv4_sk_update_pmtu(skb, sk, info);
545 if (inet_sock->pmtudisc != IP_PMTUDISC_DONT) {
546 err = EMSGSIZE;
547 harderr = 1;
548 break;
549 }
550 goto out;
551 }
552 err = EHOSTUNREACH;
553 if (code <= NR_ICMP_UNREACH) {
554 harderr = icmp_err_convert[code].fatal;
555 err = icmp_err_convert[code].errno;
556 }
557 break;
558 case ICMP_REDIRECT:
559 /* See ICMP_SOURCE_QUENCH */
560 ipv4_sk_redirect(skb, sk);
561 err = EREMOTEIO;
562 break;
563 }
564 #if IS_ENABLED(CONFIG_IPV6)
565 } else if (skb->protocol == htons(ETH_P_IPV6)) {
566 harderr = pingv6_ops.icmpv6_err_convert(type, code, &err);
567 #endif
568 }
569
570 /*
571 * RFC1122: OK. Passes ICMP errors back to application, as per
572 * 4.1.3.3.
573 */
574 if ((family == AF_INET && !inet_sock->recverr) ||
575 (family == AF_INET6 && !inet6_sk(sk)->recverr)) {
576 if (!harderr || sk->sk_state != TCP_ESTABLISHED)
577 goto out;
578 } else {
579 if (family == AF_INET) {
580 ip_icmp_error(sk, skb, err, 0 /* no remote port */,
581 info, (u8 *)icmph);
582 #if IS_ENABLED(CONFIG_IPV6)
583 } else if (family == AF_INET6) {
584 pingv6_ops.ipv6_icmp_error(sk, skb, err, 0,
585 info, (u8 *)icmph);
586 #endif
587 }
588 }
589 sk->sk_err = err;
590 sk->sk_error_report(sk);
591 out:
592 sock_put(sk);
593 }
594 EXPORT_SYMBOL_GPL(ping_err);
595
596 /*
597 * Copy and checksum an ICMP Echo packet from user space into a buffer
598 * starting from the payload.
599 */
600
601 int ping_getfrag(void *from, char *to,
602 int offset, int fraglen, int odd, struct sk_buff *skb)
603 {
604 struct pingfakehdr *pfh = (struct pingfakehdr *)from;
605
606 if (offset == 0) {
607 if (fraglen < sizeof(struct icmphdr))
608 BUG();
609 if (csum_partial_copy_fromiovecend(to + sizeof(struct icmphdr),
610 pfh->iov, 0, fraglen - sizeof(struct icmphdr),
611 &pfh->wcheck))
612 return -EFAULT;
613 } else if (offset < sizeof(struct icmphdr)) {
614 BUG();
615 } else {
616 if (csum_partial_copy_fromiovecend
617 (to, pfh->iov, offset - sizeof(struct icmphdr),
618 fraglen, &pfh->wcheck))
619 return -EFAULT;
620 }
621
622 #if IS_ENABLED(CONFIG_IPV6)
623 /* For IPv6, checksum each skb as we go along, as expected by
624 * icmpv6_push_pending_frames. For IPv4, accumulate the checksum in
625 * wcheck, it will be finalized in ping_v4_push_pending_frames.
626 */
627 if (pfh->family == AF_INET6) {
628 skb->csum = pfh->wcheck;
629 skb->ip_summed = CHECKSUM_NONE;
630 pfh->wcheck = 0;
631 }
632 #endif
633
634 return 0;
635 }
636 EXPORT_SYMBOL_GPL(ping_getfrag);
637
638 static int ping_v4_push_pending_frames(struct sock *sk, struct pingfakehdr *pfh,
639 struct flowi4 *fl4)
640 {
641 struct sk_buff *skb = skb_peek(&sk->sk_write_queue);
642
643 pfh->wcheck = csum_partial((char *)&pfh->icmph,
644 sizeof(struct icmphdr), pfh->wcheck);
645 pfh->icmph.checksum = csum_fold(pfh->wcheck);
646 memcpy(icmp_hdr(skb), &pfh->icmph, sizeof(struct icmphdr));
647 skb->ip_summed = CHECKSUM_NONE;
648 return ip_push_pending_frames(sk, fl4);
649 }
650
651 int ping_common_sendmsg(int family, struct msghdr *msg, size_t len,
652 void *user_icmph, size_t icmph_len) {
653 u8 type, code;
654
655 if (len > 0xFFFF)
656 return -EMSGSIZE;
657
658 /*
659 * Check the flags.
660 */
661
662 /* Mirror BSD error message compatibility */
663 if (msg->msg_flags & MSG_OOB)
664 return -EOPNOTSUPP;
665
666 /*
667 * Fetch the ICMP header provided by the userland.
668 * iovec is modified! The ICMP header is consumed.
669 */
670 if (memcpy_fromiovec(user_icmph, msg->msg_iov, icmph_len))
671 return -EFAULT;
672
673 if (family == AF_INET) {
674 type = ((struct icmphdr *) user_icmph)->type;
675 code = ((struct icmphdr *) user_icmph)->code;
676 #if IS_ENABLED(CONFIG_IPV6)
677 } else if (family == AF_INET6) {
678 type = ((struct icmp6hdr *) user_icmph)->icmp6_type;
679 code = ((struct icmp6hdr *) user_icmph)->icmp6_code;
680 #endif
681 } else {
682 BUG();
683 }
684
685 if (!ping_supported(family, type, code))
686 return -EINVAL;
687
688 return 0;
689 }
690 EXPORT_SYMBOL_GPL(ping_common_sendmsg);
691
692 int ping_v4_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
693 size_t len)
694 {
695 struct net *net = sock_net(sk);
696 struct flowi4 fl4;
697 struct inet_sock *inet = inet_sk(sk);
698 struct ipcm_cookie ipc;
699 struct icmphdr user_icmph;
700 struct pingfakehdr pfh;
701 struct rtable *rt = NULL;
702 struct ip_options_data opt_copy;
703 int free = 0;
704 __be32 saddr, daddr, faddr;
705 u8 tos;
706 int err;
707
708 pr_debug("ping_v4_sendmsg(sk=%p,sk->num=%u)\n", inet, inet->inet_num);
709
710 err = ping_common_sendmsg(AF_INET, msg, len, &user_icmph,
711 sizeof(user_icmph));
712 if (err)
713 return err;
714
715 /*
716 * Get and verify the address.
717 */
718
719 if (msg->msg_name) {
720 struct sockaddr_in *usin = (struct sockaddr_in *)msg->msg_name;
721 if (msg->msg_namelen < sizeof(*usin))
722 return -EINVAL;
723 if (usin->sin_family != AF_INET)
724 return -EAFNOSUPPORT;
725 daddr = usin->sin_addr.s_addr;
726 /* no remote port */
727 } else {
728 if (sk->sk_state != TCP_ESTABLISHED)
729 return -EDESTADDRREQ;
730 daddr = inet->inet_daddr;
731 /* no remote port */
732 }
733
734 ipc.addr = inet->inet_saddr;
735 ipc.opt = NULL;
736 ipc.oif = sk->sk_bound_dev_if;
737 ipc.tx_flags = 0;
738
739 sock_tx_timestamp(sk, &ipc.tx_flags);
740
741 if (msg->msg_controllen) {
742 err = ip_cmsg_send(sock_net(sk), msg, &ipc);
743 if (unlikely(err)) {
744 kfree(ipc.opt);
745 return err;
746 }
747 if (ipc.opt)
748 free = 1;
749 }
750 if (!ipc.opt) {
751 struct ip_options_rcu *inet_opt;
752
753 rcu_read_lock();
754 inet_opt = rcu_dereference(inet->inet_opt);
755 if (inet_opt) {
756 memcpy(&opt_copy, inet_opt,
757 sizeof(*inet_opt) + inet_opt->opt.optlen);
758 ipc.opt = &opt_copy.opt;
759 }
760 rcu_read_unlock();
761 }
762
763 saddr = ipc.addr;
764 ipc.addr = faddr = daddr;
765
766 if (ipc.opt && ipc.opt->opt.srr) {
767 if (!daddr)
768 return -EINVAL;
769 faddr = ipc.opt->opt.faddr;
770 }
771 tos = RT_TOS(inet->tos);
772 if (sock_flag(sk, SOCK_LOCALROUTE) ||
773 (msg->msg_flags & MSG_DONTROUTE) ||
774 (ipc.opt && ipc.opt->opt.is_strictroute)) {
775 tos |= RTO_ONLINK;
776 }
777
778 if (ipv4_is_multicast(daddr)) {
779 if (!ipc.oif)
780 ipc.oif = inet->mc_index;
781 if (!saddr)
782 saddr = inet->mc_addr;
783 } else if (!ipc.oif)
784 ipc.oif = inet->uc_index;
785
786 flowi4_init_output(&fl4, ipc.oif, sk->sk_mark, tos,
787 RT_SCOPE_UNIVERSE, sk->sk_protocol,
788 inet_sk_flowi_flags(sk), faddr, saddr, 0, 0);
789
790 security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
791 rt = ip_route_output_flow(net, &fl4, sk);
792 if (IS_ERR(rt)) {
793 err = PTR_ERR(rt);
794 rt = NULL;
795 if (err == -ENETUNREACH)
796 IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
797 goto out;
798 }
799
800 err = -EACCES;
801 if ((rt->rt_flags & RTCF_BROADCAST) &&
802 !sock_flag(sk, SOCK_BROADCAST))
803 goto out;
804
805 if (msg->msg_flags & MSG_CONFIRM)
806 goto do_confirm;
807 back_from_confirm:
808
809 if (!ipc.addr)
810 ipc.addr = fl4.daddr;
811
812 lock_sock(sk);
813
814 pfh.icmph.type = user_icmph.type; /* already checked */
815 pfh.icmph.code = user_icmph.code; /* ditto */
816 pfh.icmph.checksum = 0;
817 pfh.icmph.un.echo.id = inet->inet_sport;
818 pfh.icmph.un.echo.sequence = user_icmph.un.echo.sequence;
819 pfh.iov = msg->msg_iov;
820 pfh.wcheck = 0;
821 pfh.family = AF_INET;
822
823 err = ip_append_data(sk, &fl4, ping_getfrag, &pfh, len,
824 0, &ipc, &rt, msg->msg_flags);
825 if (err)
826 ip_flush_pending_frames(sk);
827 else
828 err = ping_v4_push_pending_frames(sk, &pfh, &fl4);
829 release_sock(sk);
830
831 out:
832 ip_rt_put(rt);
833 if (free)
834 kfree(ipc.opt);
835 if (!err) {
836 icmp_out_count(sock_net(sk), user_icmph.type);
837 return len;
838 }
839 return err;
840
841 do_confirm:
842 dst_confirm(&rt->dst);
843 if (!(msg->msg_flags & MSG_PROBE) || len)
844 goto back_from_confirm;
845 err = 0;
846 goto out;
847 }
848
849 int ping_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
850 size_t len, int noblock, int flags, int *addr_len)
851 {
852 struct inet_sock *isk = inet_sk(sk);
853 int family = sk->sk_family;
854 struct sk_buff *skb;
855 int copied, err;
856
857 pr_debug("ping_recvmsg(sk=%p,sk->num=%u)\n", isk, isk->inet_num);
858
859 err = -EOPNOTSUPP;
860 if (flags & MSG_OOB)
861 goto out;
862
863 if (flags & MSG_ERRQUEUE) {
864 if (family == AF_INET) {
865 return ip_recv_error(sk, msg, len, addr_len);
866 #if IS_ENABLED(CONFIG_IPV6)
867 } else if (family == AF_INET6) {
868 return pingv6_ops.ipv6_recv_error(sk, msg, len,
869 addr_len);
870 #endif
871 }
872 }
873
874 skb = skb_recv_datagram(sk, flags, noblock, &err);
875 if (!skb)
876 goto out;
877
878 copied = skb->len;
879 if (copied > len) {
880 msg->msg_flags |= MSG_TRUNC;
881 copied = len;
882 }
883
884 /* Don't bother checking the checksum */
885 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
886 if (err)
887 goto done;
888
889 sock_recv_timestamp(msg, sk, skb);
890
891 /* Copy the address and add cmsg data. */
892 if (family == AF_INET) {
893 struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
894
895 if (sin) {
896 sin->sin_family = AF_INET;
897 sin->sin_port = 0 /* skb->h.uh->source */;
898 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
899 memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
900 *addr_len = sizeof(*sin);
901 }
902
903 if (isk->cmsg_flags)
904 ip_cmsg_recv(msg, skb);
905
906 #if IS_ENABLED(CONFIG_IPV6)
907 } else if (family == AF_INET6) {
908 struct ipv6_pinfo *np = inet6_sk(sk);
909 struct ipv6hdr *ip6 = ipv6_hdr(skb);
910 struct sockaddr_in6 *sin6 =
911 (struct sockaddr_in6 *)msg->msg_name;
912
913 if (sin6) {
914 sin6->sin6_family = AF_INET6;
915 sin6->sin6_port = 0;
916 sin6->sin6_addr = ip6->saddr;
917 sin6->sin6_flowinfo = 0;
918 if (np->sndflow)
919 sin6->sin6_flowinfo = ip6_flowinfo(ip6);
920 sin6->sin6_scope_id =
921 ipv6_iface_scope_id(&sin6->sin6_addr,
922 IP6CB(skb)->iif);
923 *addr_len = sizeof(*sin6);
924 }
925
926 if (inet6_sk(sk)->rxopt.all)
927 pingv6_ops.ip6_datagram_recv_ctl(sk, msg, skb);
928 #endif
929 } else {
930 BUG();
931 }
932
933 err = copied;
934
935 done:
936 skb_free_datagram(sk, skb);
937 out:
938 pr_debug("ping_recvmsg -> %d\n", err);
939 return err;
940 }
941 EXPORT_SYMBOL_GPL(ping_recvmsg);
942
943 int ping_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
944 {
945 pr_debug("ping_queue_rcv_skb(sk=%p,sk->num=%d,skb=%p)\n",
946 inet_sk(sk), inet_sk(sk)->inet_num, skb);
947 if (sock_queue_rcv_skb(sk, skb) < 0) {
948 kfree_skb(skb);
949 pr_debug("ping_queue_rcv_skb -> failed\n");
950 return -1;
951 }
952 return 0;
953 }
954 EXPORT_SYMBOL_GPL(ping_queue_rcv_skb);
955
956
957 /*
958 * All we need to do is get the socket.
959 */
960
961 void ping_rcv(struct sk_buff *skb)
962 {
963 struct sock *sk;
964 struct net *net = dev_net(skb->dev);
965 struct icmphdr *icmph = icmp_hdr(skb);
966
967 /* We assume the packet has already been checked by icmp_rcv */
968
969 pr_debug("ping_rcv(skb=%p,id=%04x,seq=%04x)\n",
970 skb, ntohs(icmph->un.echo.id), ntohs(icmph->un.echo.sequence));
971
972 /* Push ICMP header back */
973 skb_push(skb, skb->data - (u8 *)icmph);
974
975 sk = ping_lookup(net, skb, ntohs(icmph->un.echo.id));
976 if (sk != NULL) {
977 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
978
979 pr_debug("rcv on socket %p\n", sk);
980 if (skb2)
981 ping_queue_rcv_skb(sk, skb2);
982 sock_put(sk);
983 return;
984 }
985 pr_debug("no socket, dropping\n");
986
987 /* We're called from icmp_rcv(). kfree_skb() is done there. */
988 }
989 EXPORT_SYMBOL_GPL(ping_rcv);
990
991 struct proto ping_prot = {
992 .name = "PING",
993 .owner = THIS_MODULE,
994 .init = ping_init_sock,
995 .close = ping_close,
996 .connect = ip4_datagram_connect,
997 .disconnect = udp_disconnect,
998 .setsockopt = ip_setsockopt,
999 .getsockopt = ip_getsockopt,
1000 .sendmsg = ping_v4_sendmsg,
1001 .recvmsg = ping_recvmsg,
1002 .bind = ping_bind,
1003 .backlog_rcv = ping_queue_rcv_skb,
1004 .release_cb = ip4_datagram_release_cb,
1005 .hash = ping_hash,
1006 .unhash = ping_unhash,
1007 .get_port = ping_get_port,
1008 .obj_size = sizeof(struct inet_sock),
1009 };
1010 EXPORT_SYMBOL(ping_prot);
1011
1012 #ifdef CONFIG_PROC_FS
1013
1014 static struct sock *ping_get_first(struct seq_file *seq, int start)
1015 {
1016 struct sock *sk;
1017 struct ping_iter_state *state = seq->private;
1018 struct net *net = seq_file_net(seq);
1019
1020 for (state->bucket = start; state->bucket < PING_HTABLE_SIZE;
1021 ++state->bucket) {
1022 struct hlist_nulls_node *node;
1023 struct hlist_nulls_head *hslot;
1024
1025 hslot = &ping_table.hash[state->bucket];
1026
1027 if (hlist_nulls_empty(hslot))
1028 continue;
1029
1030 sk_nulls_for_each(sk, node, hslot) {
1031 if (net_eq(sock_net(sk), net) &&
1032 sk->sk_family == state->family)
1033 goto found;
1034 }
1035 }
1036 sk = NULL;
1037 found:
1038 return sk;
1039 }
1040
1041 static struct sock *ping_get_next(struct seq_file *seq, struct sock *sk)
1042 {
1043 struct ping_iter_state *state = seq->private;
1044 struct net *net = seq_file_net(seq);
1045
1046 do {
1047 sk = sk_nulls_next(sk);
1048 } while (sk && (!net_eq(sock_net(sk), net)));
1049
1050 if (!sk)
1051 return ping_get_first(seq, state->bucket + 1);
1052 return sk;
1053 }
1054
1055 static struct sock *ping_get_idx(struct seq_file *seq, loff_t pos)
1056 {
1057 struct sock *sk = ping_get_first(seq, 0);
1058
1059 if (sk)
1060 while (pos && (sk = ping_get_next(seq, sk)) != NULL)
1061 --pos;
1062 return pos ? NULL : sk;
1063 }
1064
1065 void *ping_seq_start(struct seq_file *seq, loff_t *pos, sa_family_t family)
1066 {
1067 struct ping_iter_state *state = seq->private;
1068 state->bucket = 0;
1069 state->family = family;
1070
1071 read_lock_bh(&ping_table.lock);
1072
1073 return *pos ? ping_get_idx(seq, *pos-1) : SEQ_START_TOKEN;
1074 }
1075 EXPORT_SYMBOL_GPL(ping_seq_start);
1076
1077 static void *ping_v4_seq_start(struct seq_file *seq, loff_t *pos)
1078 {
1079 return ping_seq_start(seq, pos, AF_INET);
1080 }
1081
1082 void *ping_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1083 {
1084 struct sock *sk;
1085
1086 if (v == SEQ_START_TOKEN)
1087 sk = ping_get_idx(seq, 0);
1088 else
1089 sk = ping_get_next(seq, v);
1090
1091 ++*pos;
1092 return sk;
1093 }
1094 EXPORT_SYMBOL_GPL(ping_seq_next);
1095
1096 void ping_seq_stop(struct seq_file *seq, void *v)
1097 {
1098 read_unlock_bh(&ping_table.lock);
1099 }
1100 EXPORT_SYMBOL_GPL(ping_seq_stop);
1101
1102 static void ping_v4_format_sock(struct sock *sp, struct seq_file *f,
1103 int bucket, int *len)
1104 {
1105 struct inet_sock *inet = inet_sk(sp);
1106 __be32 dest = inet->inet_daddr;
1107 __be32 src = inet->inet_rcv_saddr;
1108 __u16 destp = ntohs(inet->inet_dport);
1109 __u16 srcp = ntohs(inet->inet_sport);
1110
1111 seq_printf(f, "%5d: %08X:%04X %08X:%04X"
1112 " %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %d%n",
1113 bucket, src, srcp, dest, destp, sp->sk_state,
1114 sk_wmem_alloc_get(sp),
1115 sk_rmem_alloc_get(sp),
1116 0, 0L, 0,
1117 from_kuid_munged(seq_user_ns(f), sock_i_uid(sp)),
1118 0, sock_i_ino(sp),
1119 atomic_read(&sp->sk_refcnt), sp,
1120 atomic_read(&sp->sk_drops), len);
1121 }
1122
1123 static int ping_v4_seq_show(struct seq_file *seq, void *v)
1124 {
1125 if (v == SEQ_START_TOKEN)
1126 seq_printf(seq, "%-127s\n",
1127 " sl local_address rem_address st tx_queue "
1128 "rx_queue tr tm->when retrnsmt uid timeout "
1129 "inode ref pointer drops");
1130 else {
1131 struct ping_iter_state *state = seq->private;
1132 int len;
1133
1134 ping_v4_format_sock(v, seq, state->bucket, &len);
1135 seq_printf(seq, "%*s\n", 127 - len, "");
1136 }
1137 return 0;
1138 }
1139
1140 static const struct seq_operations ping_v4_seq_ops = {
1141 .show = ping_v4_seq_show,
1142 .start = ping_v4_seq_start,
1143 .next = ping_seq_next,
1144 .stop = ping_seq_stop,
1145 };
1146
1147 static int ping_seq_open(struct inode *inode, struct file *file)
1148 {
1149 struct ping_seq_afinfo *afinfo = PDE_DATA(inode);
1150 return seq_open_net(inode, file, &afinfo->seq_ops,
1151 sizeof(struct ping_iter_state));
1152 }
1153
1154 const struct file_operations ping_seq_fops = {
1155 .open = ping_seq_open,
1156 .read = seq_read,
1157 .llseek = seq_lseek,
1158 .release = seq_release_net,
1159 };
1160 EXPORT_SYMBOL_GPL(ping_seq_fops);
1161
1162 static struct ping_seq_afinfo ping_v4_seq_afinfo = {
1163 .name = "icmp",
1164 .family = AF_INET,
1165 .seq_fops = &ping_seq_fops,
1166 .seq_ops = {
1167 .start = ping_v4_seq_start,
1168 .show = ping_v4_seq_show,
1169 .next = ping_seq_next,
1170 .stop = ping_seq_stop,
1171 },
1172 };
1173
1174 int ping_proc_register(struct net *net, struct ping_seq_afinfo *afinfo)
1175 {
1176 struct proc_dir_entry *p;
1177 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
1178 afinfo->seq_fops, afinfo);
1179 if (!p)
1180 return -ENOMEM;
1181 return 0;
1182 }
1183 EXPORT_SYMBOL_GPL(ping_proc_register);
1184
1185 void ping_proc_unregister(struct net *net, struct ping_seq_afinfo *afinfo)
1186 {
1187 remove_proc_entry(afinfo->name, net->proc_net);
1188 }
1189 EXPORT_SYMBOL_GPL(ping_proc_unregister);
1190
1191 static int __net_init ping_v4_proc_init_net(struct net *net)
1192 {
1193 return ping_proc_register(net, &ping_v4_seq_afinfo);
1194 }
1195
1196 static void __net_exit ping_v4_proc_exit_net(struct net *net)
1197 {
1198 ping_proc_unregister(net, &ping_v4_seq_afinfo);
1199 }
1200
1201 static struct pernet_operations ping_v4_net_ops = {
1202 .init = ping_v4_proc_init_net,
1203 .exit = ping_v4_proc_exit_net,
1204 };
1205
1206 int __init ping_proc_init(void)
1207 {
1208 return register_pernet_subsys(&ping_v4_net_ops);
1209 }
1210
1211 void ping_proc_exit(void)
1212 {
1213 unregister_pernet_subsys(&ping_v4_net_ops);
1214 }
1215
1216 #endif
1217
1218 void __init ping_init(void)
1219 {
1220 int i;
1221
1222 for (i = 0; i < PING_HTABLE_SIZE; i++)
1223 INIT_HLIST_NULLS_HEAD(&ping_table.hash[i], i);
1224 rwlock_init(&ping_table.lock);
1225 }
Linux with added FPC-III support