raw.c 29 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294
  1. /*
  2. * RAW sockets for IPv6
  3. * Linux INET6 implementation
  4. *
  5. * Authors:
  6. * Pedro Roque <roque@di.fc.ul.pt>
  7. *
  8. * Adapted from linux/net/ipv4/raw.c
  9. *
  10. * $Id: raw.c,v 1.1.1.1 2007/06/12 07:27:14 eyryu Exp $
  11. *
  12. * Fixes:
  13. * Hideaki YOSHIFUJI : sin6_scope_id support
  14. * YOSHIFUJI,H.@USAGI : raw checksum (RFC2292(bis) compliance)
  15. * Kazunori MIYAZAWA @USAGI: change process style to use ip6_append_data
  16. *
  17. * This program is free software; you can redistribute it and/or
  18. * modify it under the terms of the GNU General Public License
  19. * as published by the Free Software Foundation; either version
  20. * 2 of the License, or (at your option) any later version.
  21. */
  22. #include <linux/errno.h>
  23. #include <linux/types.h>
  24. #include <linux/socket.h>
  25. #include <linux/sockios.h>
  26. #include <linux/net.h>
  27. #include <linux/in6.h>
  28. #include <linux/netdevice.h>
  29. #include <linux/if_arp.h>
  30. #include <linux/icmpv6.h>
  31. #include <linux/netfilter.h>
  32. #include <linux/netfilter_ipv6.h>
  33. #include <linux/skbuff.h>
  34. #include <asm/uaccess.h>
  35. #include <asm/ioctls.h>
  36. #include <net/ip.h>
  37. #include <net/sock.h>
  38. #include <net/snmp.h>
  39. #include <net/ipv6.h>
  40. #include <net/ndisc.h>
  41. #include <net/protocol.h>
  42. #include <net/ip6_route.h>
  43. #include <net/ip6_checksum.h>
  44. #include <net/addrconf.h>
  45. #include <net/transp_v6.h>
  46. #include <net/udp.h>
  47. #include <net/inet_common.h>
  48. #include <net/tcp_states.h>
  49. #ifdef CONFIG_IPV6_MIP6
  50. #include <net/mip6.h>
  51. #endif
  52. #include <net/rawv6.h>
  53. #include <net/xfrm.h>
  54. #include <linux/proc_fs.h>
  55. #include <linux/seq_file.h>
  56. struct hlist_head raw_v6_htable[RAWV6_HTABLE_SIZE];
  57. DEFINE_RWLOCK(raw_v6_lock);
  58. static void raw_v6_hash(struct sock *sk)
  59. {
  60. struct hlist_head *list = &raw_v6_htable[inet_sk(sk)->num &
  61. (RAWV6_HTABLE_SIZE - 1)];
  62. write_lock_bh(&raw_v6_lock);
  63. sk_add_node(sk, list);
  64. sock_prot_inc_use(sk->sk_prot);
  65. write_unlock_bh(&raw_v6_lock);
  66. }
  67. static void raw_v6_unhash(struct sock *sk)
  68. {
  69. write_lock_bh(&raw_v6_lock);
  70. if (sk_del_node_init(sk))
  71. sock_prot_dec_use(sk->sk_prot);
  72. write_unlock_bh(&raw_v6_lock);
  73. }
  74. /* Grumble... icmp and ip_input want to get at this... */
  75. struct sock *__raw_v6_lookup(struct sock *sk, unsigned short num,
  76. struct in6_addr *loc_addr, struct in6_addr *rmt_addr,
  77. int dif)
  78. {
  79. struct hlist_node *node;
  80. int is_multicast = ipv6_addr_is_multicast(loc_addr);
  81. sk_for_each_from(sk, node)
  82. if (inet_sk(sk)->num == num) {
  83. struct ipv6_pinfo *np = inet6_sk(sk);
  84. if (!ipv6_addr_any(&np->daddr) &&
  85. !ipv6_addr_equal(&np->daddr, rmt_addr))
  86. continue;
  87. if (sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif)
  88. continue;
  89. if (!ipv6_addr_any(&np->rcv_saddr)) {
  90. if (ipv6_addr_equal(&np->rcv_saddr, loc_addr))
  91. goto found;
  92. if (is_multicast &&
  93. inet6_mc_check(sk, loc_addr, rmt_addr))
  94. goto found;
  95. continue;
  96. }
  97. goto found;
  98. }
  99. sk = NULL;
  100. found:
  101. return sk;
  102. }
  103. /*
  104. * 0 - deliver
  105. * 1 - block
  106. */
  107. static __inline__ int icmpv6_filter(struct sock *sk, struct sk_buff *skb)
  108. {
  109. struct icmp6hdr *icmph;
  110. struct raw6_sock *rp = raw6_sk(sk);
  111. if (pskb_may_pull(skb, sizeof(struct icmp6hdr))) {
  112. __u32 *data = &rp->filter.data[0];
  113. int bit_nr;
  114. icmph = (struct icmp6hdr *) skb->data;
  115. bit_nr = icmph->icmp6_type;
  116. return (data[bit_nr >> 5] & (1 << (bit_nr & 31))) != 0;
  117. }
  118. return 0;
  119. }
  120. /*
  121. * demultiplex raw sockets.
  122. * (should consider queueing the skb in the sock receive_queue
  123. * without calling rawv6.c)
  124. *
  125. * Caller owns SKB so we must make clones.
  126. */
  127. int ipv6_raw_deliver(struct sk_buff *skb, int nexthdr)
  128. {
  129. struct in6_addr *saddr;
  130. struct in6_addr *daddr;
  131. struct sock *sk;
  132. int delivered = 0;
  133. __u8 hash;
  134. saddr = &skb->nh.ipv6h->saddr;
  135. daddr = saddr + 1;
  136. hash = nexthdr & (MAX_INET_PROTOS - 1);
  137. read_lock(&raw_v6_lock);
  138. sk = sk_head(&raw_v6_htable[hash]);
  139. /*
  140. * The first socket found will be delivered after
  141. * delivery to transport protocols.
  142. */
  143. if (sk == NULL)
  144. goto out;
  145. sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr, IP6CB(skb)->iif);
  146. while (sk) {
  147. int filtered;
  148. delivered = 1;
  149. switch (nexthdr) {
  150. case IPPROTO_ICMPV6:
  151. filtered = icmpv6_filter(sk, skb);
  152. break;
  153. #ifdef CONFIG_IPV6_MIP6
  154. case IPPROTO_MH:
  155. /* XXX: To validate MH only once for each packet,
  156. * this is placed here. It should be after checking
  157. * xfrm policy, however it doesn't. The checking xfrm
  158. * policy is placed in rawv6_rcv() because it is
  159. * required for each socket.
  160. */
  161. filtered = mip6_mh_filter(sk, skb);
  162. break;
  163. #endif
  164. default:
  165. filtered = 0;
  166. break;
  167. }
  168. if (filtered < 0)
  169. break;
  170. if (filtered == 0) {
  171. struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);
  172. /* Not releasing hash table! */
  173. if (clone) {
  174. nf_reset(clone);
  175. rawv6_rcv(sk, clone);
  176. }
  177. }
  178. sk = __raw_v6_lookup(sk_next(sk), nexthdr, daddr, saddr,
  179. IP6CB(skb)->iif);
  180. }
  181. out:
  182. read_unlock(&raw_v6_lock);
  183. return delivered;
  184. }
  185. /* This cleans up af_inet6 a bit. -DaveM */
  186. static int rawv6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
  187. {
  188. struct inet_sock *inet = inet_sk(sk);
  189. struct ipv6_pinfo *np = inet6_sk(sk);
  190. struct sockaddr_in6 *addr = (struct sockaddr_in6 *) uaddr;
  191. __be32 v4addr = 0;
  192. int addr_type;
  193. int err;
  194. if (addr_len < SIN6_LEN_RFC2133)
  195. return -EINVAL;
  196. addr_type = ipv6_addr_type(&addr->sin6_addr);
  197. /* Raw sockets are IPv6 only */
  198. if (addr_type == IPV6_ADDR_MAPPED)
  199. return(-EADDRNOTAVAIL);
  200. lock_sock(sk);
  201. err = -EINVAL;
  202. if (sk->sk_state != TCP_CLOSE)
  203. goto out;
  204. /* Check if the address belongs to the host. */
  205. if (addr_type != IPV6_ADDR_ANY) {
  206. struct net_device *dev = NULL;
  207. if (addr_type & IPV6_ADDR_LINKLOCAL) {
  208. if (addr_len >= sizeof(struct sockaddr_in6) &&
  209. addr->sin6_scope_id) {
  210. /* Override any existing binding, if another
  211. * one is supplied by user.
  212. */
  213. sk->sk_bound_dev_if = addr->sin6_scope_id;
  214. }
  215. /* Binding to link-local address requires an interface */
  216. if (!sk->sk_bound_dev_if)
  217. goto out;
  218. dev = dev_get_by_index(sk->sk_bound_dev_if);
  219. if (!dev) {
  220. err = -ENODEV;
  221. goto out;
  222. }
  223. }
  224. /* ipv4 addr of the socket is invalid. Only the
  225. * unspecified and mapped address have a v4 equivalent.
  226. */
  227. v4addr = LOOPBACK4_IPV6;
  228. if (!(addr_type & IPV6_ADDR_MULTICAST)) {
  229. err = -EADDRNOTAVAIL;
  230. if (!ipv6_chk_addr(&addr->sin6_addr, dev, 0)) {
  231. if (dev)
  232. dev_put(dev);
  233. goto out;
  234. }
  235. }
  236. if (dev)
  237. dev_put(dev);
  238. }
  239. inet->rcv_saddr = inet->saddr = v4addr;
  240. ipv6_addr_copy(&np->rcv_saddr, &addr->sin6_addr);
  241. if (!(addr_type & IPV6_ADDR_MULTICAST))
  242. ipv6_addr_copy(&np->saddr, &addr->sin6_addr);
  243. err = 0;
  244. out:
  245. release_sock(sk);
  246. return err;
  247. }
  248. void rawv6_err(struct sock *sk, struct sk_buff *skb,
  249. struct inet6_skb_parm *opt,
  250. int type, int code, int offset, __be32 info)
  251. {
  252. struct inet_sock *inet = inet_sk(sk);
  253. struct ipv6_pinfo *np = inet6_sk(sk);
  254. int err;
  255. int harderr;
  256. /* Report error on raw socket, if:
  257. 1. User requested recverr.
  258. 2. Socket is connected (otherwise the error indication
  259. is useless without recverr and error is hard.
  260. */
  261. if (!np->recverr && sk->sk_state != TCP_ESTABLISHED)
  262. return;
  263. harderr = icmpv6_err_convert(type, code, &err);
  264. if (type == ICMPV6_PKT_TOOBIG)
  265. harderr = (np->pmtudisc == IPV6_PMTUDISC_DO);
  266. if (np->recverr) {
  267. u8 *payload = skb->data;
  268. if (!inet->hdrincl)
  269. payload += offset;
  270. ipv6_icmp_error(sk, skb, err, 0, ntohl(info), payload);
  271. }
  272. if (np->recverr || harderr) {
  273. sk->sk_err = err;
  274. sk->sk_error_report(sk);
  275. }
  276. }
  277. static inline int rawv6_rcv_skb(struct sock * sk, struct sk_buff * skb)
  278. {
  279. if ((raw6_sk(sk)->checksum || sk->sk_filter) &&
  280. skb_checksum_complete(skb)) {
  281. /* FIXME: increment a raw6 drops counter here */
  282. kfree_skb(skb);
  283. return 0;
  284. }
  285. /* Charge it to the socket. */
  286. if (sock_queue_rcv_skb(sk,skb)<0) {
  287. /* FIXME: increment a raw6 drops counter here */
  288. kfree_skb(skb);
  289. return 0;
  290. }
  291. return 0;
  292. }
  293. /*
  294. * This is next to useless...
  295. * if we demultiplex in network layer we don't need the extra call
  296. * just to queue the skb...
  297. * maybe we could have the network decide upon a hint if it
  298. * should call raw_rcv for demultiplexing
  299. */
  300. int rawv6_rcv(struct sock *sk, struct sk_buff *skb)
  301. {
  302. struct inet_sock *inet = inet_sk(sk);
  303. struct raw6_sock *rp = raw6_sk(sk);
  304. if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) {
  305. kfree_skb(skb);
  306. return NET_RX_DROP;
  307. }
  308. if (!rp->checksum)
  309. skb->ip_summed = CHECKSUM_UNNECESSARY;
  310. if (skb->ip_summed == CHECKSUM_COMPLETE) {
  311. skb_postpull_rcsum(skb, skb->nh.raw,
  312. skb->h.raw - skb->nh.raw);
  313. if (!csum_ipv6_magic(&skb->nh.ipv6h->saddr,
  314. &skb->nh.ipv6h->daddr,
  315. skb->len, inet->num, skb->csum))
  316. skb->ip_summed = CHECKSUM_UNNECESSARY;
  317. }
  318. if (skb->ip_summed != CHECKSUM_UNNECESSARY)
  319. skb->csum = ~csum_unfold(csum_ipv6_magic(&skb->nh.ipv6h->saddr,
  320. &skb->nh.ipv6h->daddr,
  321. skb->len, inet->num, 0));
  322. if (inet->hdrincl) {
  323. if (skb_checksum_complete(skb)) {
  324. /* FIXME: increment a raw6 drops counter here */
  325. kfree_skb(skb);
  326. return 0;
  327. }
  328. }
  329. rawv6_rcv_skb(sk, skb);
  330. return 0;
  331. }
  332. /*
  333. * This should be easy, if there is something there
  334. * we return it, otherwise we block.
  335. */
  336. static int rawv6_recvmsg(struct kiocb *iocb, struct sock *sk,
  337. struct msghdr *msg, size_t len,
  338. int noblock, int flags, int *addr_len)
  339. {
  340. struct ipv6_pinfo *np = inet6_sk(sk);
  341. struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)msg->msg_name;
  342. struct sk_buff *skb;
  343. size_t copied;
  344. int err;
  345. if (flags & MSG_OOB)
  346. return -EOPNOTSUPP;
  347. if (addr_len)
  348. *addr_len=sizeof(*sin6);
  349. if (flags & MSG_ERRQUEUE)
  350. return ipv6_recv_error(sk, msg, len);
  351. skb = skb_recv_datagram(sk, flags, noblock, &err);
  352. if (!skb)
  353. goto out;
  354. copied = skb->len;
  355. if (copied > len) {
  356. copied = len;
  357. msg->msg_flags |= MSG_TRUNC;
  358. }
  359. if (skb->ip_summed==CHECKSUM_UNNECESSARY) {
  360. err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  361. } else if (msg->msg_flags&MSG_TRUNC) {
  362. if (__skb_checksum_complete(skb))
  363. goto csum_copy_err;
  364. err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  365. } else {
  366. err = skb_copy_and_csum_datagram_iovec(skb, 0, msg->msg_iov);
  367. if (err == -EINVAL)
  368. goto csum_copy_err;
  369. }
  370. if (err)
  371. goto out_free;
  372. /* Copy the address. */
  373. if (sin6) {
  374. sin6->sin6_family = AF_INET6;
  375. sin6->sin6_port = 0;
  376. ipv6_addr_copy(&sin6->sin6_addr, &skb->nh.ipv6h->saddr);
  377. sin6->sin6_flowinfo = 0;
  378. sin6->sin6_scope_id = 0;
  379. if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
  380. sin6->sin6_scope_id = IP6CB(skb)->iif;
  381. }
  382. sock_recv_timestamp(msg, sk, skb);
  383. if (np->rxopt.all)
  384. datagram_recv_ctl(sk, msg, skb);
  385. err = copied;
  386. if (flags & MSG_TRUNC)
  387. err = skb->len;
  388. out_free:
  389. skb_free_datagram(sk, skb);
  390. out:
  391. return err;
  392. csum_copy_err:
  393. skb_kill_datagram(sk, skb, flags);
  394. /* Error for blocking case is chosen to masquerade
  395. as some normal condition.
  396. */
  397. err = (flags&MSG_DONTWAIT) ? -EAGAIN : -EHOSTUNREACH;
  398. /* FIXME: increment a raw6 drops counter here */
  399. goto out;
  400. }
  401. static int rawv6_push_pending_frames(struct sock *sk, struct flowi *fl,
  402. struct raw6_sock *rp)
  403. {
  404. struct sk_buff *skb;
  405. int err = 0;
  406. int offset;
  407. int len;
  408. int total_len;
  409. __wsum tmp_csum;
  410. __sum16 csum;
  411. if (!rp->checksum)
  412. goto send;
  413. if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
  414. goto out;
  415. offset = rp->offset;
  416. total_len = inet_sk(sk)->cork.length - (skb->nh.raw - skb->data);
  417. if (offset >= total_len - 1) {
  418. err = -EINVAL;
  419. ip6_flush_pending_frames(sk);
  420. goto out;
  421. }
  422. /* should be check HW csum miyazawa */
  423. if (skb_queue_len(&sk->sk_write_queue) == 1) {
  424. /*
  425. * Only one fragment on the socket.
  426. */
  427. tmp_csum = skb->csum;
  428. } else {
  429. struct sk_buff *csum_skb = NULL;
  430. tmp_csum = 0;
  431. skb_queue_walk(&sk->sk_write_queue, skb) {
  432. tmp_csum = csum_add(tmp_csum, skb->csum);
  433. if (csum_skb)
  434. continue;
  435. len = skb->len - (skb->h.raw - skb->data);
  436. if (offset >= len) {
  437. offset -= len;
  438. continue;
  439. }
  440. csum_skb = skb;
  441. }
  442. skb = csum_skb;
  443. }
  444. offset += skb->h.raw - skb->data;
  445. if (skb_copy_bits(skb, offset, &csum, 2))
  446. BUG();
  447. /* in case cksum was not initialized */
  448. if (unlikely(csum))
  449. tmp_csum = csum_sub(tmp_csum, csum_unfold(csum));
  450. csum = csum_ipv6_magic(&fl->fl6_src,
  451. &fl->fl6_dst,
  452. total_len, fl->proto, tmp_csum);
  453. if (csum == 0 && fl->proto == IPPROTO_UDP)
  454. csum = CSUM_MANGLED_0;
  455. if (skb_store_bits(skb, offset, &csum, 2))
  456. BUG();
  457. send:
  458. err = ip6_push_pending_frames(sk);
  459. out:
  460. return err;
  461. }
  462. static int rawv6_send_hdrinc(struct sock *sk, void *from, int length,
  463. struct flowi *fl, struct rt6_info *rt,
  464. unsigned int flags)
  465. {
  466. struct ipv6_pinfo *np = inet6_sk(sk);
  467. struct ipv6hdr *iph;
  468. struct sk_buff *skb;
  469. unsigned int hh_len;
  470. int err;
  471. if (length > rt->u.dst.dev->mtu) {
  472. ipv6_local_error(sk, EMSGSIZE, fl, rt->u.dst.dev->mtu);
  473. return -EMSGSIZE;
  474. }
  475. if (flags&MSG_PROBE)
  476. goto out;
  477. hh_len = LL_RESERVED_SPACE(rt->u.dst.dev);
  478. skb = sock_alloc_send_skb(sk, length+hh_len+15,
  479. flags&MSG_DONTWAIT, &err);
  480. if (skb == NULL)
  481. goto error;
  482. skb_reserve(skb, hh_len);
  483. skb->priority = sk->sk_priority;
  484. skb->dst = dst_clone(&rt->u.dst);
  485. skb->nh.ipv6h = iph = (struct ipv6hdr *)skb_put(skb, length);
  486. skb->ip_summed = CHECKSUM_NONE;
  487. skb->h.raw = skb->nh.raw;
  488. err = memcpy_fromiovecend((void *)iph, from, 0, length);
  489. if (err)
  490. goto error_fault;
  491. IP6_INC_STATS(rt->rt6i_idev, IPSTATS_MIB_OUTREQUESTS);
  492. err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
  493. dst_output);
  494. if (err > 0)
  495. err = np->recverr ? net_xmit_errno(err) : 0;
  496. if (err)
  497. goto error;
  498. out:
  499. return 0;
  500. error_fault:
  501. err = -EFAULT;
  502. kfree_skb(skb);
  503. error:
  504. IP6_INC_STATS(rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
  505. return err;
  506. }
  507. static int rawv6_probe_proto_opt(struct flowi *fl, struct msghdr *msg)
  508. {
  509. struct iovec *iov;
  510. u8 __user *type = NULL;
  511. u8 __user *code = NULL;
  512. #ifdef CONFIG_IPV6_MIP6
  513. u8 len = 0;
  514. #endif
  515. int probed = 0;
  516. int i;
  517. if (!msg->msg_iov)
  518. return 0;
  519. for (i = 0; i < msg->msg_iovlen; i++) {
  520. iov = &msg->msg_iov[i];
  521. if (!iov)
  522. continue;
  523. switch (fl->proto) {
  524. case IPPROTO_ICMPV6:
  525. /* check if one-byte field is readable or not. */
  526. if (iov->iov_base && iov->iov_len < 1)
  527. break;
  528. if (!type) {
  529. type = iov->iov_base;
  530. /* check if code field is readable or not. */
  531. if (iov->iov_len > 1)
  532. code = type + 1;
  533. } else if (!code)
  534. code = iov->iov_base;
  535. if (type && code) {
  536. if (get_user(fl->fl_icmp_type, type) ||
  537. get_user(fl->fl_icmp_code, code))
  538. return -EFAULT;
  539. probed = 1;
  540. }
  541. break;
  542. #ifdef CONFIG_IPV6_MIP6
  543. case IPPROTO_MH:
  544. if (iov->iov_base && iov->iov_len < 1)
  545. break;
  546. /* check if type field is readable or not. */
  547. if (iov->iov_len > 2 - len) {
  548. u8 __user *p = iov->iov_base;
  549. if (get_user(fl->fl_mh_type, &p[2 - len]))
  550. return -EFAULT;
  551. probed = 1;
  552. } else
  553. len += iov->iov_len;
  554. break;
  555. #endif
  556. default:
  557. probed = 1;
  558. break;
  559. }
  560. if (probed)
  561. break;
  562. }
  563. return 0;
  564. }
  565. static int rawv6_sendmsg(struct kiocb *iocb, struct sock *sk,
  566. struct msghdr *msg, size_t len)
  567. {
  568. struct ipv6_txoptions opt_space;
  569. struct sockaddr_in6 * sin6 = (struct sockaddr_in6 *) msg->msg_name;
  570. struct in6_addr *daddr, *final_p = NULL, final;
  571. struct inet_sock *inet = inet_sk(sk);
  572. struct ipv6_pinfo *np = inet6_sk(sk);
  573. struct raw6_sock *rp = raw6_sk(sk);
  574. struct ipv6_txoptions *opt = NULL;
  575. struct ip6_flowlabel *flowlabel = NULL;
  576. struct dst_entry *dst = NULL;
  577. struct flowi fl;
  578. int addr_len = msg->msg_namelen;
  579. int hlimit = -1;
  580. int tclass = -1;
  581. u16 proto;
  582. int err;
  583. /* Rough check on arithmetic overflow,
  584. better check is made in ip6_append_data().
  585. */
  586. if (len > INT_MAX)
  587. return -EMSGSIZE;
  588. /* Mirror BSD error message compatibility */
  589. if (msg->msg_flags & MSG_OOB)
  590. return -EOPNOTSUPP;
  591. /*
  592. * Get and verify the address.
  593. */
  594. memset(&fl, 0, sizeof(fl));
  595. if (sin6) {
  596. if (addr_len < SIN6_LEN_RFC2133)
  597. return -EINVAL;
  598. if (sin6->sin6_family && sin6->sin6_family != AF_INET6)
  599. return(-EAFNOSUPPORT);
  600. /* port is the proto value [0..255] carried in nexthdr */
  601. proto = ntohs(sin6->sin6_port);
  602. if (!proto)
  603. proto = inet->num;
  604. else if (proto != inet->num)
  605. return(-EINVAL);
  606. if (proto > 255)
  607. return(-EINVAL);
  608. daddr = &sin6->sin6_addr;
  609. if (np->sndflow) {
  610. fl.fl6_flowlabel = sin6->sin6_flowinfo&IPV6_FLOWINFO_MASK;
  611. if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
  612. flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
  613. if (flowlabel == NULL)
  614. return -EINVAL;
  615. daddr = &flowlabel->dst;
  616. }
  617. }
  618. /*
  619. * Otherwise it will be difficult to maintain
  620. * sk->sk_dst_cache.
  621. */
  622. if (sk->sk_state == TCP_ESTABLISHED &&
  623. ipv6_addr_equal(daddr, &np->daddr))
  624. daddr = &np->daddr;
  625. if (addr_len >= sizeof(struct sockaddr_in6) &&
  626. sin6->sin6_scope_id &&
  627. ipv6_addr_type(daddr)&IPV6_ADDR_LINKLOCAL)
  628. fl.oif = sin6->sin6_scope_id;
  629. } else {
  630. if (sk->sk_state != TCP_ESTABLISHED)
  631. return -EDESTADDRREQ;
  632. proto = inet->num;
  633. daddr = &np->daddr;
  634. fl.fl6_flowlabel = np->flow_label;
  635. }
  636. if (ipv6_addr_any(daddr)) {
  637. /*
  638. * unspecified destination address
  639. * treated as error... is this correct ?
  640. */
  641. fl6_sock_release(flowlabel);
  642. return(-EINVAL);
  643. }
  644. if (fl.oif == 0)
  645. fl.oif = sk->sk_bound_dev_if;
  646. if (msg->msg_controllen) {
  647. opt = &opt_space;
  648. memset(opt, 0, sizeof(struct ipv6_txoptions));
  649. opt->tot_len = sizeof(struct ipv6_txoptions);
  650. err = datagram_send_ctl(msg, &fl, opt, &hlimit, &tclass);
  651. if (err < 0) {
  652. fl6_sock_release(flowlabel);
  653. return err;
  654. }
  655. if ((fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) && !flowlabel) {
  656. flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
  657. if (flowlabel == NULL)
  658. return -EINVAL;
  659. }
  660. if (!(opt->opt_nflen|opt->opt_flen))
  661. opt = NULL;
  662. }
  663. if (opt == NULL)
  664. opt = np->opt;
  665. if (flowlabel)
  666. opt = fl6_merge_options(&opt_space, flowlabel, opt);
  667. opt = ipv6_fixup_options(&opt_space, opt);
  668. fl.proto = proto;
  669. err = rawv6_probe_proto_opt(&fl, msg);
  670. if (err)
  671. goto out;
  672. ipv6_addr_copy(&fl.fl6_dst, daddr);
  673. if (ipv6_addr_any(&fl.fl6_src) && !ipv6_addr_any(&np->saddr))
  674. ipv6_addr_copy(&fl.fl6_src, &np->saddr);
  675. /* merge ip6_build_xmit from ip6_output */
  676. if (opt && opt->srcrt) {
  677. struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
  678. ipv6_addr_copy(&final, &fl.fl6_dst);
  679. ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
  680. final_p = &final;
  681. }
  682. if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
  683. fl.oif = np->mcast_oif;
  684. security_sk_classify_flow(sk, &fl);
  685. err = ip6_dst_lookup(sk, &dst, &fl);
  686. if (err)
  687. goto out;
  688. if (final_p)
  689. ipv6_addr_copy(&fl.fl6_dst, final_p);
  690. if ((err = xfrm_lookup(&dst, &fl, sk, 1)) < 0)
  691. goto out;
  692. if (hlimit < 0) {
  693. if (ipv6_addr_is_multicast(&fl.fl6_dst))
  694. hlimit = np->mcast_hops;
  695. else
  696. hlimit = np->hop_limit;
  697. if (hlimit < 0)
  698. hlimit = dst_metric(dst, RTAX_HOPLIMIT);
  699. if (hlimit < 0)
  700. hlimit = ipv6_get_hoplimit(dst->dev);
  701. }
  702. if (tclass < 0) {
  703. tclass = np->tclass;
  704. if (tclass < 0)
  705. tclass = 0;
  706. }
  707. if (msg->msg_flags&MSG_CONFIRM)
  708. goto do_confirm;
  709. back_from_confirm:
  710. if (inet->hdrincl) {
  711. err = rawv6_send_hdrinc(sk, msg->msg_iov, len, &fl, (struct rt6_info*)dst, msg->msg_flags);
  712. } else {
  713. lock_sock(sk);
  714. err = ip6_append_data(sk, ip_generic_getfrag, msg->msg_iov,
  715. len, 0, hlimit, tclass, opt, &fl, (struct rt6_info*)dst,
  716. msg->msg_flags);
  717. if (err)
  718. ip6_flush_pending_frames(sk);
  719. else if (!(msg->msg_flags & MSG_MORE))
  720. err = rawv6_push_pending_frames(sk, &fl, rp);
  721. }
  722. done:
  723. dst_release(dst);
  724. if (!inet->hdrincl)
  725. release_sock(sk);
  726. out:
  727. fl6_sock_release(flowlabel);
  728. return err<0?err:len;
  729. do_confirm:
  730. dst_confirm(dst);
  731. if (!(msg->msg_flags & MSG_PROBE) || len)
  732. goto back_from_confirm;
  733. err = 0;
  734. goto done;
  735. }
  736. static int rawv6_seticmpfilter(struct sock *sk, int level, int optname,
  737. char __user *optval, int optlen)
  738. {
  739. switch (optname) {
  740. case ICMPV6_FILTER:
  741. if (optlen > sizeof(struct icmp6_filter))
  742. optlen = sizeof(struct icmp6_filter);
  743. if (copy_from_user(&raw6_sk(sk)->filter, optval, optlen))
  744. return -EFAULT;
  745. return 0;
  746. default:
  747. return -ENOPROTOOPT;
  748. };
  749. return 0;
  750. }
  751. static int rawv6_geticmpfilter(struct sock *sk, int level, int optname,
  752. char __user *optval, int __user *optlen)
  753. {
  754. int len;
  755. switch (optname) {
  756. case ICMPV6_FILTER:
  757. if (get_user(len, optlen))
  758. return -EFAULT;
  759. if (len < 0)
  760. return -EINVAL;
  761. if (len > sizeof(struct icmp6_filter))
  762. len = sizeof(struct icmp6_filter);
  763. if (put_user(len, optlen))
  764. return -EFAULT;
  765. if (copy_to_user(optval, &raw6_sk(sk)->filter, len))
  766. return -EFAULT;
  767. return 0;
  768. default:
  769. return -ENOPROTOOPT;
  770. };
  771. return 0;
  772. }
  773. static int do_rawv6_setsockopt(struct sock *sk, int level, int optname,
  774. char __user *optval, int optlen)
  775. {
  776. struct raw6_sock *rp = raw6_sk(sk);
  777. int val;
  778. if (get_user(val, (int __user *)optval))
  779. return -EFAULT;
  780. switch (optname) {
  781. case IPV6_CHECKSUM:
  782. /* You may get strange result with a positive odd offset;
  783. RFC2292bis agrees with me. */
  784. if (val > 0 && (val&1))
  785. return(-EINVAL);
  786. if (val < 0) {
  787. rp->checksum = 0;
  788. } else {
  789. rp->checksum = 1;
  790. rp->offset = val;
  791. }
  792. return 0;
  793. break;
  794. default:
  795. return(-ENOPROTOOPT);
  796. }
  797. }
  798. static int rawv6_setsockopt(struct sock *sk, int level, int optname,
  799. char __user *optval, int optlen)
  800. {
  801. switch(level) {
  802. case SOL_RAW:
  803. break;
  804. case SOL_ICMPV6:
  805. if (inet_sk(sk)->num != IPPROTO_ICMPV6)
  806. return -EOPNOTSUPP;
  807. return rawv6_seticmpfilter(sk, level, optname, optval,
  808. optlen);
  809. case SOL_IPV6:
  810. if (optname == IPV6_CHECKSUM)
  811. break;
  812. default:
  813. return ipv6_setsockopt(sk, level, optname, optval,
  814. optlen);
  815. };
  816. return do_rawv6_setsockopt(sk, level, optname, optval, optlen);
  817. }
  818. #ifdef CONFIG_COMPAT
  819. static int compat_rawv6_setsockopt(struct sock *sk, int level, int optname,
  820. char __user *optval, int optlen)
  821. {
  822. switch (level) {
  823. case SOL_RAW:
  824. break;
  825. case SOL_ICMPV6:
  826. if (inet_sk(sk)->num != IPPROTO_ICMPV6)
  827. return -EOPNOTSUPP;
  828. return rawv6_seticmpfilter(sk, level, optname, optval, optlen);
  829. case SOL_IPV6:
  830. if (optname == IPV6_CHECKSUM)
  831. break;
  832. default:
  833. return compat_ipv6_setsockopt(sk, level, optname,
  834. optval, optlen);
  835. };
  836. return do_rawv6_setsockopt(sk, level, optname, optval, optlen);
  837. }
  838. #endif
  839. static int do_rawv6_getsockopt(struct sock *sk, int level, int optname,
  840. char __user *optval, int __user *optlen)
  841. {
  842. struct raw6_sock *rp = raw6_sk(sk);
  843. int val, len;
  844. if (get_user(len,optlen))
  845. return -EFAULT;
  846. switch (optname) {
  847. case IPV6_CHECKSUM:
  848. if (rp->checksum == 0)
  849. val = -1;
  850. else
  851. val = rp->offset;
  852. break;
  853. default:
  854. return -ENOPROTOOPT;
  855. }
  856. len = min_t(unsigned int, sizeof(int), len);
  857. if (put_user(len, optlen))
  858. return -EFAULT;
  859. if (copy_to_user(optval,&val,len))
  860. return -EFAULT;
  861. return 0;
  862. }
  863. static int rawv6_getsockopt(struct sock *sk, int level, int optname,
  864. char __user *optval, int __user *optlen)
  865. {
  866. switch(level) {
  867. case SOL_RAW:
  868. break;
  869. case SOL_ICMPV6:
  870. if (inet_sk(sk)->num != IPPROTO_ICMPV6)
  871. return -EOPNOTSUPP;
  872. return rawv6_geticmpfilter(sk, level, optname, optval,
  873. optlen);
  874. case SOL_IPV6:
  875. if (optname == IPV6_CHECKSUM)
  876. break;
  877. default:
  878. return ipv6_getsockopt(sk, level, optname, optval,
  879. optlen);
  880. };
  881. return do_rawv6_getsockopt(sk, level, optname, optval, optlen);
  882. }
  883. #ifdef CONFIG_COMPAT
  884. static int compat_rawv6_getsockopt(struct sock *sk, int level, int optname,
  885. char __user *optval, int __user *optlen)
  886. {
  887. switch (level) {
  888. case SOL_RAW:
  889. break;
  890. case SOL_ICMPV6:
  891. if (inet_sk(sk)->num != IPPROTO_ICMPV6)
  892. return -EOPNOTSUPP;
  893. return rawv6_geticmpfilter(sk, level, optname, optval, optlen);
  894. case SOL_IPV6:
  895. if (optname == IPV6_CHECKSUM)
  896. break;
  897. default:
  898. return compat_ipv6_getsockopt(sk, level, optname,
  899. optval, optlen);
  900. };
  901. return do_rawv6_getsockopt(sk, level, optname, optval, optlen);
  902. }
  903. #endif
  904. static int rawv6_ioctl(struct sock *sk, int cmd, unsigned long arg)
  905. {
  906. switch(cmd) {
  907. case SIOCOUTQ:
  908. {
  909. int amount = atomic_read(&sk->sk_wmem_alloc);
  910. return put_user(amount, (int __user *)arg);
  911. }
  912. case SIOCINQ:
  913. {
  914. struct sk_buff *skb;
  915. int amount = 0;
  916. spin_lock_bh(&sk->sk_receive_queue.lock);
  917. skb = skb_peek(&sk->sk_receive_queue);
  918. if (skb != NULL)
  919. amount = skb->tail - skb->h.raw;
  920. spin_unlock_bh(&sk->sk_receive_queue.lock);
  921. return put_user(amount, (int __user *)arg);
  922. }
  923. default:
  924. return -ENOIOCTLCMD;
  925. }
  926. }
  927. static void rawv6_close(struct sock *sk, long timeout)
  928. {
  929. if (inet_sk(sk)->num == IPPROTO_RAW)
  930. ip6_ra_control(sk, -1, NULL);
  931. sk_common_release(sk);
  932. }
  933. static int rawv6_init_sk(struct sock *sk)
  934. {
  935. struct raw6_sock *rp = raw6_sk(sk);
  936. switch (inet_sk(sk)->num) {
  937. case IPPROTO_ICMPV6:
  938. rp->checksum = 1;
  939. rp->offset = 2;
  940. break;
  941. case IPPROTO_MH:
  942. rp->checksum = 1;
  943. rp->offset = 4;
  944. break;
  945. default:
  946. break;
  947. }
  948. return(0);
  949. }
  950. struct proto rawv6_prot = {
  951. .name = "RAWv6",
  952. .owner = THIS_MODULE,
  953. .close = rawv6_close,
  954. .connect = ip6_datagram_connect,
  955. .disconnect = udp_disconnect,
  956. .ioctl = rawv6_ioctl,
  957. .init = rawv6_init_sk,
  958. .destroy = inet6_destroy_sock,
  959. .setsockopt = rawv6_setsockopt,
  960. .getsockopt = rawv6_getsockopt,
  961. .sendmsg = rawv6_sendmsg,
  962. .recvmsg = rawv6_recvmsg,
  963. .bind = rawv6_bind,
  964. .backlog_rcv = rawv6_rcv_skb,
  965. .hash = raw_v6_hash,
  966. .unhash = raw_v6_unhash,
  967. .obj_size = sizeof(struct raw6_sock),
  968. #ifdef CONFIG_COMPAT
  969. .compat_setsockopt = compat_rawv6_setsockopt,
  970. .compat_getsockopt = compat_rawv6_getsockopt,
  971. #endif
  972. };
  973. #ifdef CONFIG_PROC_FS
  974. struct raw6_iter_state {
  975. int bucket;
  976. };
  977. #define raw6_seq_private(seq) ((struct raw6_iter_state *)(seq)->private)
  978. static struct sock *raw6_get_first(struct seq_file *seq)
  979. {
  980. struct sock *sk;
  981. struct hlist_node *node;
  982. struct raw6_iter_state* state = raw6_seq_private(seq);
  983. for (state->bucket = 0; state->bucket < RAWV6_HTABLE_SIZE; ++state->bucket)
  984. sk_for_each(sk, node, &raw_v6_htable[state->bucket])
  985. if (sk->sk_family == PF_INET6)
  986. goto out;
  987. sk = NULL;
  988. out:
  989. return sk;
  990. }
  991. static struct sock *raw6_get_next(struct seq_file *seq, struct sock *sk)
  992. {
  993. struct raw6_iter_state* state = raw6_seq_private(seq);
  994. do {
  995. sk = sk_next(sk);
  996. try_again:
  997. ;
  998. } while (sk && sk->sk_family != PF_INET6);
  999. if (!sk && ++state->bucket < RAWV6_HTABLE_SIZE) {
  1000. sk = sk_head(&raw_v6_htable[state->bucket]);
  1001. goto try_again;
  1002. }
  1003. return sk;
  1004. }
  1005. static struct sock *raw6_get_idx(struct seq_file *seq, loff_t pos)
  1006. {
  1007. struct sock *sk = raw6_get_first(seq);
  1008. if (sk)
  1009. while (pos && (sk = raw6_get_next(seq, sk)) != NULL)
  1010. --pos;
  1011. return pos ? NULL : sk;
  1012. }
  1013. static void *raw6_seq_start(struct seq_file *seq, loff_t *pos)
  1014. {
  1015. read_lock(&raw_v6_lock);
  1016. return *pos ? raw6_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
  1017. }
  1018. static void *raw6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  1019. {
  1020. struct sock *sk;
  1021. if (v == SEQ_START_TOKEN)
  1022. sk = raw6_get_first(seq);
  1023. else
  1024. sk = raw6_get_next(seq, v);
  1025. ++*pos;
  1026. return sk;
  1027. }
  1028. static void raw6_seq_stop(struct seq_file *seq, void *v)
  1029. {
  1030. read_unlock(&raw_v6_lock);
  1031. }
  1032. static void raw6_sock_seq_show(struct seq_file *seq, struct sock *sp, int i)
  1033. {
  1034. struct ipv6_pinfo *np = inet6_sk(sp);
  1035. struct in6_addr *dest, *src;
  1036. __u16 destp, srcp;
  1037. dest = &np->daddr;
  1038. src = &np->rcv_saddr;
  1039. destp = 0;
  1040. srcp = inet_sk(sp)->num;
  1041. seq_printf(seq,
  1042. "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
  1043. "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p\n",
  1044. i,
  1045. src->s6_addr32[0], src->s6_addr32[1],
  1046. src->s6_addr32[2], src->s6_addr32[3], srcp,
  1047. dest->s6_addr32[0], dest->s6_addr32[1],
  1048. dest->s6_addr32[2], dest->s6_addr32[3], destp,
  1049. sp->sk_state,
  1050. atomic_read(&sp->sk_wmem_alloc),
  1051. atomic_read(&sp->sk_rmem_alloc),
  1052. 0, 0L, 0,
  1053. sock_i_uid(sp), 0,
  1054. sock_i_ino(sp),
  1055. atomic_read(&sp->sk_refcnt), sp);
  1056. }
  1057. static int raw6_seq_show(struct seq_file *seq, void *v)
  1058. {
  1059. if (v == SEQ_START_TOKEN)
  1060. seq_printf(seq,
  1061. " sl "
  1062. "local_address "
  1063. "remote_address "
  1064. "st tx_queue rx_queue tr tm->when retrnsmt"
  1065. " uid timeout inode\n");
  1066. else
  1067. raw6_sock_seq_show(seq, v, raw6_seq_private(seq)->bucket);
  1068. return 0;
  1069. }
  1070. static struct seq_operations raw6_seq_ops = {
  1071. .start = raw6_seq_start,
  1072. .next = raw6_seq_next,
  1073. .stop = raw6_seq_stop,
  1074. .show = raw6_seq_show,
  1075. };
  1076. static int raw6_seq_open(struct inode *inode, struct file *file)
  1077. {
  1078. struct seq_file *seq;
  1079. int rc = -ENOMEM;
  1080. struct raw6_iter_state *s = kzalloc(sizeof(*s), GFP_KERNEL);
  1081. if (!s)
  1082. goto out;
  1083. rc = seq_open(file, &raw6_seq_ops);
  1084. if (rc)
  1085. goto out_kfree;
  1086. seq = file->private_data;
  1087. seq->private = s;
  1088. out:
  1089. return rc;
  1090. out_kfree:
  1091. kfree(s);
  1092. goto out;
  1093. }
  1094. static const struct file_operations raw6_seq_fops = {
  1095. .owner = THIS_MODULE,
  1096. .open = raw6_seq_open,
  1097. .read = seq_read,
  1098. .llseek = seq_lseek,
  1099. .release = seq_release_private,
  1100. };
  1101. int __init raw6_proc_init(void)
  1102. {
  1103. if (!proc_net_fops_create("raw6", S_IRUGO, &raw6_seq_fops))
  1104. return -ENOMEM;
  1105. return 0;
  1106. }
  1107. void raw6_proc_exit(void)
  1108. {
  1109. proc_net_remove("raw6");
  1110. }
  1111. #endif /* CONFIG_PROC_FS */