ping.c 29 KB

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