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