raw.c 30 KB

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