projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[DCCPv6]: Choose a genuine initial sequence number
[deliverable/linux.git] / net / dccp / ipv6.c
1 /*
2 * DCCP over IPv6
3 * Linux INET6 implementation
4 *
5 * Based on net/dccp6/ipv6.c
6 *
7 * Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
13 */
14
15 #include <linux/module.h>
16 #include <linux/random.h>
17 #include <linux/xfrm.h>
18
19 #include <net/addrconf.h>
20 #include <net/inet_common.h>
21 #include <net/inet_hashtables.h>
22 #include <net/inet_sock.h>
23 #include <net/inet6_connection_sock.h>
24 #include <net/inet6_hashtables.h>
25 #include <net/ip6_route.h>
26 #include <net/ipv6.h>
27 #include <net/protocol.h>
28 #include <net/transp_v6.h>
29 #include <net/ip6_checksum.h>
30 #include <net/xfrm.h>
31
32 #include "dccp.h"
33 #include "ipv6.h"
34 #include "feat.h"
35
36 /* Socket used for sending RSTs and ACKs */
37 static struct socket *dccp_v6_ctl_socket;
38
39 static struct inet_connection_sock_af_ops dccp_ipv6_mapped;
40 static struct inet_connection_sock_af_ops dccp_ipv6_af_ops;
41
42 static int dccp_v6_get_port(struct sock *sk, unsigned short snum)
43 {
44 return inet_csk_get_port(&dccp_hashinfo, sk, snum,
45 inet6_csk_bind_conflict);
46 }
47
48 static void dccp_v6_hash(struct sock *sk)
49 {
50 if (sk->sk_state != DCCP_CLOSED) {
51 if (inet_csk(sk)->icsk_af_ops == &dccp_ipv6_mapped) {
52 dccp_hash(sk);
53 return;
54 }
55 local_bh_disable();
56 __inet6_hash(&dccp_hashinfo, sk);
57 local_bh_enable();
58 }
59 }
60
61 /* add pseudo-header to DCCP checksum stored in skb->csum */
62 static inline u16 dccp_v6_csum_finish(struct sk_buff *skb,
63 struct in6_addr *saddr,
64 struct in6_addr *daddr)
65 {
66 return csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_DCCP, skb->csum);
67 }
68
69 static inline void dccp_v6_send_check(struct sock *sk, int unused_value,
70 struct sk_buff *skb)
71 {
72 struct ipv6_pinfo *np = inet6_sk(sk);
73 struct dccp_hdr *dh = dccp_hdr(skb);
74
75 dccp_csum_outgoing(skb);
76 dh->dccph_checksum = dccp_v6_csum_finish(skb, &np->saddr, &np->daddr);
77 }
78
79 static inline __u32 secure_dccpv6_sequence_number(__u32 *saddr, __u32 *daddr,
80 __u16 sport, __u16 dport )
81 {
82 return secure_tcpv6_sequence_number(saddr, daddr, sport, dport);
83 }
84
85 static inline __u32 dccp_v6_init_sequence(struct sk_buff *skb)
86 {
87 return secure_dccpv6_sequence_number(skb->nh.ipv6h->daddr.s6_addr32,
88 skb->nh.ipv6h->saddr.s6_addr32,
89 dccp_hdr(skb)->dccph_dport,
90 dccp_hdr(skb)->dccph_sport );
91
92 }
93
94 static void dccp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
95 int type, int code, int offset, __be32 info)
96 {
97 struct ipv6hdr *hdr = (struct ipv6hdr *)skb->data;
98 const struct dccp_hdr *dh = (struct dccp_hdr *)(skb->data + offset);
99 struct ipv6_pinfo *np;
100 struct sock *sk;
101 int err;
102 __u64 seq;
103
104 sk = inet6_lookup(&dccp_hashinfo, &hdr->daddr, dh->dccph_dport,
105 &hdr->saddr, dh->dccph_sport, inet6_iif(skb));
106
107 if (sk == NULL) {
108 ICMP6_INC_STATS_BH(__in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
109 return;
110 }
111
112 if (sk->sk_state == DCCP_TIME_WAIT) {
113 inet_twsk_put(inet_twsk(sk));
114 return;
115 }
116
117 bh_lock_sock(sk);
118 if (sock_owned_by_user(sk))
119 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
120
121 if (sk->sk_state == DCCP_CLOSED)
122 goto out;
123
124 np = inet6_sk(sk);
125
126 if (type == ICMPV6_PKT_TOOBIG) {
127 struct dst_entry *dst = NULL;
128
129 if (sock_owned_by_user(sk))
130 goto out;
131 if ((1 << sk->sk_state) & (DCCPF_LISTEN | DCCPF_CLOSED))
132 goto out;
133
134 /* icmp should have updated the destination cache entry */
135 dst = __sk_dst_check(sk, np->dst_cookie);
136 if (dst == NULL) {
137 struct inet_sock *inet = inet_sk(sk);
138 struct flowi fl;
139
140 /* BUGGG_FUTURE: Again, it is not clear how
141 to handle rthdr case. Ignore this complexity
142 for now.
143 */
144 memset(&fl, 0, sizeof(fl));
145 fl.proto = IPPROTO_DCCP;
146 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
147 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
148 fl.oif = sk->sk_bound_dev_if;
149 fl.fl_ip_dport = inet->dport;
150 fl.fl_ip_sport = inet->sport;
151 security_sk_classify_flow(sk, &fl);
152
153 err = ip6_dst_lookup(sk, &dst, &fl);
154 if (err) {
155 sk->sk_err_soft = -err;
156 goto out;
157 }
158
159 err = xfrm_lookup(&dst, &fl, sk, 0);
160 if (err < 0) {
161 sk->sk_err_soft = -err;
162 goto out;
163 }
164 } else
165 dst_hold(dst);
166
167 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
168 dccp_sync_mss(sk, dst_mtu(dst));
169 } /* else let the usual retransmit timer handle it */
170 dst_release(dst);
171 goto out;
172 }
173
174 icmpv6_err_convert(type, code, &err);
175
176 seq = DCCP_SKB_CB(skb)->dccpd_seq;
177 /* Might be for an request_sock */
178 switch (sk->sk_state) {
179 struct request_sock *req, **prev;
180 case DCCP_LISTEN:
181 if (sock_owned_by_user(sk))
182 goto out;
183
184 req = inet6_csk_search_req(sk, &prev, dh->dccph_dport,
185 &hdr->daddr, &hdr->saddr,
186 inet6_iif(skb));
187 if (req == NULL)
188 goto out;
189
190 /*
191 * ICMPs are not backlogged, hence we cannot get an established
192 * socket here.
193 */
194 BUG_TRAP(req->sk == NULL);
195
196 if (seq != dccp_rsk(req)->dreq_iss) {
197 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
198 goto out;
199 }
200
201 inet_csk_reqsk_queue_drop(sk, req, prev);
202 goto out;
203
204 case DCCP_REQUESTING:
205 case DCCP_RESPOND: /* Cannot happen.
206 It can, it SYNs are crossed. --ANK */
207 if (!sock_owned_by_user(sk)) {
208 DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS);
209 sk->sk_err = err;
210 /*
211 * Wake people up to see the error
212 * (see connect in sock.c)
213 */
214 sk->sk_error_report(sk);
215 dccp_done(sk);
216 } else
217 sk->sk_err_soft = err;
218 goto out;
219 }
220
221 if (!sock_owned_by_user(sk) && np->recverr) {
222 sk->sk_err = err;
223 sk->sk_error_report(sk);
224 } else
225 sk->sk_err_soft = err;
226
227 out:
228 bh_unlock_sock(sk);
229 sock_put(sk);
230 }
231
232
233 static int dccp_v6_send_response(struct sock *sk, struct request_sock *req,
234 struct dst_entry *dst)
235 {
236 struct inet6_request_sock *ireq6 = inet6_rsk(req);
237 struct ipv6_pinfo *np = inet6_sk(sk);
238 struct sk_buff *skb;
239 struct ipv6_txoptions *opt = NULL;
240 struct in6_addr *final_p = NULL, final;
241 struct flowi fl;
242 int err = -1;
243
244 memset(&fl, 0, sizeof(fl));
245 fl.proto = IPPROTO_DCCP;
246 ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr);
247 ipv6_addr_copy(&fl.fl6_src, &ireq6->loc_addr);
248 fl.fl6_flowlabel = 0;
249 fl.oif = ireq6->iif;
250 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
251 fl.fl_ip_sport = inet_sk(sk)->sport;
252 security_req_classify_flow(req, &fl);
253
254 if (dst == NULL) {
255 opt = np->opt;
256 if (opt == NULL &&
257 np->rxopt.bits.osrcrt == 2 &&
258 ireq6->pktopts) {
259 struct sk_buff *pktopts = ireq6->pktopts;
260 struct inet6_skb_parm *rxopt = IP6CB(pktopts);
261
262 if (rxopt->srcrt)
263 opt = ipv6_invert_rthdr(sk,
264 (struct ipv6_rt_hdr *)(pktopts->nh.raw +
265 rxopt->srcrt));
266 }
267
268 if (opt != NULL && opt->srcrt != NULL) {
269 const struct rt0_hdr *rt0 = (struct rt0_hdr *)opt->srcrt;
270
271 ipv6_addr_copy(&final, &fl.fl6_dst);
272 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
273 final_p = &final;
274 }
275
276 err = ip6_dst_lookup(sk, &dst, &fl);
277 if (err)
278 goto done;
279
280 if (final_p)
281 ipv6_addr_copy(&fl.fl6_dst, final_p);
282
283 err = xfrm_lookup(&dst, &fl, sk, 0);
284 if (err < 0)
285 goto done;
286 }
287
288 skb = dccp_make_response(sk, dst, req);
289 if (skb != NULL) {
290 struct dccp_hdr *dh = dccp_hdr(skb);
291
292 dh->dccph_checksum = dccp_v6_csum_finish(skb,
293 &ireq6->loc_addr,
294 &ireq6->rmt_addr);
295 ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr);
296 err = ip6_xmit(sk, skb, &fl, opt, 0);
297 if (err == NET_XMIT_CN)
298 err = 0;
299 }
300
301 done:
302 if (opt != NULL && opt != np->opt)
303 sock_kfree_s(sk, opt, opt->tot_len);
304 dst_release(dst);
305 return err;
306 }
307
308 static void dccp_v6_reqsk_destructor(struct request_sock *req)
309 {
310 if (inet6_rsk(req)->pktopts != NULL)
311 kfree_skb(inet6_rsk(req)->pktopts);
312 }
313
314 static void dccp_v6_ctl_send_reset(struct sk_buff *rxskb)
315 {
316 struct dccp_hdr *rxdh = dccp_hdr(rxskb), *dh;
317 const u32 dccp_hdr_reset_len = sizeof(struct dccp_hdr) +
318 sizeof(struct dccp_hdr_ext) +
319 sizeof(struct dccp_hdr_reset);
320 struct sk_buff *skb;
321 struct flowi fl;
322 u64 seqno;
323
324 if (rxdh->dccph_type == DCCP_PKT_RESET)
325 return;
326
327 if (!ipv6_unicast_destination(rxskb))
328 return;
329
330 skb = alloc_skb(dccp_v6_ctl_socket->sk->sk_prot->max_header,
331 GFP_ATOMIC);
332 if (skb == NULL)
333 return;
334
335 skb_reserve(skb, dccp_v6_ctl_socket->sk->sk_prot->max_header);
336
337 dh = dccp_zeroed_hdr(skb, dccp_hdr_reset_len);
338
339 /* Swap the send and the receive. */
340 dh->dccph_type = DCCP_PKT_RESET;
341 dh->dccph_sport = rxdh->dccph_dport;
342 dh->dccph_dport = rxdh->dccph_sport;
343 dh->dccph_doff = dccp_hdr_reset_len / 4;
344 dh->dccph_x = 1;
345 dccp_hdr_reset(skb)->dccph_reset_code =
346 DCCP_SKB_CB(rxskb)->dccpd_reset_code;
347
348 /* See "8.3.1. Abnormal Termination" in RFC 4340 */
349 seqno = 0;
350 if (DCCP_SKB_CB(rxskb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
351 dccp_set_seqno(&seqno, DCCP_SKB_CB(rxskb)->dccpd_ack_seq + 1);
352
353 dccp_hdr_set_seq(dh, seqno);
354 dccp_hdr_set_ack(dccp_hdr_ack_bits(skb),
355 DCCP_SKB_CB(rxskb)->dccpd_seq);
356
357 dccp_csum_outgoing(skb);
358 dh->dccph_checksum = dccp_v6_csum_finish(skb, &rxskb->nh.ipv6h->saddr,
359 &rxskb->nh.ipv6h->daddr);
360
361 memset(&fl, 0, sizeof(fl));
362 ipv6_addr_copy(&fl.fl6_dst, &rxskb->nh.ipv6h->saddr);
363 ipv6_addr_copy(&fl.fl6_src, &rxskb->nh.ipv6h->daddr);
364
365 fl.proto = IPPROTO_DCCP;
366 fl.oif = inet6_iif(rxskb);
367 fl.fl_ip_dport = dh->dccph_dport;
368 fl.fl_ip_sport = dh->dccph_sport;
369 security_skb_classify_flow(rxskb, &fl);
370
371 /* sk = NULL, but it is safe for now. RST socket required. */
372 if (!ip6_dst_lookup(NULL, &skb->dst, &fl)) {
373 if (xfrm_lookup(&skb->dst, &fl, NULL, 0) >= 0) {
374 ip6_xmit(dccp_v6_ctl_socket->sk, skb, &fl, NULL, 0);
375 DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS);
376 DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS);
377 return;
378 }
379 }
380
381 kfree_skb(skb);
382 }
383
384 static struct request_sock_ops dccp6_request_sock_ops = {
385 .family = AF_INET6,
386 .obj_size = sizeof(struct dccp6_request_sock),
387 .rtx_syn_ack = dccp_v6_send_response,
388 .send_ack = dccp_reqsk_send_ack,
389 .destructor = dccp_v6_reqsk_destructor,
390 .send_reset = dccp_v6_ctl_send_reset,
391 };
392
393 static struct sock *dccp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
394 {
395 const struct dccp_hdr *dh = dccp_hdr(skb);
396 const struct ipv6hdr *iph = skb->nh.ipv6h;
397 struct sock *nsk;
398 struct request_sock **prev;
399 /* Find possible connection requests. */
400 struct request_sock *req = inet6_csk_search_req(sk, &prev,
401 dh->dccph_sport,
402 &iph->saddr,
403 &iph->daddr,
404 inet6_iif(skb));
405 if (req != NULL)
406 return dccp_check_req(sk, skb, req, prev);
407
408 nsk = __inet6_lookup_established(&dccp_hashinfo,
409 &iph->saddr, dh->dccph_sport,
410 &iph->daddr, ntohs(dh->dccph_dport),
411 inet6_iif(skb));
412 if (nsk != NULL) {
413 if (nsk->sk_state != DCCP_TIME_WAIT) {
414 bh_lock_sock(nsk);
415 return nsk;
416 }
417 inet_twsk_put(inet_twsk(nsk));
418 return NULL;
419 }
420
421 return sk;
422 }
423
424 static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
425 {
426 struct request_sock *req;
427 struct dccp_request_sock *dreq;
428 struct inet6_request_sock *ireq6;
429 struct ipv6_pinfo *np = inet6_sk(sk);
430 const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
431 struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
432 __u8 reset_code = DCCP_RESET_CODE_TOO_BUSY;
433
434 if (skb->protocol == htons(ETH_P_IP))
435 return dccp_v4_conn_request(sk, skb);
436
437 if (!ipv6_unicast_destination(skb))
438 goto drop;
439
440 if (dccp_bad_service_code(sk, service)) {
441 reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
442 goto drop;
443 }
444 /*
445 * There are no SYN attacks on IPv6, yet...
446 */
447 if (inet_csk_reqsk_queue_is_full(sk))
448 goto drop;
449
450 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
451 goto drop;
452
453 req = inet6_reqsk_alloc(&dccp6_request_sock_ops);
454 if (req == NULL)
455 goto drop;
456
457 if (dccp_parse_options(sk, skb))
458 goto drop_and_free;
459
460 dccp_reqsk_init(req, skb);
461
462 if (security_inet_conn_request(sk, skb, req))
463 goto drop_and_free;
464
465 ireq6 = inet6_rsk(req);
466 ipv6_addr_copy(&ireq6->rmt_addr, &skb->nh.ipv6h->saddr);
467 ipv6_addr_copy(&ireq6->loc_addr, &skb->nh.ipv6h->daddr);
468 ireq6->pktopts = NULL;
469
470 if (ipv6_opt_accepted(sk, skb) ||
471 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
472 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
473 atomic_inc(&skb->users);
474 ireq6->pktopts = skb;
475 }
476 ireq6->iif = sk->sk_bound_dev_if;
477
478 /* So that link locals have meaning */
479 if (!sk->sk_bound_dev_if &&
480 ipv6_addr_type(&ireq6->rmt_addr) & IPV6_ADDR_LINKLOCAL)
481 ireq6->iif = inet6_iif(skb);
482
483 /*
484 * Step 3: Process LISTEN state
485 *
486 * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
487 *
488 * In fact we defer setting S.GSR, S.SWL, S.SWH to
489 * dccp_create_openreq_child.
490 */
491 dreq = dccp_rsk(req);
492 dreq->dreq_isr = dcb->dccpd_seq;
493 dreq->dreq_iss = dccp_v6_init_sequence(skb);
494 dreq->dreq_service = service;
495
496 if (dccp_v6_send_response(sk, req, NULL))
497 goto drop_and_free;
498
499 inet6_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT);
500 return 0;
501
502 drop_and_free:
503 reqsk_free(req);
504 drop:
505 DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS);
506 dcb->dccpd_reset_code = reset_code;
507 return -1;
508 }
509
510 static struct sock *dccp_v6_request_recv_sock(struct sock *sk,
511 struct sk_buff *skb,
512 struct request_sock *req,
513 struct dst_entry *dst)
514 {
515 struct inet6_request_sock *ireq6 = inet6_rsk(req);
516 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
517 struct inet_sock *newinet;
518 struct dccp_sock *newdp;
519 struct dccp6_sock *newdp6;
520 struct sock *newsk;
521 struct ipv6_txoptions *opt;
522
523 if (skb->protocol == htons(ETH_P_IP)) {
524 /*
525 * v6 mapped
526 */
527 newsk = dccp_v4_request_recv_sock(sk, skb, req, dst);
528 if (newsk == NULL)
529 return NULL;
530
531 newdp6 = (struct dccp6_sock *)newsk;
532 newdp = dccp_sk(newsk);
533 newinet = inet_sk(newsk);
534 newinet->pinet6 = &newdp6->inet6;
535 newnp = inet6_sk(newsk);
536
537 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
538
539 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
540 newinet->daddr);
541
542 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
543 newinet->saddr);
544
545 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
546
547 inet_csk(newsk)->icsk_af_ops = &dccp_ipv6_mapped;
548 newsk->sk_backlog_rcv = dccp_v4_do_rcv;
549 newnp->pktoptions = NULL;
550 newnp->opt = NULL;
551 newnp->mcast_oif = inet6_iif(skb);
552 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
553
554 /*
555 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
556 * here, dccp_create_openreq_child now does this for us, see the comment in
557 * that function for the gory details. -acme
558 */
559
560 /* It is tricky place. Until this moment IPv4 tcp
561 worked with IPv6 icsk.icsk_af_ops.
562 Sync it now.
563 */
564 dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
565
566 return newsk;
567 }
568
569 opt = np->opt;
570
571 if (sk_acceptq_is_full(sk))
572 goto out_overflow;
573
574 if (np->rxopt.bits.osrcrt == 2 && opt == NULL && ireq6->pktopts) {
575 const struct inet6_skb_parm *rxopt = IP6CB(ireq6->pktopts);
576
577 if (rxopt->srcrt)
578 opt = ipv6_invert_rthdr(sk,
579 (struct ipv6_rt_hdr *)(ireq6->pktopts->nh.raw +
580 rxopt->srcrt));
581 }
582
583 if (dst == NULL) {
584 struct in6_addr *final_p = NULL, final;
585 struct flowi fl;
586
587 memset(&fl, 0, sizeof(fl));
588 fl.proto = IPPROTO_DCCP;
589 ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr);
590 if (opt != NULL && opt->srcrt != NULL) {
591 const struct rt0_hdr *rt0 = (struct rt0_hdr *)opt->srcrt;
592
593 ipv6_addr_copy(&final, &fl.fl6_dst);
594 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
595 final_p = &final;
596 }
597 ipv6_addr_copy(&fl.fl6_src, &ireq6->loc_addr);
598 fl.oif = sk->sk_bound_dev_if;
599 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
600 fl.fl_ip_sport = inet_sk(sk)->sport;
601 security_sk_classify_flow(sk, &fl);
602
603 if (ip6_dst_lookup(sk, &dst, &fl))
604 goto out;
605
606 if (final_p)
607 ipv6_addr_copy(&fl.fl6_dst, final_p);
608
609 if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0)
610 goto out;
611 }
612
613 newsk = dccp_create_openreq_child(sk, req, skb);
614 if (newsk == NULL)
615 goto out;
616
617 /*
618 * No need to charge this sock to the relevant IPv6 refcnt debug socks
619 * count here, dccp_create_openreq_child now does this for us, see the
620 * comment in that function for the gory details. -acme
621 */
622
623 __ip6_dst_store(newsk, dst, NULL, NULL);
624 newsk->sk_route_caps = dst->dev->features & ~(NETIF_F_IP_CSUM |
625 NETIF_F_TSO);
626 newdp6 = (struct dccp6_sock *)newsk;
627 newinet = inet_sk(newsk);
628 newinet->pinet6 = &newdp6->inet6;
629 newdp = dccp_sk(newsk);
630 newnp = inet6_sk(newsk);
631
632 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
633
634 ipv6_addr_copy(&newnp->daddr, &ireq6->rmt_addr);
635 ipv6_addr_copy(&newnp->saddr, &ireq6->loc_addr);
636 ipv6_addr_copy(&newnp->rcv_saddr, &ireq6->loc_addr);
637 newsk->sk_bound_dev_if = ireq6->iif;
638
639 /* Now IPv6 options...
640
641 First: no IPv4 options.
642 */
643 newinet->opt = NULL;
644
645 /* Clone RX bits */
646 newnp->rxopt.all = np->rxopt.all;
647
648 /* Clone pktoptions received with SYN */
649 newnp->pktoptions = NULL;
650 if (ireq6->pktopts != NULL) {
651 newnp->pktoptions = skb_clone(ireq6->pktopts, GFP_ATOMIC);
652 kfree_skb(ireq6->pktopts);
653 ireq6->pktopts = NULL;
654 if (newnp->pktoptions)
655 skb_set_owner_r(newnp->pktoptions, newsk);
656 }
657 newnp->opt = NULL;
658 newnp->mcast_oif = inet6_iif(skb);
659 newnp->mcast_hops = skb->nh.ipv6h->hop_limit;
660
661 /*
662 * Clone native IPv6 options from listening socket (if any)
663 *
664 * Yes, keeping reference count would be much more clever, but we make
665 * one more one thing there: reattach optmem to newsk.
666 */
667 if (opt != NULL) {
668 newnp->opt = ipv6_dup_options(newsk, opt);
669 if (opt != np->opt)
670 sock_kfree_s(sk, opt, opt->tot_len);
671 }
672
673 inet_csk(newsk)->icsk_ext_hdr_len = 0;
674 if (newnp->opt != NULL)
675 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
676 newnp->opt->opt_flen);
677
678 dccp_sync_mss(newsk, dst_mtu(dst));
679
680 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
681
682 __inet6_hash(&dccp_hashinfo, newsk);
683 inet_inherit_port(&dccp_hashinfo, sk, newsk);
684
685 return newsk;
686
687 out_overflow:
688 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
689 out:
690 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
691 if (opt != NULL && opt != np->opt)
692 sock_kfree_s(sk, opt, opt->tot_len);
693 dst_release(dst);
694 return NULL;
695 }
696
697 /* The socket must have it's spinlock held when we get
698 * here.
699 *
700 * We have a potential double-lock case here, so even when
701 * doing backlog processing we use the BH locking scheme.
702 * This is because we cannot sleep with the original spinlock
703 * held.
704 */
705 static int dccp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
706 {
707 struct ipv6_pinfo *np = inet6_sk(sk);
708 struct sk_buff *opt_skb = NULL;
709
710 /* Imagine: socket is IPv6. IPv4 packet arrives,
711 goes to IPv4 receive handler and backlogged.
712 From backlog it always goes here. Kerboom...
713 Fortunately, dccp_rcv_established and rcv_established
714 handle them correctly, but it is not case with
715 dccp_v6_hnd_req and dccp_v6_ctl_send_reset(). --ANK
716 */
717
718 if (skb->protocol == htons(ETH_P_IP))
719 return dccp_v4_do_rcv(sk, skb);
720
721 if (sk_filter(sk, skb))
722 goto discard;
723
724 /*
725 * socket locking is here for SMP purposes as backlog rcv is currently
726 * called with bh processing disabled.
727 */
728
729 /* Do Stevens' IPV6_PKTOPTIONS.
730
731 Yes, guys, it is the only place in our code, where we
732 may make it not affecting IPv4.
733 The rest of code is protocol independent,
734 and I do not like idea to uglify IPv4.
735
736 Actually, all the idea behind IPV6_PKTOPTIONS
737 looks not very well thought. For now we latch
738 options, received in the last packet, enqueued
739 by tcp. Feel free to propose better solution.
740 --ANK (980728)
741 */
742 if (np->rxopt.all)
743 /*
744 * FIXME: Add handling of IPV6_PKTOPTIONS skb. See the comments below
745 * (wrt ipv6_pktopions) and net/ipv6/tcp_ipv6.c for an example.
746 */
747 opt_skb = skb_clone(skb, GFP_ATOMIC);
748
749 if (sk->sk_state == DCCP_OPEN) { /* Fast path */
750 if (dccp_rcv_established(sk, skb, dccp_hdr(skb), skb->len))
751 goto reset;
752 if (opt_skb) {
753 /* XXX This is where we would goto ipv6_pktoptions. */
754 __kfree_skb(opt_skb);
755 }
756 return 0;
757 }
758
759 /*
760 * Step 3: Process LISTEN state
761 * If S.state == LISTEN,
762 * If P.type == Request or P contains a valid Init Cookie option,
763 * (* Must scan the packet's options to check for Init
764 * Cookies. Only Init Cookies are processed here,
765 * however; other options are processed in Step 8. This
766 * scan need only be performed if the endpoint uses Init
767 * Cookies *)
768 * (* Generate a new socket and switch to that socket *)
769 * Set S := new socket for this port pair
770 * S.state = RESPOND
771 * Choose S.ISS (initial seqno) or set from Init Cookies
772 * Initialize S.GAR := S.ISS
773 * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookies
774 * Continue with S.state == RESPOND
775 * (* A Response packet will be generated in Step 11 *)
776 * Otherwise,
777 * Generate Reset(No Connection) unless P.type == Reset
778 * Drop packet and return
779 *
780 * NOTE: the check for the packet types is done in
781 * dccp_rcv_state_process
782 */
783 if (sk->sk_state == DCCP_LISTEN) {
784 struct sock *nsk = dccp_v6_hnd_req(sk, skb);
785
786 if (nsk == NULL)
787 goto discard;
788 /*
789 * Queue it on the new socket if the new socket is active,
790 * otherwise we just shortcircuit this and continue with
791 * the new socket..
792 */
793 if (nsk != sk) {
794 if (dccp_child_process(sk, nsk, skb))
795 goto reset;
796 if (opt_skb != NULL)
797 __kfree_skb(opt_skb);
798 return 0;
799 }
800 }
801
802 if (dccp_rcv_state_process(sk, skb, dccp_hdr(skb), skb->len))
803 goto reset;
804 if (opt_skb) {
805 /* XXX This is where we would goto ipv6_pktoptions. */
806 __kfree_skb(opt_skb);
807 }
808 return 0;
809
810 reset:
811 dccp_v6_ctl_send_reset(skb);
812 discard:
813 if (opt_skb != NULL)
814 __kfree_skb(opt_skb);
815 kfree_skb(skb);
816 return 0;
817 }
818
819 static int dccp_v6_rcv(struct sk_buff **pskb)
820 {
821 const struct dccp_hdr *dh;
822 struct sk_buff *skb = *pskb;
823 struct sock *sk;
824 int min_cov;
825
826 /* Step 1: Check header basics */
827
828 if (dccp_invalid_packet(skb))
829 goto discard_it;
830
831 /* Step 1: If header checksum is incorrect, drop packet and return. */
832 if (dccp_v6_csum_finish(skb, &skb->nh.ipv6h->saddr,
833 &skb->nh.ipv6h->daddr)) {
834 LIMIT_NETDEBUG(KERN_WARNING
835 "%s: dropped packet with invalid checksum\n",
836 __FUNCTION__);
837 goto discard_it;
838 }
839
840 dh = dccp_hdr(skb);
841
842 DCCP_SKB_CB(skb)->dccpd_seq = dccp_hdr_seq(skb);
843 DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type;
844
845 if (dccp_packet_without_ack(skb))
846 DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ;
847 else
848 DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb);
849
850 /* Step 2:
851 * Look up flow ID in table and get corresponding socket */
852 sk = __inet6_lookup(&dccp_hashinfo, &skb->nh.ipv6h->saddr,
853 dh->dccph_sport,
854 &skb->nh.ipv6h->daddr, ntohs(dh->dccph_dport),
855 inet6_iif(skb));
856 /*
857 * Step 2:
858 * If no socket ...
859 */
860 if (sk == NULL) {
861 dccp_pr_debug("failed to look up flow ID in table and "
862 "get corresponding socket\n");
863 goto no_dccp_socket;
864 }
865
866 /*
867 * Step 2:
868 * ... or S.state == TIMEWAIT,
869 * Generate Reset(No Connection) unless P.type == Reset
870 * Drop packet and return
871 */
872 if (sk->sk_state == DCCP_TIME_WAIT) {
873 dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: do_time_wait\n");
874 inet_twsk_put(inet_twsk(sk));
875 goto no_dccp_socket;
876 }
877
878 /*
879 * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage
880 * o if MinCsCov = 0, only packets with CsCov = 0 are accepted
881 * o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov
882 */
883 min_cov = dccp_sk(sk)->dccps_pcrlen;
884 if (dh->dccph_cscov && (min_cov == 0 || dh->dccph_cscov < min_cov)) {
885 dccp_pr_debug("Packet CsCov %d does not satisfy MinCsCov %d\n",
886 dh->dccph_cscov, min_cov);
887 /* FIXME: send Data Dropped option (see also dccp_v4_rcv) */
888 goto discard_and_relse;
889 }
890
891 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
892 goto discard_and_relse;
893
894 return sk_receive_skb(sk, skb) ? -1 : 0;
895
896 no_dccp_socket:
897 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
898 goto discard_it;
899 /*
900 * Step 2:
901 * If no socket ...
902 * Generate Reset(No Connection) unless P.type == Reset
903 * Drop packet and return
904 */
905 if (dh->dccph_type != DCCP_PKT_RESET) {
906 DCCP_SKB_CB(skb)->dccpd_reset_code =
907 DCCP_RESET_CODE_NO_CONNECTION;
908 dccp_v6_ctl_send_reset(skb);
909 }
910
911 discard_it:
912 kfree_skb(skb);
913 return 0;
914
915 discard_and_relse:
916 sock_put(sk);
917 goto discard_it;
918 }
919
920 static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
921 int addr_len)
922 {
923 struct sockaddr_in6 *usin = (struct sockaddr_in6 *)uaddr;
924 struct inet_connection_sock *icsk = inet_csk(sk);
925 struct inet_sock *inet = inet_sk(sk);
926 struct ipv6_pinfo *np = inet6_sk(sk);
927 struct dccp_sock *dp = dccp_sk(sk);
928 struct in6_addr *saddr = NULL, *final_p = NULL, final;
929 struct flowi fl;
930 struct dst_entry *dst;
931 int addr_type;
932 int err;
933
934 dp->dccps_role = DCCP_ROLE_CLIENT;
935
936 if (addr_len < SIN6_LEN_RFC2133)
937 return -EINVAL;
938
939 if (usin->sin6_family != AF_INET6)
940 return -EAFNOSUPPORT;
941
942 memset(&fl, 0, sizeof(fl));
943
944 if (np->sndflow) {
945 fl.fl6_flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
946 IP6_ECN_flow_init(fl.fl6_flowlabel);
947 if (fl.fl6_flowlabel & IPV6_FLOWLABEL_MASK) {
948 struct ip6_flowlabel *flowlabel;
949 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
950 if (flowlabel == NULL)
951 return -EINVAL;
952 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
953 fl6_sock_release(flowlabel);
954 }
955 }
956 /*
957 * connect() to INADDR_ANY means loopback (BSD'ism).
958 */
959 if (ipv6_addr_any(&usin->sin6_addr))
960 usin->sin6_addr.s6_addr[15] = 1;
961
962 addr_type = ipv6_addr_type(&usin->sin6_addr);
963
964 if (addr_type & IPV6_ADDR_MULTICAST)
965 return -ENETUNREACH;
966
967 if (addr_type & IPV6_ADDR_LINKLOCAL) {
968 if (addr_len >= sizeof(struct sockaddr_in6) &&
969 usin->sin6_scope_id) {
970 /* If interface is set while binding, indices
971 * must coincide.
972 */
973 if (sk->sk_bound_dev_if &&
974 sk->sk_bound_dev_if != usin->sin6_scope_id)
975 return -EINVAL;
976
977 sk->sk_bound_dev_if = usin->sin6_scope_id;
978 }
979
980 /* Connect to link-local address requires an interface */
981 if (!sk->sk_bound_dev_if)
982 return -EINVAL;
983 }
984
985 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
986 np->flow_label = fl.fl6_flowlabel;
987
988 /*
989 * DCCP over IPv4
990 */
991 if (addr_type == IPV6_ADDR_MAPPED) {
992 u32 exthdrlen = icsk->icsk_ext_hdr_len;
993 struct sockaddr_in sin;
994
995 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
996
997 if (__ipv6_only_sock(sk))
998 return -ENETUNREACH;
999
1000 sin.sin_family = AF_INET;
1001 sin.sin_port = usin->sin6_port;
1002 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
1003
1004 icsk->icsk_af_ops = &dccp_ipv6_mapped;
1005 sk->sk_backlog_rcv = dccp_v4_do_rcv;
1006
1007 err = dccp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
1008 if (err) {
1009 icsk->icsk_ext_hdr_len = exthdrlen;
1010 icsk->icsk_af_ops = &dccp_ipv6_af_ops;
1011 sk->sk_backlog_rcv = dccp_v6_do_rcv;
1012 goto failure;
1013 } else {
1014 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
1015 inet->saddr);
1016 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
1017 inet->rcv_saddr);
1018 }
1019
1020 return err;
1021 }
1022
1023 if (!ipv6_addr_any(&np->rcv_saddr))
1024 saddr = &np->rcv_saddr;
1025
1026 fl.proto = IPPROTO_DCCP;
1027 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
1028 ipv6_addr_copy(&fl.fl6_src, saddr ? saddr : &np->saddr);
1029 fl.oif = sk->sk_bound_dev_if;
1030 fl.fl_ip_dport = usin->sin6_port;
1031 fl.fl_ip_sport = inet->sport;
1032 security_sk_classify_flow(sk, &fl);
1033
1034 if (np->opt != NULL && np->opt->srcrt != NULL) {
1035 const struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
1036
1037 ipv6_addr_copy(&final, &fl.fl6_dst);
1038 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1039 final_p = &final;
1040 }
1041
1042 err = ip6_dst_lookup(sk, &dst, &fl);
1043 if (err)
1044 goto failure;
1045
1046 if (final_p)
1047 ipv6_addr_copy(&fl.fl6_dst, final_p);
1048
1049 err = xfrm_lookup(&dst, &fl, sk, 0);
1050 if (err < 0)
1051 goto failure;
1052
1053 if (saddr == NULL) {
1054 saddr = &fl.fl6_src;
1055 ipv6_addr_copy(&np->rcv_saddr, saddr);
1056 }
1057
1058 /* set the source address */
1059 ipv6_addr_copy(&np->saddr, saddr);
1060 inet->rcv_saddr = LOOPBACK4_IPV6;
1061
1062 __ip6_dst_store(sk, dst, NULL, NULL);
1063
1064 icsk->icsk_ext_hdr_len = 0;
1065 if (np->opt != NULL)
1066 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
1067 np->opt->opt_nflen);
1068
1069 inet->dport = usin->sin6_port;
1070
1071 dccp_set_state(sk, DCCP_REQUESTING);
1072 err = inet6_hash_connect(&dccp_death_row, sk);
1073 if (err)
1074 goto late_failure;
1075
1076 dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,
1077 np->daddr.s6_addr32,
1078 inet->sport, inet->dport);
1079 err = dccp_connect(sk);
1080 if (err)
1081 goto late_failure;
1082
1083 return 0;
1084
1085 late_failure:
1086 dccp_set_state(sk, DCCP_CLOSED);
1087 __sk_dst_reset(sk);
1088 failure:
1089 inet->dport = 0;
1090 sk->sk_route_caps = 0;
1091 return err;
1092 }
1093
1094 static struct inet_connection_sock_af_ops dccp_ipv6_af_ops = {
1095 .queue_xmit = inet6_csk_xmit,
1096 .send_check = dccp_v6_send_check,
1097 .rebuild_header = inet6_sk_rebuild_header,
1098 .conn_request = dccp_v6_conn_request,
1099 .syn_recv_sock = dccp_v6_request_recv_sock,
1100 .net_header_len = sizeof(struct ipv6hdr),
1101 .setsockopt = ipv6_setsockopt,
1102 .getsockopt = ipv6_getsockopt,
1103 .addr2sockaddr = inet6_csk_addr2sockaddr,
1104 .sockaddr_len = sizeof(struct sockaddr_in6),
1105 #ifdef CONFIG_COMPAT
1106 .compat_setsockopt = compat_ipv6_setsockopt,
1107 .compat_getsockopt = compat_ipv6_getsockopt,
1108 #endif
1109 };
1110
1111 /*
1112 * DCCP over IPv4 via INET6 API
1113 */
1114 static struct inet_connection_sock_af_ops dccp_ipv6_mapped = {
1115 .queue_xmit = ip_queue_xmit,
1116 .send_check = dccp_v4_send_check,
1117 .rebuild_header = inet_sk_rebuild_header,
1118 .conn_request = dccp_v6_conn_request,
1119 .syn_recv_sock = dccp_v6_request_recv_sock,
1120 .net_header_len = sizeof(struct iphdr),
1121 .setsockopt = ipv6_setsockopt,
1122 .getsockopt = ipv6_getsockopt,
1123 .addr2sockaddr = inet6_csk_addr2sockaddr,
1124 .sockaddr_len = sizeof(struct sockaddr_in6),
1125 #ifdef CONFIG_COMPAT
1126 .compat_setsockopt = compat_ipv6_setsockopt,
1127 .compat_getsockopt = compat_ipv6_getsockopt,
1128 #endif
1129 };
1130
1131 /* NOTE: A lot of things set to zero explicitly by call to
1132 * sk_alloc() so need not be done here.
1133 */
1134 static int dccp_v6_init_sock(struct sock *sk)
1135 {
1136 static __u8 dccp_v6_ctl_sock_initialized;
1137 int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized);
1138
1139 if (err == 0) {
1140 if (unlikely(!dccp_v6_ctl_sock_initialized))
1141 dccp_v6_ctl_sock_initialized = 1;
1142 inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops;
1143 }
1144
1145 return err;
1146 }
1147
1148 static int dccp_v6_destroy_sock(struct sock *sk)
1149 {
1150 dccp_destroy_sock(sk);
1151 return inet6_destroy_sock(sk);
1152 }
1153
1154 static struct timewait_sock_ops dccp6_timewait_sock_ops = {
1155 .twsk_obj_size = sizeof(struct dccp6_timewait_sock),
1156 };
1157
1158 static struct proto dccp_v6_prot = {
1159 .name = "DCCPv6",
1160 .owner = THIS_MODULE,
1161 .close = dccp_close,
1162 .connect = dccp_v6_connect,
1163 .disconnect = dccp_disconnect,
1164 .ioctl = dccp_ioctl,
1165 .init = dccp_v6_init_sock,
1166 .setsockopt = dccp_setsockopt,
1167 .getsockopt = dccp_getsockopt,
1168 .sendmsg = dccp_sendmsg,
1169 .recvmsg = dccp_recvmsg,
1170 .backlog_rcv = dccp_v6_do_rcv,
1171 .hash = dccp_v6_hash,
1172 .unhash = dccp_unhash,
1173 .accept = inet_csk_accept,
1174 .get_port = dccp_v6_get_port,
1175 .shutdown = dccp_shutdown,
1176 .destroy = dccp_v6_destroy_sock,
1177 .orphan_count = &dccp_orphan_count,
1178 .max_header = MAX_DCCP_HEADER,
1179 .obj_size = sizeof(struct dccp6_sock),
1180 .rsk_prot = &dccp6_request_sock_ops,
1181 .twsk_prot = &dccp6_timewait_sock_ops,
1182 #ifdef CONFIG_COMPAT
1183 .compat_setsockopt = compat_dccp_setsockopt,
1184 .compat_getsockopt = compat_dccp_getsockopt,
1185 #endif
1186 };
1187
1188 static struct inet6_protocol dccp_v6_protocol = {
1189 .handler = dccp_v6_rcv,
1190 .err_handler = dccp_v6_err,
1191 .flags = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
1192 };
1193
1194 static struct proto_ops inet6_dccp_ops = {
1195 .family = PF_INET6,
1196 .owner = THIS_MODULE,
1197 .release = inet6_release,
1198 .bind = inet6_bind,
1199 .connect = inet_stream_connect,
1200 .socketpair = sock_no_socketpair,
1201 .accept = inet_accept,
1202 .getname = inet6_getname,
1203 .poll = dccp_poll,
1204 .ioctl = inet6_ioctl,
1205 .listen = inet_dccp_listen,
1206 .shutdown = inet_shutdown,
1207 .setsockopt = sock_common_setsockopt,
1208 .getsockopt = sock_common_getsockopt,
1209 .sendmsg = inet_sendmsg,
1210 .recvmsg = sock_common_recvmsg,
1211 .mmap = sock_no_mmap,
1212 .sendpage = sock_no_sendpage,
1213 #ifdef CONFIG_COMPAT
1214 .compat_setsockopt = compat_sock_common_setsockopt,
1215 .compat_getsockopt = compat_sock_common_getsockopt,
1216 #endif
1217 };
1218
1219 static struct inet_protosw dccp_v6_protosw = {
1220 .type = SOCK_DCCP,
1221 .protocol = IPPROTO_DCCP,
1222 .prot = &dccp_v6_prot,
1223 .ops = &inet6_dccp_ops,
1224 .capability = -1,
1225 .flags = INET_PROTOSW_ICSK,
1226 };
1227
1228 static int __init dccp_v6_init(void)
1229 {
1230 int err = proto_register(&dccp_v6_prot, 1);
1231
1232 if (err != 0)
1233 goto out;
1234
1235 err = inet6_add_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1236 if (err != 0)
1237 goto out_unregister_proto;
1238
1239 inet6_register_protosw(&dccp_v6_protosw);
1240
1241 err = inet_csk_ctl_sock_create(&dccp_v6_ctl_socket, PF_INET6,
1242 SOCK_DCCP, IPPROTO_DCCP);
1243 if (err != 0)
1244 goto out_unregister_protosw;
1245 out:
1246 return err;
1247 out_unregister_protosw:
1248 inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1249 inet6_unregister_protosw(&dccp_v6_protosw);
1250 out_unregister_proto:
1251 proto_unregister(&dccp_v6_prot);
1252 goto out;
1253 }
1254
1255 static void __exit dccp_v6_exit(void)
1256 {
1257 inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1258 inet6_unregister_protosw(&dccp_v6_protosw);
1259 proto_unregister(&dccp_v6_prot);
1260 }
1261
1262 module_init(dccp_v6_init);
1263 module_exit(dccp_v6_exit);
1264
1265 /*
1266 * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33)
1267 * values directly, Also cover the case where the protocol is not specified,
1268 * i.e. net-pf-PF_INET6-proto-0-type-SOCK_DCCP
1269 */
1270 MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-33-type-6");
1271 MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-0-type-6");
1272 MODULE_LICENSE("GPL");
1273 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
1274 MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol");
Linux kernel - Deliverables
This page took 0.055955 seconds and 5 git commands to generate.