?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel-doc: generate main index page when building 'htmldocs'
[linux-2.6/zen-sources.git] / net / dccp / ipv6.c
blob64eac2515aa2554205534426b5f1cfcf7626931e
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 __sum16 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(__be32 *saddr, __be32 *daddr,
80 __be16 sport, __be16 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(ipv6_hdr(skb)->daddr.s6_addr32,
88 ipv6_hdr(skb)->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 *)(skb_network_header(pktopts) +
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 err = net_xmit_eval(err);
298 }
299
300 done:
301 if (opt != NULL && opt != np->opt)
302 sock_kfree_s(sk, opt, opt->tot_len);
303 dst_release(dst);
304 return err;
305 }
306
307 static void dccp_v6_reqsk_destructor(struct request_sock *req)
308 {
309 if (inet6_rsk(req)->pktopts != NULL)
310 kfree_skb(inet6_rsk(req)->pktopts);
311 }
312
313 static void dccp_v6_ctl_send_reset(struct sock *sk, struct sk_buff *rxskb)
314 {
315 struct dccp_hdr *rxdh = dccp_hdr(rxskb), *dh;
316 struct ipv6hdr *rxip6h;
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 = 0;
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 if (DCCP_SKB_CB(rxskb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
350 dccp_set_seqno(&seqno, DCCP_SKB_CB(rxskb)->dccpd_ack_seq + 1);
351
352 dccp_hdr_set_seq(dh, seqno);
353 dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), DCCP_SKB_CB(rxskb)->dccpd_seq);
354
355 dccp_csum_outgoing(skb);
356 rxip6h = ipv6_hdr(rxskb);
357 dh->dccph_checksum = dccp_v6_csum_finish(skb, &rxip6h->saddr,
358 &rxip6h->daddr);
359
360 memset(&fl, 0, sizeof(fl));
361 ipv6_addr_copy(&fl.fl6_dst, &rxip6h->saddr);
362 ipv6_addr_copy(&fl.fl6_src, &rxip6h->daddr);
363
364 fl.proto = IPPROTO_DCCP;
365 fl.oif = inet6_iif(rxskb);
366 fl.fl_ip_dport = dh->dccph_dport;
367 fl.fl_ip_sport = dh->dccph_sport;
368 security_skb_classify_flow(rxskb, &fl);
369
370 /* sk = NULL, but it is safe for now. RST socket required. */
371 if (!ip6_dst_lookup(NULL, &skb->dst, &fl)) {
372 if (xfrm_lookup(&skb->dst, &fl, NULL, 0) >= 0) {
373 ip6_xmit(dccp_v6_ctl_socket->sk, skb, &fl, NULL, 0);
374 DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS);
375 DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS);
376 return;
377 }
378 }
379
380 kfree_skb(skb);
381 }
382
383 static struct request_sock_ops dccp6_request_sock_ops = {
384 .family = AF_INET6,
385 .obj_size = sizeof(struct dccp6_request_sock),
386 .rtx_syn_ack = dccp_v6_send_response,
387 .send_ack = dccp_reqsk_send_ack,
388 .destructor = dccp_v6_reqsk_destructor,
389 .send_reset = dccp_v6_ctl_send_reset,
390 };
391
392 static struct sock *dccp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
393 {
394 const struct dccp_hdr *dh = dccp_hdr(skb);
395 const struct ipv6hdr *iph = ipv6_hdr(skb);
396 struct sock *nsk;
397 struct request_sock **prev;
398 /* Find possible connection requests. */
399 struct request_sock *req = inet6_csk_search_req(sk, &prev,
400 dh->dccph_sport,
401 &iph->saddr,
402 &iph->daddr,
403 inet6_iif(skb));
404 if (req != NULL)
405 return dccp_check_req(sk, skb, req, prev);
406
407 nsk = __inet6_lookup_established(&dccp_hashinfo,
408 &iph->saddr, dh->dccph_sport,
409 &iph->daddr, ntohs(dh->dccph_dport),
410 inet6_iif(skb));
411 if (nsk != NULL) {
412 if (nsk->sk_state != DCCP_TIME_WAIT) {
413 bh_lock_sock(nsk);
414 return nsk;
415 }
416 inet_twsk_put(inet_twsk(nsk));
417 return NULL;
418 }
419
420 return sk;
421 }
422
423 static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
424 {
425 struct request_sock *req;
426 struct dccp_request_sock *dreq;
427 struct inet6_request_sock *ireq6;
428 struct ipv6_pinfo *np = inet6_sk(sk);
429 const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
430 struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
431 __u8 reset_code = DCCP_RESET_CODE_TOO_BUSY;
432
433 if (skb->protocol == htons(ETH_P_IP))
434 return dccp_v4_conn_request(sk, skb);
435
436 if (!ipv6_unicast_destination(skb))
437 goto drop;
438
439 if (dccp_bad_service_code(sk, service)) {
440 reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
441 goto drop;
442 }
443 /*
444 * There are no SYN attacks on IPv6, yet...
445 */
446 if (inet_csk_reqsk_queue_is_full(sk))
447 goto drop;
448
449 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
450 goto drop;
451
452 req = inet6_reqsk_alloc(&dccp6_request_sock_ops);
453 if (req == NULL)
454 goto drop;
455
456 if (dccp_parse_options(sk, skb))
457 goto drop_and_free;
458
459 dccp_reqsk_init(req, skb);
460
461 if (security_inet_conn_request(sk, skb, req))
462 goto drop_and_free;
463
464 ireq6 = inet6_rsk(req);
465 ipv6_addr_copy(&ireq6->rmt_addr, &ipv6_hdr(skb)->saddr);
466 ipv6_addr_copy(&ireq6->loc_addr, &ipv6_hdr(skb)->daddr);
467 ireq6->pktopts = NULL;
468
469 if (ipv6_opt_accepted(sk, skb) ||
470 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
471 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
472 atomic_inc(&skb->users);
473 ireq6->pktopts = skb;
474 }
475 ireq6->iif = sk->sk_bound_dev_if;
476
477 /* So that link locals have meaning */
478 if (!sk->sk_bound_dev_if &&
479 ipv6_addr_type(&ireq6->rmt_addr) & IPV6_ADDR_LINKLOCAL)
480 ireq6->iif = inet6_iif(skb);
481
482 /*
483 * Step 3: Process LISTEN state
484 *
485 * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
486 *
487 * In fact we defer setting S.GSR, S.SWL, S.SWH to
488 * dccp_create_openreq_child.
489 */
490 dreq = dccp_rsk(req);
491 dreq->dreq_isr = dcb->dccpd_seq;
492 dreq->dreq_iss = dccp_v6_init_sequence(skb);
493 dreq->dreq_service = service;
494
495 if (dccp_v6_send_response(sk, req, NULL))
496 goto drop_and_free;
497
498 inet6_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT);
499 return 0;
500
501 drop_and_free:
502 reqsk_free(req);
503 drop:
504 DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS);
505 dcb->dccpd_reset_code = reset_code;
506 return -1;
507 }
508
509 static struct sock *dccp_v6_request_recv_sock(struct sock *sk,
510 struct sk_buff *skb,
511 struct request_sock *req,
512 struct dst_entry *dst)
513 {
514 struct inet6_request_sock *ireq6 = inet6_rsk(req);
515 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
516 struct inet_sock *newinet;
517 struct dccp_sock *newdp;
518 struct dccp6_sock *newdp6;
519 struct sock *newsk;
520 struct ipv6_txoptions *opt;
521
522 if (skb->protocol == htons(ETH_P_IP)) {
523 /*
524 * v6 mapped
525 */
526 newsk = dccp_v4_request_recv_sock(sk, skb, req, dst);
527 if (newsk == NULL)
528 return NULL;
529
530 newdp6 = (struct dccp6_sock *)newsk;
531 newdp = dccp_sk(newsk);
532 newinet = inet_sk(newsk);
533 newinet->pinet6 = &newdp6->inet6;
534 newnp = inet6_sk(newsk);
535
536 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
537
538 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
539 newinet->daddr);
540
541 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
542 newinet->saddr);
543
544 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
545
546 inet_csk(newsk)->icsk_af_ops = &dccp_ipv6_mapped;
547 newsk->sk_backlog_rcv = dccp_v4_do_rcv;
548 newnp->pktoptions = NULL;
549 newnp->opt = NULL;
550 newnp->mcast_oif = inet6_iif(skb);
551 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
552
553 /*
554 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
555 * here, dccp_create_openreq_child now does this for us, see the comment in
556 * that function for the gory details. -acme
557 */
558
559 /* It is tricky place. Until this moment IPv4 tcp
560 worked with IPv6 icsk.icsk_af_ops.
561 Sync it now.
562 */
563 dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
564
565 return newsk;
566 }
567
568 opt = np->opt;
569
570 if (sk_acceptq_is_full(sk))
571 goto out_overflow;
572
573 if (np->rxopt.bits.osrcrt == 2 && opt == NULL && ireq6->pktopts) {
574 const struct inet6_skb_parm *rxopt = IP6CB(ireq6->pktopts);
575
576 if (rxopt->srcrt)
577 opt = ipv6_invert_rthdr(sk,
578 (struct ipv6_rt_hdr *)(skb_network_header(ireq6->pktopts) +
579 rxopt->srcrt));
580 }
581
582 if (dst == NULL) {
583 struct in6_addr *final_p = NULL, final;
584 struct flowi fl;
585
586 memset(&fl, 0, sizeof(fl));
587 fl.proto = IPPROTO_DCCP;
588 ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr);
589 if (opt != NULL && opt->srcrt != NULL) {
590 const struct rt0_hdr *rt0 = (struct rt0_hdr *)opt->srcrt;
591
592 ipv6_addr_copy(&final, &fl.fl6_dst);
593 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
594 final_p = &final;
595 }
596 ipv6_addr_copy(&fl.fl6_src, &ireq6->loc_addr);
597 fl.oif = sk->sk_bound_dev_if;
598 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
599 fl.fl_ip_sport = inet_sk(sk)->sport;
600 security_sk_classify_flow(sk, &fl);
601
602 if (ip6_dst_lookup(sk, &dst, &fl))
603 goto out;
604
605 if (final_p)
606 ipv6_addr_copy(&fl.fl6_dst, final_p);
607
608 if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0)
609 goto out;
610 }
611
612 newsk = dccp_create_openreq_child(sk, req, skb);
613 if (newsk == NULL)
614 goto out;
615
616 /*
617 * No need to charge this sock to the relevant IPv6 refcnt debug socks
618 * count here, dccp_create_openreq_child now does this for us, see the
619 * comment in that function for the gory details. -acme
620 */
621
622 __ip6_dst_store(newsk, dst, NULL, NULL);
623 newsk->sk_route_caps = dst->dev->features & ~(NETIF_F_IP_CSUM |
624 NETIF_F_TSO);
625 newdp6 = (struct dccp6_sock *)newsk;
626 newinet = inet_sk(newsk);
627 newinet->pinet6 = &newdp6->inet6;
628 newdp = dccp_sk(newsk);
629 newnp = inet6_sk(newsk);
630
631 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
632
633 ipv6_addr_copy(&newnp->daddr, &ireq6->rmt_addr);
634 ipv6_addr_copy(&newnp->saddr, &ireq6->loc_addr);
635 ipv6_addr_copy(&newnp->rcv_saddr, &ireq6->loc_addr);
636 newsk->sk_bound_dev_if = ireq6->iif;
637
638 /* Now IPv6 options...
639
640 First: no IPv4 options.
641 */
642 newinet->opt = NULL;
643
644 /* Clone RX bits */
645 newnp->rxopt.all = np->rxopt.all;
646
647 /* Clone pktoptions received with SYN */
648 newnp->pktoptions = NULL;
649 if (ireq6->pktopts != NULL) {
650 newnp->pktoptions = skb_clone(ireq6->pktopts, GFP_ATOMIC);
651 kfree_skb(ireq6->pktopts);
652 ireq6->pktopts = NULL;
653 if (newnp->pktoptions)
654 skb_set_owner_r(newnp->pktoptions, newsk);
655 }
656 newnp->opt = NULL;
657 newnp->mcast_oif = inet6_iif(skb);
658 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
659
660 /*
661 * Clone native IPv6 options from listening socket (if any)
662 *
663 * Yes, keeping reference count would be much more clever, but we make
664 * one more one thing there: reattach optmem to newsk.
665 */
666 if (opt != NULL) {
667 newnp->opt = ipv6_dup_options(newsk, opt);
668 if (opt != np->opt)
669 sock_kfree_s(sk, opt, opt->tot_len);
670 }
671
672 inet_csk(newsk)->icsk_ext_hdr_len = 0;
673 if (newnp->opt != NULL)
674 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
675 newnp->opt->opt_flen);
676
677 dccp_sync_mss(newsk, dst_mtu(dst));
678
679 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
680
681 __inet6_hash(&dccp_hashinfo, newsk);
682 inet_inherit_port(&dccp_hashinfo, sk, newsk);
683
684 return newsk;
685
686 out_overflow:
687 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
688 out:
689 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
690 if (opt != NULL && opt != np->opt)
691 sock_kfree_s(sk, opt, opt->tot_len);
692 dst_release(dst);
693 return NULL;
694 }
695
696 /* The socket must have it's spinlock held when we get
697 * here.
698 *
699 * We have a potential double-lock case here, so even when
700 * doing backlog processing we use the BH locking scheme.
701 * This is because we cannot sleep with the original spinlock
702 * held.
703 */
704 static int dccp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
705 {
706 struct ipv6_pinfo *np = inet6_sk(sk);
707 struct sk_buff *opt_skb = NULL;
708
709 /* Imagine: socket is IPv6. IPv4 packet arrives,
710 goes to IPv4 receive handler and backlogged.
711 From backlog it always goes here. Kerboom...
712 Fortunately, dccp_rcv_established and rcv_established
713 handle them correctly, but it is not case with
714 dccp_v6_hnd_req and dccp_v6_ctl_send_reset(). --ANK
715 */
716
717 if (skb->protocol == htons(ETH_P_IP))
718 return dccp_v4_do_rcv(sk, skb);
719
720 if (sk_filter(sk, skb))
721 goto discard;
722
723 /*
724 * socket locking is here for SMP purposes as backlog rcv is currently
725 * called with bh processing disabled.
726 */
727
728 /* Do Stevens' IPV6_PKTOPTIONS.
729
730 Yes, guys, it is the only place in our code, where we
731 may make it not affecting IPv4.
732 The rest of code is protocol independent,
733 and I do not like idea to uglify IPv4.
734
735 Actually, all the idea behind IPV6_PKTOPTIONS
736 looks not very well thought. For now we latch
737 options, received in the last packet, enqueued
738 by tcp. Feel free to propose better solution.
739 --ANK (980728)
740 */
741 if (np->rxopt.all)
742 /*
743 * FIXME: Add handling of IPV6_PKTOPTIONS skb. See the comments below
744 * (wrt ipv6_pktopions) and net/ipv6/tcp_ipv6.c for an example.
745 */
746 opt_skb = skb_clone(skb, GFP_ATOMIC);
747
748 if (sk->sk_state == DCCP_OPEN) { /* Fast path */
749 if (dccp_rcv_established(sk, skb, dccp_hdr(skb), skb->len))
750 goto reset;
751 if (opt_skb) {
752 /* XXX This is where we would goto ipv6_pktoptions. */
753 __kfree_skb(opt_skb);
754 }
755 return 0;
756 }
757
758 /*
759 * Step 3: Process LISTEN state
760 * If S.state == LISTEN,
761 * If P.type == Request or P contains a valid Init Cookie option,
762 * (* Must scan the packet's options to check for Init
763 * Cookies. Only Init Cookies are processed here,
764 * however; other options are processed in Step 8. This
765 * scan need only be performed if the endpoint uses Init
766 * Cookies *)
767 * (* Generate a new socket and switch to that socket *)
768 * Set S := new socket for this port pair
769 * S.state = RESPOND
770 * Choose S.ISS (initial seqno) or set from Init Cookies
771 * Initialize S.GAR := S.ISS
772 * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookies
773 * Continue with S.state == RESPOND
774 * (* A Response packet will be generated in Step 11 *)
775 * Otherwise,
776 * Generate Reset(No Connection) unless P.type == Reset
777 * Drop packet and return
778 *
779 * NOTE: the check for the packet types is done in
780 * dccp_rcv_state_process
781 */
782 if (sk->sk_state == DCCP_LISTEN) {
783 struct sock *nsk = dccp_v6_hnd_req(sk, skb);
784
785 if (nsk == NULL)
786 goto discard;
787 /*
788 * Queue it on the new socket if the new socket is active,
789 * otherwise we just shortcircuit this and continue with
790 * the new socket..
791 */
792 if (nsk != sk) {
793 if (dccp_child_process(sk, nsk, skb))
794 goto reset;
795 if (opt_skb != NULL)
796 __kfree_skb(opt_skb);
797 return 0;
798 }
799 }
800
801 if (dccp_rcv_state_process(sk, skb, dccp_hdr(skb), skb->len))
802 goto reset;
803 if (opt_skb) {
804 /* XXX This is where we would goto ipv6_pktoptions. */
805 __kfree_skb(opt_skb);
806 }
807 return 0;
808
809 reset:
810 dccp_v6_ctl_send_reset(sk, skb);
811 discard:
812 if (opt_skb != NULL)
813 __kfree_skb(opt_skb);
814 kfree_skb(skb);
815 return 0;
816 }
817
818 static int dccp_v6_rcv(struct sk_buff **pskb)
819 {
820 const struct dccp_hdr *dh;
821 struct sk_buff *skb = *pskb;
822 struct sock *sk;
823 int min_cov;
824
825 /* Step 1: Check header basics */
826
827 if (dccp_invalid_packet(skb))
828 goto discard_it;
829
830 /* Step 1: If header checksum is incorrect, drop packet and return. */
831 if (dccp_v6_csum_finish(skb, &ipv6_hdr(skb)->saddr,
832 &ipv6_hdr(skb)->daddr)) {
833 DCCP_WARN("dropped packet with invalid checksum\n");
834 goto discard_it;
835 }
836
837 dh = dccp_hdr(skb);
838
839 DCCP_SKB_CB(skb)->dccpd_seq = dccp_hdr_seq(skb);
840 DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type;
841
842 if (dccp_packet_without_ack(skb))
843 DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ;
844 else
845 DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb);
846
847 /* Step 2:
848 * Look up flow ID in table and get corresponding socket */
849 sk = __inet6_lookup(&dccp_hashinfo, &ipv6_hdr(skb)->saddr,
850 dh->dccph_sport,
851 &ipv6_hdr(skb)->daddr, ntohs(dh->dccph_dport),
852 inet6_iif(skb));
853 /*
854 * Step 2:
855 * If no socket ...
856 */
857 if (sk == NULL) {
858 dccp_pr_debug("failed to look up flow ID in table and "
859 "get corresponding socket\n");
860 goto no_dccp_socket;
861 }
862
863 /*
864 * Step 2:
865 * ... or S.state == TIMEWAIT,
866 * Generate Reset(No Connection) unless P.type == Reset
867 * Drop packet and return
868 */
869 if (sk->sk_state == DCCP_TIME_WAIT) {
870 dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: do_time_wait\n");
871 inet_twsk_put(inet_twsk(sk));
872 goto no_dccp_socket;
873 }
874
875 /*
876 * RFC 4340, sec. 9.2.1: Minimum Checksum Coverage
877 * o if MinCsCov = 0, only packets with CsCov = 0 are accepted
878 * o if MinCsCov > 0, also accept packets with CsCov >= MinCsCov
879 */
880 min_cov = dccp_sk(sk)->dccps_pcrlen;
881 if (dh->dccph_cscov && (min_cov == 0 || dh->dccph_cscov < min_cov)) {
882 dccp_pr_debug("Packet CsCov %d does not satisfy MinCsCov %d\n",
883 dh->dccph_cscov, min_cov);
884 /* FIXME: send Data Dropped option (see also dccp_v4_rcv) */
885 goto discard_and_relse;
886 }
887
888 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
889 goto discard_and_relse;
890
891 return sk_receive_skb(sk, skb, 1) ? -1 : 0;
892
893 no_dccp_socket:
894 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
895 goto discard_it;
896 /*
897 * Step 2:
898 * If no socket ...
899 * Generate Reset(No Connection) unless P.type == Reset
900 * Drop packet and return
901 */
902 if (dh->dccph_type != DCCP_PKT_RESET) {
903 DCCP_SKB_CB(skb)->dccpd_reset_code =
904 DCCP_RESET_CODE_NO_CONNECTION;
905 dccp_v6_ctl_send_reset(sk, skb);
906 }
907
908 discard_it:
909 kfree_skb(skb);
910 return 0;
911
912 discard_and_relse:
913 sock_put(sk);
914 goto discard_it;
915 }
916
917 static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
918 int addr_len)
919 {
920 struct sockaddr_in6 *usin = (struct sockaddr_in6 *)uaddr;
921 struct inet_connection_sock *icsk = inet_csk(sk);
922 struct inet_sock *inet = inet_sk(sk);
923 struct ipv6_pinfo *np = inet6_sk(sk);
924 struct dccp_sock *dp = dccp_sk(sk);
925 struct in6_addr *saddr = NULL, *final_p = NULL, final;
926 struct flowi fl;
927 struct dst_entry *dst;
928 int addr_type;
929 int err;
930
931 dp->dccps_role = DCCP_ROLE_CLIENT;
932
933 if (addr_len < SIN6_LEN_RFC2133)
934 return -EINVAL;
935
936 if (usin->sin6_family != AF_INET6)
937 return -EAFNOSUPPORT;
938
939 memset(&fl, 0, sizeof(fl));
940
941 if (np->sndflow) {
942 fl.fl6_flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
943 IP6_ECN_flow_init(fl.fl6_flowlabel);
944 if (fl.fl6_flowlabel & IPV6_FLOWLABEL_MASK) {
945 struct ip6_flowlabel *flowlabel;
946 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
947 if (flowlabel == NULL)
948 return -EINVAL;
949 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
950 fl6_sock_release(flowlabel);
951 }
952 }
953 /*
954 * connect() to INADDR_ANY means loopback (BSD'ism).
955 */
956 if (ipv6_addr_any(&usin->sin6_addr))
957 usin->sin6_addr.s6_addr[15] = 1;
958
959 addr_type = ipv6_addr_type(&usin->sin6_addr);
960
961 if (addr_type & IPV6_ADDR_MULTICAST)
962 return -ENETUNREACH;
963
964 if (addr_type & IPV6_ADDR_LINKLOCAL) {
965 if (addr_len >= sizeof(struct sockaddr_in6) &&
966 usin->sin6_scope_id) {
967 /* If interface is set while binding, indices
968 * must coincide.
969 */
970 if (sk->sk_bound_dev_if &&
971 sk->sk_bound_dev_if != usin->sin6_scope_id)
972 return -EINVAL;
973
974 sk->sk_bound_dev_if = usin->sin6_scope_id;
975 }
976
977 /* Connect to link-local address requires an interface */
978 if (!sk->sk_bound_dev_if)
979 return -EINVAL;
980 }
981
982 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
983 np->flow_label = fl.fl6_flowlabel;
984
985 /*
986 * DCCP over IPv4
987 */
988 if (addr_type == IPV6_ADDR_MAPPED) {
989 u32 exthdrlen = icsk->icsk_ext_hdr_len;
990 struct sockaddr_in sin;
991
992 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
993
994 if (__ipv6_only_sock(sk))
995 return -ENETUNREACH;
996
997 sin.sin_family = AF_INET;
998 sin.sin_port = usin->sin6_port;
999 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
1000
1001 icsk->icsk_af_ops = &dccp_ipv6_mapped;
1002 sk->sk_backlog_rcv = dccp_v4_do_rcv;
1003
1004 err = dccp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
1005 if (err) {
1006 icsk->icsk_ext_hdr_len = exthdrlen;
1007 icsk->icsk_af_ops = &dccp_ipv6_af_ops;
1008 sk->sk_backlog_rcv = dccp_v6_do_rcv;
1009 goto failure;
1010 } else {
1011 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
1012 inet->saddr);
1013 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
1014 inet->rcv_saddr);
1015 }
1016
1017 return err;
1018 }
1019
1020 if (!ipv6_addr_any(&np->rcv_saddr))
1021 saddr = &np->rcv_saddr;
1022
1023 fl.proto = IPPROTO_DCCP;
1024 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
1025 ipv6_addr_copy(&fl.fl6_src, saddr ? saddr : &np->saddr);
1026 fl.oif = sk->sk_bound_dev_if;
1027 fl.fl_ip_dport = usin->sin6_port;
1028 fl.fl_ip_sport = inet->sport;
1029 security_sk_classify_flow(sk, &fl);
1030
1031 if (np->opt != NULL && np->opt->srcrt != NULL) {
1032 const struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
1033
1034 ipv6_addr_copy(&final, &fl.fl6_dst);
1035 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1036 final_p = &final;
1037 }
1038
1039 err = ip6_dst_lookup(sk, &dst, &fl);
1040 if (err)
1041 goto failure;
1042
1043 if (final_p)
1044 ipv6_addr_copy(&fl.fl6_dst, final_p);
1045
1046 err = xfrm_lookup(&dst, &fl, sk, 1);
1047 if (err < 0)
1048 goto failure;
1049
1050 if (saddr == NULL) {
1051 saddr = &fl.fl6_src;
1052 ipv6_addr_copy(&np->rcv_saddr, saddr);
1053 }
1054
1055 /* set the source address */
1056 ipv6_addr_copy(&np->saddr, saddr);
1057 inet->rcv_saddr = LOOPBACK4_IPV6;
1058
1059 __ip6_dst_store(sk, dst, NULL, NULL);
1060
1061 icsk->icsk_ext_hdr_len = 0;
1062 if (np->opt != NULL)
1063 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
1064 np->opt->opt_nflen);
1065
1066 inet->dport = usin->sin6_port;
1067
1068 dccp_set_state(sk, DCCP_REQUESTING);
1069 err = inet6_hash_connect(&dccp_death_row, sk);
1070 if (err)
1071 goto late_failure;
1072
1073 dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,
1074 np->daddr.s6_addr32,
1075 inet->sport, inet->dport);
1076 err = dccp_connect(sk);
1077 if (err)
1078 goto late_failure;
1079
1080 return 0;
1081
1082 late_failure:
1083 dccp_set_state(sk, DCCP_CLOSED);
1084 __sk_dst_reset(sk);
1085 failure:
1086 inet->dport = 0;
1087 sk->sk_route_caps = 0;
1088 return err;
1089 }
1090
1091 static struct inet_connection_sock_af_ops dccp_ipv6_af_ops = {
1092 .queue_xmit = inet6_csk_xmit,
1093 .send_check = dccp_v6_send_check,
1094 .rebuild_header = inet6_sk_rebuild_header,
1095 .conn_request = dccp_v6_conn_request,
1096 .syn_recv_sock = dccp_v6_request_recv_sock,
1097 .net_header_len = sizeof(struct ipv6hdr),
1098 .setsockopt = ipv6_setsockopt,
1099 .getsockopt = ipv6_getsockopt,
1100 .addr2sockaddr = inet6_csk_addr2sockaddr,
1101 .sockaddr_len = sizeof(struct sockaddr_in6),
1102 #ifdef CONFIG_COMPAT
1103 .compat_setsockopt = compat_ipv6_setsockopt,
1104 .compat_getsockopt = compat_ipv6_getsockopt,
1105 #endif
1106 };
1107
1108 /*
1109 * DCCP over IPv4 via INET6 API
1110 */
1111 static struct inet_connection_sock_af_ops dccp_ipv6_mapped = {
1112 .queue_xmit = ip_queue_xmit,
1113 .send_check = dccp_v4_send_check,
1114 .rebuild_header = inet_sk_rebuild_header,
1115 .conn_request = dccp_v6_conn_request,
1116 .syn_recv_sock = dccp_v6_request_recv_sock,
1117 .net_header_len = sizeof(struct iphdr),
1118 .setsockopt = ipv6_setsockopt,
1119 .getsockopt = ipv6_getsockopt,
1120 .addr2sockaddr = inet6_csk_addr2sockaddr,
1121 .sockaddr_len = sizeof(struct sockaddr_in6),
1122 #ifdef CONFIG_COMPAT
1123 .compat_setsockopt = compat_ipv6_setsockopt,
1124 .compat_getsockopt = compat_ipv6_getsockopt,
1125 #endif
1126 };
1127
1128 /* NOTE: A lot of things set to zero explicitly by call to
1129 * sk_alloc() so need not be done here.
1130 */
1131 static int dccp_v6_init_sock(struct sock *sk)
1132 {
1133 static __u8 dccp_v6_ctl_sock_initialized;
1134 int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized);
1135
1136 if (err == 0) {
1137 if (unlikely(!dccp_v6_ctl_sock_initialized))
1138 dccp_v6_ctl_sock_initialized = 1;
1139 inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops;
1140 }
1141
1142 return err;
1143 }
1144
1145 static int dccp_v6_destroy_sock(struct sock *sk)
1146 {
1147 dccp_destroy_sock(sk);
1148 return inet6_destroy_sock(sk);
1149 }
1150
1151 static struct timewait_sock_ops dccp6_timewait_sock_ops = {
1152 .twsk_obj_size = sizeof(struct dccp6_timewait_sock),
1153 };
1154
1155 static struct proto dccp_v6_prot = {
1156 .name = "DCCPv6",
1157 .owner = THIS_MODULE,
1158 .close = dccp_close,
1159 .connect = dccp_v6_connect,
1160 .disconnect = dccp_disconnect,
1161 .ioctl = dccp_ioctl,
1162 .init = dccp_v6_init_sock,
1163 .setsockopt = dccp_setsockopt,
1164 .getsockopt = dccp_getsockopt,
1165 .sendmsg = dccp_sendmsg,
1166 .recvmsg = dccp_recvmsg,
1167 .backlog_rcv = dccp_v6_do_rcv,
1168 .hash = dccp_v6_hash,
1169 .unhash = dccp_unhash,
1170 .accept = inet_csk_accept,
1171 .get_port = dccp_v6_get_port,
1172 .shutdown = dccp_shutdown,
1173 .destroy = dccp_v6_destroy_sock,
1174 .orphan_count = &dccp_orphan_count,
1175 .max_header = MAX_DCCP_HEADER,
1176 .obj_size = sizeof(struct dccp6_sock),
1177 .rsk_prot = &dccp6_request_sock_ops,
1178 .twsk_prot = &dccp6_timewait_sock_ops,
1179 #ifdef CONFIG_COMPAT
1180 .compat_setsockopt = compat_dccp_setsockopt,
1181 .compat_getsockopt = compat_dccp_getsockopt,
1182 #endif
1183 };
1184
1185 static struct inet6_protocol dccp_v6_protocol = {
1186 .handler = dccp_v6_rcv,
1187 .err_handler = dccp_v6_err,
1188 .flags = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
1189 };
1190
1191 static struct proto_ops inet6_dccp_ops = {
1192 .family = PF_INET6,
1193 .owner = THIS_MODULE,
1194 .release = inet6_release,
1195 .bind = inet6_bind,
1196 .connect = inet_stream_connect,
1197 .socketpair = sock_no_socketpair,
1198 .accept = inet_accept,
1199 .getname = inet6_getname,
1200 .poll = dccp_poll,
1201 .ioctl = inet6_ioctl,
1202 .listen = inet_dccp_listen,
1203 .shutdown = inet_shutdown,
1204 .setsockopt = sock_common_setsockopt,
1205 .getsockopt = sock_common_getsockopt,
1206 .sendmsg = inet_sendmsg,
1207 .recvmsg = sock_common_recvmsg,
1208 .mmap = sock_no_mmap,
1209 .sendpage = sock_no_sendpage,
1210 #ifdef CONFIG_COMPAT
1211 .compat_setsockopt = compat_sock_common_setsockopt,
1212 .compat_getsockopt = compat_sock_common_getsockopt,
1213 #endif
1214 };
1215
1216 static struct inet_protosw dccp_v6_protosw = {
1217 .type = SOCK_DCCP,
1218 .protocol = IPPROTO_DCCP,
1219 .prot = &dccp_v6_prot,
1220 .ops = &inet6_dccp_ops,
1221 .capability = -1,
1222 .flags = INET_PROTOSW_ICSK,
1223 };
1224
1225 static int __init dccp_v6_init(void)
1226 {
1227 int err = proto_register(&dccp_v6_prot, 1);
1228
1229 if (err != 0)
1230 goto out;
1231
1232 err = inet6_add_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1233 if (err != 0)
1234 goto out_unregister_proto;
1235
1236 inet6_register_protosw(&dccp_v6_protosw);
1237
1238 err = inet_csk_ctl_sock_create(&dccp_v6_ctl_socket, PF_INET6,
1239 SOCK_DCCP, IPPROTO_DCCP);
1240 if (err != 0)
1241 goto out_unregister_protosw;
1242 out:
1243 return err;
1244 out_unregister_protosw:
1245 inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1246 inet6_unregister_protosw(&dccp_v6_protosw);
1247 out_unregister_proto:
1248 proto_unregister(&dccp_v6_prot);
1249 goto out;
1250 }
1251
1252 static void __exit dccp_v6_exit(void)
1253 {
1254 inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1255 inet6_unregister_protosw(&dccp_v6_protosw);
1256 proto_unregister(&dccp_v6_prot);
1257 }
1258
1259 module_init(dccp_v6_init);
1260 module_exit(dccp_v6_exit);
1261
1262 /*
1263 * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33)
1264 * values directly, Also cover the case where the protocol is not specified,
1265 * i.e. net-pf-PF_INET6-proto-0-type-SOCK_DCCP
1266 */
1267 MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-33-type-6");
1268 MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-0-type-6");
1269 MODULE_LICENSE("GPL");
1270 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
1271 MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol");
Stable & featurefull patchset based on Linus's git branch