ipv6.c 30 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * DCCP over IPv6
  4. * Linux INET6 implementation
  5. *
  6. * Based on net/dccp6/ipv6.c
  7. *
  8. * Arnaldo Carvalho de Melo <[email protected]>
  9. */
  10. #include <linux/module.h>
  11. #include <linux/random.h>
  12. #include <linux/slab.h>
  13. #include <linux/xfrm.h>
  14. #include <linux/string.h>
  15. #include <net/addrconf.h>
  16. #include <net/inet_common.h>
  17. #include <net/inet_hashtables.h>
  18. #include <net/inet_sock.h>
  19. #include <net/inet6_connection_sock.h>
  20. #include <net/inet6_hashtables.h>
  21. #include <net/ip6_route.h>
  22. #include <net/ipv6.h>
  23. #include <net/protocol.h>
  24. #include <net/transp_v6.h>
  25. #include <net/ip6_checksum.h>
  26. #include <net/xfrm.h>
  27. #include <net/secure_seq.h>
  28. #include <net/netns/generic.h>
  29. #include <net/sock.h>
  30. #include "dccp.h"
  31. #include "ipv6.h"
  32. #include "feat.h"
  33. struct dccp_v6_pernet {
  34. struct sock *v6_ctl_sk;
  35. };
  36. static unsigned int dccp_v6_pernet_id __read_mostly;
  37. /* The per-net v6_ctl_sk is used for sending RSTs and ACKs */
  38. static const struct inet_connection_sock_af_ops dccp_ipv6_mapped;
  39. static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops;
  40. /* add pseudo-header to DCCP checksum stored in skb->csum */
  41. static inline __sum16 dccp_v6_csum_finish(struct sk_buff *skb,
  42. const struct in6_addr *saddr,
  43. const struct in6_addr *daddr)
  44. {
  45. return csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_DCCP, skb->csum);
  46. }
  47. static inline void dccp_v6_send_check(struct sock *sk, struct sk_buff *skb)
  48. {
  49. struct ipv6_pinfo *np = inet6_sk(sk);
  50. struct dccp_hdr *dh = dccp_hdr(skb);
  51. dccp_csum_outgoing(skb);
  52. dh->dccph_checksum = dccp_v6_csum_finish(skb, &np->saddr, &sk->sk_v6_daddr);
  53. }
  54. static inline __u64 dccp_v6_init_sequence(struct sk_buff *skb)
  55. {
  56. return secure_dccpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
  57. ipv6_hdr(skb)->saddr.s6_addr32,
  58. dccp_hdr(skb)->dccph_dport,
  59. dccp_hdr(skb)->dccph_sport );
  60. }
  61. static int dccp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
  62. u8 type, u8 code, int offset, __be32 info)
  63. {
  64. const struct ipv6hdr *hdr;
  65. const struct dccp_hdr *dh;
  66. struct dccp_sock *dp;
  67. struct ipv6_pinfo *np;
  68. struct sock *sk;
  69. int err;
  70. __u64 seq;
  71. struct net *net = dev_net(skb->dev);
  72. if (!pskb_may_pull(skb, offset + sizeof(*dh)))
  73. return -EINVAL;
  74. dh = (struct dccp_hdr *)(skb->data + offset);
  75. if (!pskb_may_pull(skb, offset + __dccp_basic_hdr_len(dh)))
  76. return -EINVAL;
  77. hdr = (const struct ipv6hdr *)skb->data;
  78. dh = (struct dccp_hdr *)(skb->data + offset);
  79. sk = __inet6_lookup_established(net, &dccp_hashinfo,
  80. &hdr->daddr, dh->dccph_dport,
  81. &hdr->saddr, ntohs(dh->dccph_sport),
  82. inet6_iif(skb), 0);
  83. if (!sk) {
  84. __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev),
  85. ICMP6_MIB_INERRORS);
  86. return -ENOENT;
  87. }
  88. if (sk->sk_state == DCCP_TIME_WAIT) {
  89. inet_twsk_put(inet_twsk(sk));
  90. return 0;
  91. }
  92. seq = dccp_hdr_seq(dh);
  93. if (sk->sk_state == DCCP_NEW_SYN_RECV) {
  94. dccp_req_err(sk, seq);
  95. return 0;
  96. }
  97. bh_lock_sock(sk);
  98. if (sock_owned_by_user(sk))
  99. __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS);
  100. if (sk->sk_state == DCCP_CLOSED)
  101. goto out;
  102. dp = dccp_sk(sk);
  103. if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_LISTEN) &&
  104. !between48(seq, dp->dccps_awl, dp->dccps_awh)) {
  105. __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
  106. goto out;
  107. }
  108. np = inet6_sk(sk);
  109. if (type == NDISC_REDIRECT) {
  110. if (!sock_owned_by_user(sk)) {
  111. struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
  112. if (dst)
  113. dst->ops->redirect(dst, sk, skb);
  114. }
  115. goto out;
  116. }
  117. if (type == ICMPV6_PKT_TOOBIG) {
  118. struct dst_entry *dst = NULL;
  119. if (!ip6_sk_accept_pmtu(sk))
  120. goto out;
  121. if (sock_owned_by_user(sk))
  122. goto out;
  123. if ((1 << sk->sk_state) & (DCCPF_LISTEN | DCCPF_CLOSED))
  124. goto out;
  125. dst = inet6_csk_update_pmtu(sk, ntohl(info));
  126. if (!dst)
  127. goto out;
  128. if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst))
  129. dccp_sync_mss(sk, dst_mtu(dst));
  130. goto out;
  131. }
  132. icmpv6_err_convert(type, code, &err);
  133. /* Might be for an request_sock */
  134. switch (sk->sk_state) {
  135. case DCCP_REQUESTING:
  136. case DCCP_RESPOND: /* Cannot happen.
  137. It can, it SYNs are crossed. --ANK */
  138. if (!sock_owned_by_user(sk)) {
  139. __DCCP_INC_STATS(DCCP_MIB_ATTEMPTFAILS);
  140. sk->sk_err = err;
  141. /*
  142. * Wake people up to see the error
  143. * (see connect in sock.c)
  144. */
  145. sk_error_report(sk);
  146. dccp_done(sk);
  147. } else
  148. sk->sk_err_soft = err;
  149. goto out;
  150. }
  151. if (!sock_owned_by_user(sk) && np->recverr) {
  152. sk->sk_err = err;
  153. sk_error_report(sk);
  154. } else
  155. sk->sk_err_soft = err;
  156. out:
  157. bh_unlock_sock(sk);
  158. sock_put(sk);
  159. return 0;
  160. }
  161. static int dccp_v6_send_response(const struct sock *sk, struct request_sock *req)
  162. {
  163. struct inet_request_sock *ireq = inet_rsk(req);
  164. struct ipv6_pinfo *np = inet6_sk(sk);
  165. struct sk_buff *skb;
  166. struct in6_addr *final_p, final;
  167. struct flowi6 fl6;
  168. int err = -1;
  169. struct dst_entry *dst;
  170. memset(&fl6, 0, sizeof(fl6));
  171. fl6.flowi6_proto = IPPROTO_DCCP;
  172. fl6.daddr = ireq->ir_v6_rmt_addr;
  173. fl6.saddr = ireq->ir_v6_loc_addr;
  174. fl6.flowlabel = 0;
  175. fl6.flowi6_oif = ireq->ir_iif;
  176. fl6.fl6_dport = ireq->ir_rmt_port;
  177. fl6.fl6_sport = htons(ireq->ir_num);
  178. security_req_classify_flow(req, flowi6_to_flowi_common(&fl6));
  179. rcu_read_lock();
  180. final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt), &final);
  181. rcu_read_unlock();
  182. dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
  183. if (IS_ERR(dst)) {
  184. err = PTR_ERR(dst);
  185. dst = NULL;
  186. goto done;
  187. }
  188. skb = dccp_make_response(sk, dst, req);
  189. if (skb != NULL) {
  190. struct dccp_hdr *dh = dccp_hdr(skb);
  191. struct ipv6_txoptions *opt;
  192. dh->dccph_checksum = dccp_v6_csum_finish(skb,
  193. &ireq->ir_v6_loc_addr,
  194. &ireq->ir_v6_rmt_addr);
  195. fl6.daddr = ireq->ir_v6_rmt_addr;
  196. rcu_read_lock();
  197. opt = ireq->ipv6_opt;
  198. if (!opt)
  199. opt = rcu_dereference(np->opt);
  200. err = ip6_xmit(sk, skb, &fl6, READ_ONCE(sk->sk_mark), opt,
  201. np->tclass, sk->sk_priority);
  202. rcu_read_unlock();
  203. err = net_xmit_eval(err);
  204. }
  205. done:
  206. dst_release(dst);
  207. return err;
  208. }
  209. static void dccp_v6_reqsk_destructor(struct request_sock *req)
  210. {
  211. dccp_feat_list_purge(&dccp_rsk(req)->dreq_featneg);
  212. kfree(inet_rsk(req)->ipv6_opt);
  213. kfree_skb(inet_rsk(req)->pktopts);
  214. }
  215. static void dccp_v6_ctl_send_reset(const struct sock *sk, struct sk_buff *rxskb)
  216. {
  217. const struct ipv6hdr *rxip6h;
  218. struct sk_buff *skb;
  219. struct flowi6 fl6;
  220. struct net *net = dev_net(skb_dst(rxskb)->dev);
  221. struct dccp_v6_pernet *pn;
  222. struct sock *ctl_sk;
  223. struct dst_entry *dst;
  224. if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
  225. return;
  226. if (!ipv6_unicast_destination(rxskb))
  227. return;
  228. pn = net_generic(net, dccp_v6_pernet_id);
  229. ctl_sk = pn->v6_ctl_sk;
  230. skb = dccp_ctl_make_reset(ctl_sk, rxskb);
  231. if (skb == NULL)
  232. return;
  233. rxip6h = ipv6_hdr(rxskb);
  234. dccp_hdr(skb)->dccph_checksum = dccp_v6_csum_finish(skb, &rxip6h->saddr,
  235. &rxip6h->daddr);
  236. memset(&fl6, 0, sizeof(fl6));
  237. fl6.daddr = rxip6h->saddr;
  238. fl6.saddr = rxip6h->daddr;
  239. fl6.flowi6_proto = IPPROTO_DCCP;
  240. fl6.flowi6_oif = inet6_iif(rxskb);
  241. fl6.fl6_dport = dccp_hdr(skb)->dccph_dport;
  242. fl6.fl6_sport = dccp_hdr(skb)->dccph_sport;
  243. security_skb_classify_flow(rxskb, flowi6_to_flowi_common(&fl6));
  244. /* sk = NULL, but it is safe for now. RST socket required. */
  245. dst = ip6_dst_lookup_flow(sock_net(ctl_sk), ctl_sk, &fl6, NULL);
  246. if (!IS_ERR(dst)) {
  247. skb_dst_set(skb, dst);
  248. ip6_xmit(ctl_sk, skb, &fl6, 0, NULL, 0, 0);
  249. DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
  250. DCCP_INC_STATS(DCCP_MIB_OUTRSTS);
  251. return;
  252. }
  253. kfree_skb(skb);
  254. }
  255. static struct request_sock_ops dccp6_request_sock_ops = {
  256. .family = AF_INET6,
  257. .obj_size = sizeof(struct dccp6_request_sock),
  258. .rtx_syn_ack = dccp_v6_send_response,
  259. .send_ack = dccp_reqsk_send_ack,
  260. .destructor = dccp_v6_reqsk_destructor,
  261. .send_reset = dccp_v6_ctl_send_reset,
  262. .syn_ack_timeout = dccp_syn_ack_timeout,
  263. };
  264. static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
  265. {
  266. struct request_sock *req;
  267. struct dccp_request_sock *dreq;
  268. struct inet_request_sock *ireq;
  269. struct ipv6_pinfo *np = inet6_sk(sk);
  270. const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
  271. struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
  272. if (skb->protocol == htons(ETH_P_IP))
  273. return dccp_v4_conn_request(sk, skb);
  274. if (!ipv6_unicast_destination(skb))
  275. return 0; /* discard, don't send a reset here */
  276. if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) {
  277. __IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS);
  278. return 0;
  279. }
  280. if (dccp_bad_service_code(sk, service)) {
  281. dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
  282. goto drop;
  283. }
  284. /*
  285. * There are no SYN attacks on IPv6, yet...
  286. */
  287. dcb->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY;
  288. if (inet_csk_reqsk_queue_is_full(sk))
  289. goto drop;
  290. if (sk_acceptq_is_full(sk))
  291. goto drop;
  292. req = inet_reqsk_alloc(&dccp6_request_sock_ops, sk, true);
  293. if (req == NULL)
  294. goto drop;
  295. if (dccp_reqsk_init(req, dccp_sk(sk), skb))
  296. goto drop_and_free;
  297. dreq = dccp_rsk(req);
  298. if (dccp_parse_options(sk, dreq, skb))
  299. goto drop_and_free;
  300. ireq = inet_rsk(req);
  301. ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
  302. ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
  303. ireq->ireq_family = AF_INET6;
  304. ireq->ir_mark = inet_request_mark(sk, skb);
  305. if (security_inet_conn_request(sk, skb, req))
  306. goto drop_and_free;
  307. if (ipv6_opt_accepted(sk, skb, IP6CB(skb)) ||
  308. np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
  309. np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
  310. refcount_inc(&skb->users);
  311. ireq->pktopts = skb;
  312. }
  313. ireq->ir_iif = READ_ONCE(sk->sk_bound_dev_if);
  314. /* So that link locals have meaning */
  315. if (!ireq->ir_iif &&
  316. ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
  317. ireq->ir_iif = inet6_iif(skb);
  318. /*
  319. * Step 3: Process LISTEN state
  320. *
  321. * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
  322. *
  323. * Setting S.SWL/S.SWH to is deferred to dccp_create_openreq_child().
  324. */
  325. dreq->dreq_isr = dcb->dccpd_seq;
  326. dreq->dreq_gsr = dreq->dreq_isr;
  327. dreq->dreq_iss = dccp_v6_init_sequence(skb);
  328. dreq->dreq_gss = dreq->dreq_iss;
  329. dreq->dreq_service = service;
  330. if (dccp_v6_send_response(sk, req))
  331. goto drop_and_free;
  332. inet_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT);
  333. reqsk_put(req);
  334. return 0;
  335. drop_and_free:
  336. reqsk_free(req);
  337. drop:
  338. __DCCP_INC_STATS(DCCP_MIB_ATTEMPTFAILS);
  339. return -1;
  340. }
  341. static struct sock *dccp_v6_request_recv_sock(const struct sock *sk,
  342. struct sk_buff *skb,
  343. struct request_sock *req,
  344. struct dst_entry *dst,
  345. struct request_sock *req_unhash,
  346. bool *own_req)
  347. {
  348. struct inet_request_sock *ireq = inet_rsk(req);
  349. struct ipv6_pinfo *newnp;
  350. const struct ipv6_pinfo *np = inet6_sk(sk);
  351. struct ipv6_txoptions *opt;
  352. struct inet_sock *newinet;
  353. struct dccp6_sock *newdp6;
  354. struct sock *newsk;
  355. if (skb->protocol == htons(ETH_P_IP)) {
  356. /*
  357. * v6 mapped
  358. */
  359. newsk = dccp_v4_request_recv_sock(sk, skb, req, dst,
  360. req_unhash, own_req);
  361. if (newsk == NULL)
  362. return NULL;
  363. newdp6 = (struct dccp6_sock *)newsk;
  364. newinet = inet_sk(newsk);
  365. newinet->pinet6 = &newdp6->inet6;
  366. newnp = inet6_sk(newsk);
  367. memcpy(newnp, np, sizeof(struct ipv6_pinfo));
  368. newnp->saddr = newsk->sk_v6_rcv_saddr;
  369. inet_csk(newsk)->icsk_af_ops = &dccp_ipv6_mapped;
  370. newsk->sk_backlog_rcv = dccp_v4_do_rcv;
  371. newnp->pktoptions = NULL;
  372. newnp->opt = NULL;
  373. newnp->ipv6_mc_list = NULL;
  374. newnp->ipv6_ac_list = NULL;
  375. newnp->ipv6_fl_list = NULL;
  376. newnp->mcast_oif = inet_iif(skb);
  377. newnp->mcast_hops = ip_hdr(skb)->ttl;
  378. /*
  379. * No need to charge this sock to the relevant IPv6 refcnt debug socks count
  380. * here, dccp_create_openreq_child now does this for us, see the comment in
  381. * that function for the gory details. -acme
  382. */
  383. /* It is tricky place. Until this moment IPv4 tcp
  384. worked with IPv6 icsk.icsk_af_ops.
  385. Sync it now.
  386. */
  387. dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
  388. return newsk;
  389. }
  390. if (sk_acceptq_is_full(sk))
  391. goto out_overflow;
  392. if (!dst) {
  393. struct flowi6 fl6;
  394. dst = inet6_csk_route_req(sk, &fl6, req, IPPROTO_DCCP);
  395. if (!dst)
  396. goto out;
  397. }
  398. newsk = dccp_create_openreq_child(sk, req, skb);
  399. if (newsk == NULL)
  400. goto out_nonewsk;
  401. /*
  402. * No need to charge this sock to the relevant IPv6 refcnt debug socks
  403. * count here, dccp_create_openreq_child now does this for us, see the
  404. * comment in that function for the gory details. -acme
  405. */
  406. ip6_dst_store(newsk, dst, NULL, NULL);
  407. newsk->sk_route_caps = dst->dev->features & ~(NETIF_F_IP_CSUM |
  408. NETIF_F_TSO);
  409. newdp6 = (struct dccp6_sock *)newsk;
  410. newinet = inet_sk(newsk);
  411. newinet->pinet6 = &newdp6->inet6;
  412. newnp = inet6_sk(newsk);
  413. memcpy(newnp, np, sizeof(struct ipv6_pinfo));
  414. newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
  415. newnp->saddr = ireq->ir_v6_loc_addr;
  416. newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
  417. newsk->sk_bound_dev_if = ireq->ir_iif;
  418. /* Now IPv6 options...
  419. First: no IPv4 options.
  420. */
  421. newinet->inet_opt = NULL;
  422. /* Clone RX bits */
  423. newnp->rxopt.all = np->rxopt.all;
  424. newnp->ipv6_mc_list = NULL;
  425. newnp->ipv6_ac_list = NULL;
  426. newnp->ipv6_fl_list = NULL;
  427. newnp->pktoptions = NULL;
  428. newnp->opt = NULL;
  429. newnp->mcast_oif = inet6_iif(skb);
  430. newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
  431. /*
  432. * Clone native IPv6 options from listening socket (if any)
  433. *
  434. * Yes, keeping reference count would be much more clever, but we make
  435. * one more one thing there: reattach optmem to newsk.
  436. */
  437. opt = ireq->ipv6_opt;
  438. if (!opt)
  439. opt = rcu_dereference(np->opt);
  440. if (opt) {
  441. opt = ipv6_dup_options(newsk, opt);
  442. RCU_INIT_POINTER(newnp->opt, opt);
  443. }
  444. inet_csk(newsk)->icsk_ext_hdr_len = 0;
  445. if (opt)
  446. inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen +
  447. opt->opt_flen;
  448. dccp_sync_mss(newsk, dst_mtu(dst));
  449. newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
  450. newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
  451. if (__inet_inherit_port(sk, newsk) < 0) {
  452. inet_csk_prepare_forced_close(newsk);
  453. dccp_done(newsk);
  454. goto out;
  455. }
  456. *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash), NULL);
  457. /* Clone pktoptions received with SYN, if we own the req */
  458. if (*own_req && ireq->pktopts) {
  459. newnp->pktoptions = skb_clone_and_charge_r(ireq->pktopts, newsk);
  460. consume_skb(ireq->pktopts);
  461. ireq->pktopts = NULL;
  462. }
  463. return newsk;
  464. out_overflow:
  465. __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
  466. out_nonewsk:
  467. dst_release(dst);
  468. out:
  469. __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENDROPS);
  470. return NULL;
  471. }
  472. /* The socket must have it's spinlock held when we get
  473. * here.
  474. *
  475. * We have a potential double-lock case here, so even when
  476. * doing backlog processing we use the BH locking scheme.
  477. * This is because we cannot sleep with the original spinlock
  478. * held.
  479. */
  480. static int dccp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
  481. {
  482. struct ipv6_pinfo *np = inet6_sk(sk);
  483. struct sk_buff *opt_skb = NULL;
  484. /* Imagine: socket is IPv6. IPv4 packet arrives,
  485. goes to IPv4 receive handler and backlogged.
  486. From backlog it always goes here. Kerboom...
  487. Fortunately, dccp_rcv_established and rcv_established
  488. handle them correctly, but it is not case with
  489. dccp_v6_hnd_req and dccp_v6_ctl_send_reset(). --ANK
  490. */
  491. if (skb->protocol == htons(ETH_P_IP))
  492. return dccp_v4_do_rcv(sk, skb);
  493. if (sk_filter(sk, skb))
  494. goto discard;
  495. /*
  496. * socket locking is here for SMP purposes as backlog rcv is currently
  497. * called with bh processing disabled.
  498. */
  499. /* Do Stevens' IPV6_PKTOPTIONS.
  500. Yes, guys, it is the only place in our code, where we
  501. may make it not affecting IPv4.
  502. The rest of code is protocol independent,
  503. and I do not like idea to uglify IPv4.
  504. Actually, all the idea behind IPV6_PKTOPTIONS
  505. looks not very well thought. For now we latch
  506. options, received in the last packet, enqueued
  507. by tcp. Feel free to propose better solution.
  508. --ANK (980728)
  509. */
  510. if (np->rxopt.all)
  511. opt_skb = skb_clone_and_charge_r(skb, sk);
  512. if (sk->sk_state == DCCP_OPEN) { /* Fast path */
  513. if (dccp_rcv_established(sk, skb, dccp_hdr(skb), skb->len))
  514. goto reset;
  515. if (opt_skb)
  516. goto ipv6_pktoptions;
  517. return 0;
  518. }
  519. /*
  520. * Step 3: Process LISTEN state
  521. * If S.state == LISTEN,
  522. * If P.type == Request or P contains a valid Init Cookie option,
  523. * (* Must scan the packet's options to check for Init
  524. * Cookies. Only Init Cookies are processed here,
  525. * however; other options are processed in Step 8. This
  526. * scan need only be performed if the endpoint uses Init
  527. * Cookies *)
  528. * (* Generate a new socket and switch to that socket *)
  529. * Set S := new socket for this port pair
  530. * S.state = RESPOND
  531. * Choose S.ISS (initial seqno) or set from Init Cookies
  532. * Initialize S.GAR := S.ISS
  533. * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookies
  534. * Continue with S.state == RESPOND
  535. * (* A Response packet will be generated in Step 11 *)
  536. * Otherwise,
  537. * Generate Reset(No Connection) unless P.type == Reset
  538. * Drop packet and return
  539. *
  540. * NOTE: the check for the packet types is done in
  541. * dccp_rcv_state_process
  542. */
  543. if (dccp_rcv_state_process(sk, skb, dccp_hdr(skb), skb->len))
  544. goto reset;
  545. if (opt_skb)
  546. goto ipv6_pktoptions;
  547. return 0;
  548. reset:
  549. dccp_v6_ctl_send_reset(sk, skb);
  550. discard:
  551. if (opt_skb != NULL)
  552. __kfree_skb(opt_skb);
  553. kfree_skb(skb);
  554. return 0;
  555. /* Handling IPV6_PKTOPTIONS skb the similar
  556. * way it's done for net/ipv6/tcp_ipv6.c
  557. */
  558. ipv6_pktoptions:
  559. if (!((1 << sk->sk_state) & (DCCPF_CLOSED | DCCPF_LISTEN))) {
  560. if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
  561. np->mcast_oif = inet6_iif(opt_skb);
  562. if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
  563. np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
  564. if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
  565. np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
  566. if (np->repflow)
  567. np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
  568. if (ipv6_opt_accepted(sk, opt_skb,
  569. &DCCP_SKB_CB(opt_skb)->header.h6)) {
  570. memmove(IP6CB(opt_skb),
  571. &DCCP_SKB_CB(opt_skb)->header.h6,
  572. sizeof(struct inet6_skb_parm));
  573. opt_skb = xchg(&np->pktoptions, opt_skb);
  574. } else {
  575. __kfree_skb(opt_skb);
  576. opt_skb = xchg(&np->pktoptions, NULL);
  577. }
  578. }
  579. kfree_skb(opt_skb);
  580. return 0;
  581. }
  582. static int dccp_v6_rcv(struct sk_buff *skb)
  583. {
  584. const struct dccp_hdr *dh;
  585. bool refcounted;
  586. struct sock *sk;
  587. int min_cov;
  588. /* Step 1: Check header basics */
  589. if (dccp_invalid_packet(skb))
  590. goto discard_it;
  591. /* Step 1: If header checksum is incorrect, drop packet and return. */
  592. if (dccp_v6_csum_finish(skb, &ipv6_hdr(skb)->saddr,
  593. &ipv6_hdr(skb)->daddr)) {
  594. DCCP_WARN("dropped packet with invalid checksum\n");
  595. goto discard_it;
  596. }
  597. dh = dccp_hdr(skb);
  598. DCCP_SKB_CB(skb)->dccpd_seq = dccp_hdr_seq(dh);
  599. DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type;
  600. if (dccp_packet_without_ack(skb))
  601. DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ;
  602. else
  603. DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb);
  604. lookup:
  605. sk = __inet6_lookup_skb(&dccp_hashinfo, skb, __dccp_hdr_len(dh),
  606. dh->dccph_sport, dh->dccph_dport,
  607. inet6_iif(skb), 0, &refcounted);
  608. if (!sk) {
  609. dccp_pr_debug("failed to look up flow ID in table and "
  610. "get corresponding socket\n");
  611. goto no_dccp_socket;
  612. }
  613. /*
  614. * Step 2:
  615. * ... or S.state == TIMEWAIT,
  616. * Generate Reset(No Connection) unless P.type == Reset
  617. * Drop packet and return
  618. */
  619. if (sk->sk_state == DCCP_TIME_WAIT) {
  620. dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: do_time_wait\n");
  621. inet_twsk_put(inet_twsk(sk));
  622. goto no_dccp_socket;
  623. }
  624. if (sk->sk_state == DCCP_NEW_SYN_RECV) {
  625. struct request_sock *req = inet_reqsk(sk);
  626. struct sock *nsk;
  627. sk = req->rsk_listener;
  628. if (unlikely(sk->sk_state != DCCP_LISTEN)) {
  629. inet_csk_reqsk_queue_drop_and_put(sk, req);
  630. goto lookup;
  631. }
  632. sock_hold(sk);
  633. refcounted = true;
  634. nsk = dccp_check_req(sk, skb, req);
  635. if (!nsk) {
  636. reqsk_put(req);
  637. goto discard_and_relse;
  638. }
  639. if (nsk == sk) {
  640. reqsk_put(req);
  641. } else if (dccp_child_process(sk, nsk, skb)) {
  642. dccp_v6_ctl_send_reset(sk, skb);
  643. goto discard_and_relse;
  644. } else {
  645. sock_put(sk);
  646. return 0;
  647. }
  648. }
  649. /*
  650. * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage
  651. * o if MinCsCov = 0, only packets with CsCov = 0 are accepted
  652. * o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov
  653. */
  654. min_cov = dccp_sk(sk)->dccps_pcrlen;
  655. if (dh->dccph_cscov && (min_cov == 0 || dh->dccph_cscov < min_cov)) {
  656. dccp_pr_debug("Packet CsCov %d does not satisfy MinCsCov %d\n",
  657. dh->dccph_cscov, min_cov);
  658. /* FIXME: send Data Dropped option (see also dccp_v4_rcv) */
  659. goto discard_and_relse;
  660. }
  661. if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
  662. goto discard_and_relse;
  663. nf_reset_ct(skb);
  664. return __sk_receive_skb(sk, skb, 1, dh->dccph_doff * 4,
  665. refcounted) ? -1 : 0;
  666. no_dccp_socket:
  667. if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
  668. goto discard_it;
  669. /*
  670. * Step 2:
  671. * If no socket ...
  672. * Generate Reset(No Connection) unless P.type == Reset
  673. * Drop packet and return
  674. */
  675. if (dh->dccph_type != DCCP_PKT_RESET) {
  676. DCCP_SKB_CB(skb)->dccpd_reset_code =
  677. DCCP_RESET_CODE_NO_CONNECTION;
  678. dccp_v6_ctl_send_reset(sk, skb);
  679. }
  680. discard_it:
  681. kfree_skb(skb);
  682. return 0;
  683. discard_and_relse:
  684. if (refcounted)
  685. sock_put(sk);
  686. goto discard_it;
  687. }
  688. static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
  689. int addr_len)
  690. {
  691. struct sockaddr_in6 *usin = (struct sockaddr_in6 *)uaddr;
  692. struct inet_connection_sock *icsk = inet_csk(sk);
  693. struct inet_sock *inet = inet_sk(sk);
  694. struct ipv6_pinfo *np = inet6_sk(sk);
  695. struct dccp_sock *dp = dccp_sk(sk);
  696. struct in6_addr *saddr = NULL, *final_p, final;
  697. struct ipv6_txoptions *opt;
  698. struct flowi6 fl6;
  699. struct dst_entry *dst;
  700. int addr_type;
  701. int err;
  702. dp->dccps_role = DCCP_ROLE_CLIENT;
  703. if (addr_len < SIN6_LEN_RFC2133)
  704. return -EINVAL;
  705. if (usin->sin6_family != AF_INET6)
  706. return -EAFNOSUPPORT;
  707. memset(&fl6, 0, sizeof(fl6));
  708. if (np->sndflow) {
  709. fl6.flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
  710. IP6_ECN_flow_init(fl6.flowlabel);
  711. if (fl6.flowlabel & IPV6_FLOWLABEL_MASK) {
  712. struct ip6_flowlabel *flowlabel;
  713. flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
  714. if (IS_ERR(flowlabel))
  715. return -EINVAL;
  716. fl6_sock_release(flowlabel);
  717. }
  718. }
  719. /*
  720. * connect() to INADDR_ANY means loopback (BSD'ism).
  721. */
  722. if (ipv6_addr_any(&usin->sin6_addr))
  723. usin->sin6_addr.s6_addr[15] = 1;
  724. addr_type = ipv6_addr_type(&usin->sin6_addr);
  725. if (addr_type & IPV6_ADDR_MULTICAST)
  726. return -ENETUNREACH;
  727. if (addr_type & IPV6_ADDR_LINKLOCAL) {
  728. if (addr_len >= sizeof(struct sockaddr_in6) &&
  729. usin->sin6_scope_id) {
  730. /* If interface is set while binding, indices
  731. * must coincide.
  732. */
  733. if (sk->sk_bound_dev_if &&
  734. sk->sk_bound_dev_if != usin->sin6_scope_id)
  735. return -EINVAL;
  736. sk->sk_bound_dev_if = usin->sin6_scope_id;
  737. }
  738. /* Connect to link-local address requires an interface */
  739. if (!sk->sk_bound_dev_if)
  740. return -EINVAL;
  741. }
  742. sk->sk_v6_daddr = usin->sin6_addr;
  743. np->flow_label = fl6.flowlabel;
  744. /*
  745. * DCCP over IPv4
  746. */
  747. if (addr_type == IPV6_ADDR_MAPPED) {
  748. u32 exthdrlen = icsk->icsk_ext_hdr_len;
  749. struct sockaddr_in sin;
  750. SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
  751. if (ipv6_only_sock(sk))
  752. return -ENETUNREACH;
  753. sin.sin_family = AF_INET;
  754. sin.sin_port = usin->sin6_port;
  755. sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
  756. icsk->icsk_af_ops = &dccp_ipv6_mapped;
  757. sk->sk_backlog_rcv = dccp_v4_do_rcv;
  758. err = dccp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
  759. if (err) {
  760. icsk->icsk_ext_hdr_len = exthdrlen;
  761. icsk->icsk_af_ops = &dccp_ipv6_af_ops;
  762. sk->sk_backlog_rcv = dccp_v6_do_rcv;
  763. goto failure;
  764. }
  765. np->saddr = sk->sk_v6_rcv_saddr;
  766. return err;
  767. }
  768. if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
  769. saddr = &sk->sk_v6_rcv_saddr;
  770. fl6.flowi6_proto = IPPROTO_DCCP;
  771. fl6.daddr = sk->sk_v6_daddr;
  772. fl6.saddr = saddr ? *saddr : np->saddr;
  773. fl6.flowi6_oif = sk->sk_bound_dev_if;
  774. fl6.fl6_dport = usin->sin6_port;
  775. fl6.fl6_sport = inet->inet_sport;
  776. security_sk_classify_flow(sk, flowi6_to_flowi_common(&fl6));
  777. opt = rcu_dereference_protected(np->opt, lockdep_sock_is_held(sk));
  778. final_p = fl6_update_dst(&fl6, opt, &final);
  779. dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
  780. if (IS_ERR(dst)) {
  781. err = PTR_ERR(dst);
  782. goto failure;
  783. }
  784. if (saddr == NULL) {
  785. saddr = &fl6.saddr;
  786. err = inet_bhash2_update_saddr(sk, saddr, AF_INET6);
  787. if (err)
  788. goto failure;
  789. }
  790. /* set the source address */
  791. np->saddr = *saddr;
  792. inet->inet_rcv_saddr = LOOPBACK4_IPV6;
  793. ip6_dst_store(sk, dst, NULL, NULL);
  794. icsk->icsk_ext_hdr_len = 0;
  795. if (opt)
  796. icsk->icsk_ext_hdr_len = opt->opt_flen + opt->opt_nflen;
  797. inet->inet_dport = usin->sin6_port;
  798. dccp_set_state(sk, DCCP_REQUESTING);
  799. err = inet6_hash_connect(&dccp_death_row, sk);
  800. if (err)
  801. goto late_failure;
  802. dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,
  803. sk->sk_v6_daddr.s6_addr32,
  804. inet->inet_sport,
  805. inet->inet_dport);
  806. err = dccp_connect(sk);
  807. if (err)
  808. goto late_failure;
  809. return 0;
  810. late_failure:
  811. dccp_set_state(sk, DCCP_CLOSED);
  812. inet_bhash2_reset_saddr(sk);
  813. __sk_dst_reset(sk);
  814. failure:
  815. inet->inet_dport = 0;
  816. sk->sk_route_caps = 0;
  817. return err;
  818. }
  819. static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops = {
  820. .queue_xmit = inet6_csk_xmit,
  821. .send_check = dccp_v6_send_check,
  822. .rebuild_header = inet6_sk_rebuild_header,
  823. .conn_request = dccp_v6_conn_request,
  824. .syn_recv_sock = dccp_v6_request_recv_sock,
  825. .net_header_len = sizeof(struct ipv6hdr),
  826. .setsockopt = ipv6_setsockopt,
  827. .getsockopt = ipv6_getsockopt,
  828. .addr2sockaddr = inet6_csk_addr2sockaddr,
  829. .sockaddr_len = sizeof(struct sockaddr_in6),
  830. };
  831. /*
  832. * DCCP over IPv4 via INET6 API
  833. */
  834. static const struct inet_connection_sock_af_ops dccp_ipv6_mapped = {
  835. .queue_xmit = ip_queue_xmit,
  836. .send_check = dccp_v4_send_check,
  837. .rebuild_header = inet_sk_rebuild_header,
  838. .conn_request = dccp_v6_conn_request,
  839. .syn_recv_sock = dccp_v6_request_recv_sock,
  840. .net_header_len = sizeof(struct iphdr),
  841. .setsockopt = ipv6_setsockopt,
  842. .getsockopt = ipv6_getsockopt,
  843. .addr2sockaddr = inet6_csk_addr2sockaddr,
  844. .sockaddr_len = sizeof(struct sockaddr_in6),
  845. };
  846. static void dccp_v6_sk_destruct(struct sock *sk)
  847. {
  848. dccp_destruct_common(sk);
  849. inet6_sock_destruct(sk);
  850. }
  851. /* NOTE: A lot of things set to zero explicitly by call to
  852. * sk_alloc() so need not be done here.
  853. */
  854. static int dccp_v6_init_sock(struct sock *sk)
  855. {
  856. static __u8 dccp_v6_ctl_sock_initialized;
  857. int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized);
  858. if (err == 0) {
  859. if (unlikely(!dccp_v6_ctl_sock_initialized))
  860. dccp_v6_ctl_sock_initialized = 1;
  861. inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops;
  862. sk->sk_destruct = dccp_v6_sk_destruct;
  863. }
  864. return err;
  865. }
  866. static struct timewait_sock_ops dccp6_timewait_sock_ops = {
  867. .twsk_obj_size = sizeof(struct dccp6_timewait_sock),
  868. };
  869. static struct proto dccp_v6_prot = {
  870. .name = "DCCPv6",
  871. .owner = THIS_MODULE,
  872. .close = dccp_close,
  873. .connect = dccp_v6_connect,
  874. .disconnect = dccp_disconnect,
  875. .ioctl = dccp_ioctl,
  876. .init = dccp_v6_init_sock,
  877. .setsockopt = dccp_setsockopt,
  878. .getsockopt = dccp_getsockopt,
  879. .sendmsg = dccp_sendmsg,
  880. .recvmsg = dccp_recvmsg,
  881. .backlog_rcv = dccp_v6_do_rcv,
  882. .hash = inet6_hash,
  883. .unhash = inet_unhash,
  884. .accept = inet_csk_accept,
  885. .get_port = inet_csk_get_port,
  886. .shutdown = dccp_shutdown,
  887. .destroy = dccp_destroy_sock,
  888. .orphan_count = &dccp_orphan_count,
  889. .max_header = MAX_DCCP_HEADER,
  890. .obj_size = sizeof(struct dccp6_sock),
  891. .slab_flags = SLAB_TYPESAFE_BY_RCU,
  892. .rsk_prot = &dccp6_request_sock_ops,
  893. .twsk_prot = &dccp6_timewait_sock_ops,
  894. .h.hashinfo = &dccp_hashinfo,
  895. };
  896. static const struct inet6_protocol dccp_v6_protocol = {
  897. .handler = dccp_v6_rcv,
  898. .err_handler = dccp_v6_err,
  899. .flags = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
  900. };
  901. static const struct proto_ops inet6_dccp_ops = {
  902. .family = PF_INET6,
  903. .owner = THIS_MODULE,
  904. .release = inet6_release,
  905. .bind = inet6_bind,
  906. .connect = inet_stream_connect,
  907. .socketpair = sock_no_socketpair,
  908. .accept = inet_accept,
  909. .getname = inet6_getname,
  910. .poll = dccp_poll,
  911. .ioctl = inet6_ioctl,
  912. .gettstamp = sock_gettstamp,
  913. .listen = inet_dccp_listen,
  914. .shutdown = inet_shutdown,
  915. .setsockopt = sock_common_setsockopt,
  916. .getsockopt = sock_common_getsockopt,
  917. .sendmsg = inet_sendmsg,
  918. .recvmsg = sock_common_recvmsg,
  919. .mmap = sock_no_mmap,
  920. .sendpage = sock_no_sendpage,
  921. #ifdef CONFIG_COMPAT
  922. .compat_ioctl = inet6_compat_ioctl,
  923. #endif
  924. };
  925. static struct inet_protosw dccp_v6_protosw = {
  926. .type = SOCK_DCCP,
  927. .protocol = IPPROTO_DCCP,
  928. .prot = &dccp_v6_prot,
  929. .ops = &inet6_dccp_ops,
  930. .flags = INET_PROTOSW_ICSK,
  931. };
  932. static int __net_init dccp_v6_init_net(struct net *net)
  933. {
  934. struct dccp_v6_pernet *pn = net_generic(net, dccp_v6_pernet_id);
  935. if (dccp_hashinfo.bhash == NULL)
  936. return -ESOCKTNOSUPPORT;
  937. return inet_ctl_sock_create(&pn->v6_ctl_sk, PF_INET6,
  938. SOCK_DCCP, IPPROTO_DCCP, net);
  939. }
  940. static void __net_exit dccp_v6_exit_net(struct net *net)
  941. {
  942. struct dccp_v6_pernet *pn = net_generic(net, dccp_v6_pernet_id);
  943. inet_ctl_sock_destroy(pn->v6_ctl_sk);
  944. }
  945. static void __net_exit dccp_v6_exit_batch(struct list_head *net_exit_list)
  946. {
  947. inet_twsk_purge(&dccp_hashinfo, AF_INET6);
  948. }
  949. static struct pernet_operations dccp_v6_ops = {
  950. .init = dccp_v6_init_net,
  951. .exit = dccp_v6_exit_net,
  952. .exit_batch = dccp_v6_exit_batch,
  953. .id = &dccp_v6_pernet_id,
  954. .size = sizeof(struct dccp_v6_pernet),
  955. };
  956. static int __init dccp_v6_init(void)
  957. {
  958. int err = proto_register(&dccp_v6_prot, 1);
  959. if (err)
  960. goto out;
  961. inet6_register_protosw(&dccp_v6_protosw);
  962. err = register_pernet_subsys(&dccp_v6_ops);
  963. if (err)
  964. goto out_destroy_ctl_sock;
  965. err = inet6_add_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
  966. if (err)
  967. goto out_unregister_proto;
  968. out:
  969. return err;
  970. out_unregister_proto:
  971. unregister_pernet_subsys(&dccp_v6_ops);
  972. out_destroy_ctl_sock:
  973. inet6_unregister_protosw(&dccp_v6_protosw);
  974. proto_unregister(&dccp_v6_prot);
  975. goto out;
  976. }
  977. static void __exit dccp_v6_exit(void)
  978. {
  979. inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
  980. unregister_pernet_subsys(&dccp_v6_ops);
  981. inet6_unregister_protosw(&dccp_v6_protosw);
  982. proto_unregister(&dccp_v6_prot);
  983. }
  984. module_init(dccp_v6_init);
  985. module_exit(dccp_v6_exit);
  986. /*
  987. * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33)
  988. * values directly, Also cover the case where the protocol is not specified,
  989. * i.e. net-pf-PF_INET6-proto-0-type-SOCK_DCCP
  990. */
  991. MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 33, 6);
  992. MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 0, 6);
  993. MODULE_LICENSE("GPL");
  994. MODULE_AUTHOR("Arnaldo Carvalho de Melo <[email protected]>");
  995. MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol");