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