1
2
3
4
5
6
7
8
9
10
11#include <linux/module.h>
12#include <linux/random.h>
13#include <linux/slab.h>
14#include <linux/xfrm.h>
15#include <linux/string.h>
16
17#include <net/addrconf.h>
18#include <net/inet_common.h>
19#include <net/inet_hashtables.h>
20#include <net/inet_sock.h>
21#include <net/inet6_connection_sock.h>
22#include <net/inet6_hashtables.h>
23#include <net/ip6_route.h>
24#include <net/ipv6.h>
25#include <net/protocol.h>
26#include <net/transp_v6.h>
27#include <net/ip6_checksum.h>
28#include <net/xfrm.h>
29#include <net/secure_seq.h>
30#include <net/netns/generic.h>
31#include <net/sock.h>
32
33#include "dccp.h"
34#include "ipv6.h"
35#include "feat.h"
36
37struct dccp_v6_pernet {
38 struct sock *v6_ctl_sk;
39};
40
41static unsigned int dccp_v6_pernet_id __read_mostly;
42
43
44
45static const struct inet_connection_sock_af_ops dccp_ipv6_mapped;
46static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops;
47
48
49static inline __sum16 dccp_v6_csum_finish(struct sk_buff *skb,
50 const struct in6_addr *saddr,
51 const struct in6_addr *daddr)
52{
53 return csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_DCCP, skb->csum);
54}
55
56static inline void dccp_v6_send_check(struct sock *sk, struct sk_buff *skb)
57{
58 struct ipv6_pinfo *np = inet6_sk(sk);
59 struct dccp_hdr *dh = dccp_hdr(skb);
60
61 dccp_csum_outgoing(skb);
62 dh->dccph_checksum = dccp_v6_csum_finish(skb, &np->saddr, &sk->sk_v6_daddr);
63}
64
65static inline __u64 dccp_v6_init_sequence(struct sk_buff *skb)
66{
67 return secure_dccpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
68 ipv6_hdr(skb)->saddr.s6_addr32,
69 dccp_hdr(skb)->dccph_dport,
70 dccp_hdr(skb)->dccph_sport );
71
72}
73
74static int dccp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
75 u8 type, u8 code, int offset, __be32 info)
76{
77 const struct ipv6hdr *hdr = (const struct ipv6hdr *)skb->data;
78 const struct dccp_hdr *dh;
79 struct dccp_sock *dp;
80 struct ipv6_pinfo *np;
81 struct sock *sk;
82 int err;
83 __u64 seq;
84 struct net *net = dev_net(skb->dev);
85
86
87
88
89
90 BUILD_BUG_ON(offsetofend(struct dccp_hdr, dccph_sport) > 8);
91 BUILD_BUG_ON(offsetofend(struct dccp_hdr, dccph_dport) > 8);
92 dh = (struct dccp_hdr *)(skb->data + offset);
93
94 sk = __inet6_lookup_established(net, &dccp_hashinfo,
95 &hdr->daddr, dh->dccph_dport,
96 &hdr->saddr, ntohs(dh->dccph_sport),
97 inet6_iif(skb), 0);
98
99 if (!sk) {
100 __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev),
101 ICMP6_MIB_INERRORS);
102 return -ENOENT;
103 }
104
105 if (sk->sk_state == DCCP_TIME_WAIT) {
106 inet_twsk_put(inet_twsk(sk));
107 return 0;
108 }
109 seq = dccp_hdr_seq(dh);
110 if (sk->sk_state == DCCP_NEW_SYN_RECV) {
111 dccp_req_err(sk, seq);
112 return 0;
113 }
114
115 bh_lock_sock(sk);
116 if (sock_owned_by_user(sk))
117 __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS);
118
119 if (sk->sk_state == DCCP_CLOSED)
120 goto out;
121
122 dp = dccp_sk(sk);
123 if ((1 << sk->sk_state) & ~(DCCPF_REQUESTING | DCCPF_LISTEN) &&
124 !between48(seq, dp->dccps_awl, dp->dccps_awh)) {
125 __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
126 goto out;
127 }
128
129 np = inet6_sk(sk);
130
131 if (type == NDISC_REDIRECT) {
132 if (!sock_owned_by_user(sk)) {
133 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
134
135 if (dst)
136 dst->ops->redirect(dst, sk, skb);
137 }
138 goto out;
139 }
140
141 if (type == ICMPV6_PKT_TOOBIG) {
142 struct dst_entry *dst = NULL;
143
144 if (!ip6_sk_accept_pmtu(sk))
145 goto out;
146
147 if (sock_owned_by_user(sk))
148 goto out;
149 if ((1 << sk->sk_state) & (DCCPF_LISTEN | DCCPF_CLOSED))
150 goto out;
151
152 dst = inet6_csk_update_pmtu(sk, ntohl(info));
153 if (!dst)
154 goto out;
155
156 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst))
157 dccp_sync_mss(sk, dst_mtu(dst));
158 goto out;
159 }
160
161 icmpv6_err_convert(type, code, &err);
162
163
164 switch (sk->sk_state) {
165 case DCCP_REQUESTING:
166 case DCCP_RESPOND:
167
168 if (!sock_owned_by_user(sk)) {
169 __DCCP_INC_STATS(DCCP_MIB_ATTEMPTFAILS);
170 sk->sk_err = err;
171
172
173
174
175 sk_error_report(sk);
176 dccp_done(sk);
177 } else
178 sk->sk_err_soft = err;
179 goto out;
180 }
181
182 if (!sock_owned_by_user(sk) && np->recverr) {
183 sk->sk_err = err;
184 sk_error_report(sk);
185 } else
186 sk->sk_err_soft = err;
187
188out:
189 bh_unlock_sock(sk);
190 sock_put(sk);
191 return 0;
192}
193
194
195static int dccp_v6_send_response(const struct sock *sk, struct request_sock *req)
196{
197 struct inet_request_sock *ireq = inet_rsk(req);
198 struct ipv6_pinfo *np = inet6_sk(sk);
199 struct sk_buff *skb;
200 struct in6_addr *final_p, final;
201 struct flowi6 fl6;
202 int err = -1;
203 struct dst_entry *dst;
204
205 memset(&fl6, 0, sizeof(fl6));
206 fl6.flowi6_proto = IPPROTO_DCCP;
207 fl6.daddr = ireq->ir_v6_rmt_addr;
208 fl6.saddr = ireq->ir_v6_loc_addr;
209 fl6.flowlabel = 0;
210 fl6.flowi6_oif = ireq->ir_iif;
211 fl6.fl6_dport = ireq->ir_rmt_port;
212 fl6.fl6_sport = htons(ireq->ir_num);
213 security_req_classify_flow(req, flowi6_to_flowi_common(&fl6));
214
215
216 rcu_read_lock();
217 final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt), &final);
218 rcu_read_unlock();
219
220 dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
221 if (IS_ERR(dst)) {
222 err = PTR_ERR(dst);
223 dst = NULL;
224 goto done;
225 }
226
227 skb = dccp_make_response(sk, dst, req);
228 if (skb != NULL) {
229 struct dccp_hdr *dh = dccp_hdr(skb);
230 struct ipv6_txoptions *opt;
231
232 dh->dccph_checksum = dccp_v6_csum_finish(skb,
233 &ireq->ir_v6_loc_addr,
234 &ireq->ir_v6_rmt_addr);
235 fl6.daddr = ireq->ir_v6_rmt_addr;
236 rcu_read_lock();
237 opt = ireq->ipv6_opt;
238 if (!opt)
239 opt = rcu_dereference(np->opt);
240 err = ip6_xmit(sk, skb, &fl6, sk->sk_mark, opt, np->tclass,
241 sk->sk_priority);
242 rcu_read_unlock();
243 err = net_xmit_eval(err);
244 }
245
246done:
247 dst_release(dst);
248 return err;
249}
250
251static void dccp_v6_reqsk_destructor(struct request_sock *req)
252{
253 dccp_feat_list_purge(&dccp_rsk(req)->dreq_featneg);
254 kfree(inet_rsk(req)->ipv6_opt);
255 kfree_skb(inet_rsk(req)->pktopts);
256}
257
258static void dccp_v6_ctl_send_reset(const struct sock *sk, struct sk_buff *rxskb)
259{
260 const struct ipv6hdr *rxip6h;
261 struct sk_buff *skb;
262 struct flowi6 fl6;
263 struct net *net = dev_net(skb_dst(rxskb)->dev);
264 struct dccp_v6_pernet *pn;
265 struct sock *ctl_sk;
266 struct dst_entry *dst;
267
268 if (dccp_hdr(rxskb)->dccph_type == DCCP_PKT_RESET)
269 return;
270
271 if (!ipv6_unicast_destination(rxskb))
272 return;
273
274 pn = net_generic(net, dccp_v6_pernet_id);
275 ctl_sk = pn->v6_ctl_sk;
276 skb = dccp_ctl_make_reset(ctl_sk, rxskb);
277 if (skb == NULL)
278 return;
279
280 rxip6h = ipv6_hdr(rxskb);
281 dccp_hdr(skb)->dccph_checksum = dccp_v6_csum_finish(skb, &rxip6h->saddr,
282 &rxip6h->daddr);
283
284 memset(&fl6, 0, sizeof(fl6));
285 fl6.daddr = rxip6h->saddr;
286 fl6.saddr = rxip6h->daddr;
287
288 fl6.flowi6_proto = IPPROTO_DCCP;
289 fl6.flowi6_oif = inet6_iif(rxskb);
290 fl6.fl6_dport = dccp_hdr(skb)->dccph_dport;
291 fl6.fl6_sport = dccp_hdr(skb)->dccph_sport;
292 security_skb_classify_flow(rxskb, flowi6_to_flowi_common(&fl6));
293
294
295 dst = ip6_dst_lookup_flow(sock_net(ctl_sk), ctl_sk, &fl6, NULL);
296 if (!IS_ERR(dst)) {
297 skb_dst_set(skb, dst);
298 ip6_xmit(ctl_sk, skb, &fl6, 0, NULL, 0, 0);
299 DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
300 DCCP_INC_STATS(DCCP_MIB_OUTRSTS);
301 return;
302 }
303
304 kfree_skb(skb);
305}
306
307static struct request_sock_ops dccp6_request_sock_ops = {
308 .family = AF_INET6,
309 .obj_size = sizeof(struct dccp6_request_sock),
310 .rtx_syn_ack = dccp_v6_send_response,
311 .send_ack = dccp_reqsk_send_ack,
312 .destructor = dccp_v6_reqsk_destructor,
313 .send_reset = dccp_v6_ctl_send_reset,
314 .syn_ack_timeout = dccp_syn_ack_timeout,
315};
316
317static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
318{
319 struct request_sock *req;
320 struct dccp_request_sock *dreq;
321 struct inet_request_sock *ireq;
322 struct ipv6_pinfo *np = inet6_sk(sk);
323 const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
324 struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
325
326 if (skb->protocol == htons(ETH_P_IP))
327 return dccp_v4_conn_request(sk, skb);
328
329 if (!ipv6_unicast_destination(skb))
330 return 0;
331
332 if (ipv6_addr_v4mapped(&ipv6_hdr(skb)->saddr)) {
333 __IP6_INC_STATS(sock_net(sk), NULL, IPSTATS_MIB_INHDRERRORS);
334 return 0;
335 }
336
337 if (dccp_bad_service_code(sk, service)) {
338 dcb->dccpd_reset_code = DCCP_RESET_CODE_BAD_SERVICE_CODE;
339 goto drop;
340 }
341
342
343
344 dcb->dccpd_reset_code = DCCP_RESET_CODE_TOO_BUSY;
345 if (inet_csk_reqsk_queue_is_full(sk))
346 goto drop;
347
348 if (sk_acceptq_is_full(sk))
349 goto drop;
350
351 req = inet_reqsk_alloc(&dccp6_request_sock_ops, sk, true);
352 if (req == NULL)
353 goto drop;
354
355 if (dccp_reqsk_init(req, dccp_sk(sk), skb))
356 goto drop_and_free;
357
358 dreq = dccp_rsk(req);
359 if (dccp_parse_options(sk, dreq, skb))
360 goto drop_and_free;
361
362 if (security_inet_conn_request(sk, skb, req))
363 goto drop_and_free;
364
365 ireq = inet_rsk(req);
366 ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
367 ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
368 ireq->ireq_family = AF_INET6;
369 ireq->ir_mark = inet_request_mark(sk, skb);
370
371 if (ipv6_opt_accepted(sk, skb, IP6CB(skb)) ||
372 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
373 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
374 refcount_inc(&skb->users);
375 ireq->pktopts = skb;
376 }
377 ireq->ir_iif = sk->sk_bound_dev_if;
378
379
380 if (!sk->sk_bound_dev_if &&
381 ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
382 ireq->ir_iif = inet6_iif(skb);
383
384
385
386
387
388
389
390
391 dreq->dreq_isr = dcb->dccpd_seq;
392 dreq->dreq_gsr = dreq->dreq_isr;
393 dreq->dreq_iss = dccp_v6_init_sequence(skb);
394 dreq->dreq_gss = dreq->dreq_iss;
395 dreq->dreq_service = service;
396
397 if (dccp_v6_send_response(sk, req))
398 goto drop_and_free;
399
400 inet_csk_reqsk_queue_hash_add(sk, req, DCCP_TIMEOUT_INIT);
401 reqsk_put(req);
402 return 0;
403
404drop_and_free:
405 reqsk_free(req);
406drop:
407 __DCCP_INC_STATS(DCCP_MIB_ATTEMPTFAILS);
408 return -1;
409}
410
411static struct sock *dccp_v6_request_recv_sock(const struct sock *sk,
412 struct sk_buff *skb,
413 struct request_sock *req,
414 struct dst_entry *dst,
415 struct request_sock *req_unhash,
416 bool *own_req)
417{
418 struct inet_request_sock *ireq = inet_rsk(req);
419 struct ipv6_pinfo *newnp;
420 const struct ipv6_pinfo *np = inet6_sk(sk);
421 struct ipv6_txoptions *opt;
422 struct inet_sock *newinet;
423 struct dccp6_sock *newdp6;
424 struct sock *newsk;
425
426 if (skb->protocol == htons(ETH_P_IP)) {
427
428
429
430 newsk = dccp_v4_request_recv_sock(sk, skb, req, dst,
431 req_unhash, own_req);
432 if (newsk == NULL)
433 return NULL;
434
435 newdp6 = (struct dccp6_sock *)newsk;
436 newinet = inet_sk(newsk);
437 newinet->pinet6 = &newdp6->inet6;
438 newnp = inet6_sk(newsk);
439
440 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
441
442 newnp->saddr = newsk->sk_v6_rcv_saddr;
443
444 inet_csk(newsk)->icsk_af_ops = &dccp_ipv6_mapped;
445 newsk->sk_backlog_rcv = dccp_v4_do_rcv;
446 newnp->pktoptions = NULL;
447 newnp->opt = NULL;
448 newnp->ipv6_mc_list = NULL;
449 newnp->ipv6_ac_list = NULL;
450 newnp->ipv6_fl_list = NULL;
451 newnp->mcast_oif = inet_iif(skb);
452 newnp->mcast_hops = ip_hdr(skb)->ttl;
453
454
455
456
457
458
459
460
461
462
463
464 dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
465
466 return newsk;
467 }
468
469
470 if (sk_acceptq_is_full(sk))
471 goto out_overflow;
472
473 if (!dst) {
474 struct flowi6 fl6;
475
476 dst = inet6_csk_route_req(sk, &fl6, req, IPPROTO_DCCP);
477 if (!dst)
478 goto out;
479 }
480
481 newsk = dccp_create_openreq_child(sk, req, skb);
482 if (newsk == NULL)
483 goto out_nonewsk;
484
485
486
487
488
489
490
491 ip6_dst_store(newsk, dst, NULL, NULL);
492 newsk->sk_route_caps = dst->dev->features & ~(NETIF_F_IP_CSUM |
493 NETIF_F_TSO);
494 newdp6 = (struct dccp6_sock *)newsk;
495 newinet = inet_sk(newsk);
496 newinet->pinet6 = &newdp6->inet6;
497 newnp = inet6_sk(newsk);
498
499 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
500
501 newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
502 newnp->saddr = ireq->ir_v6_loc_addr;
503 newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
504 newsk->sk_bound_dev_if = ireq->ir_iif;
505
506
507
508
509
510 newinet->inet_opt = NULL;
511
512
513 newnp->rxopt.all = np->rxopt.all;
514
515 newnp->ipv6_mc_list = NULL;
516 newnp->ipv6_ac_list = NULL;
517 newnp->ipv6_fl_list = NULL;
518 newnp->pktoptions = NULL;
519 newnp->opt = NULL;
520 newnp->mcast_oif = inet6_iif(skb);
521 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
522
523
524
525
526
527
528
529 opt = ireq->ipv6_opt;
530 if (!opt)
531 opt = rcu_dereference(np->opt);
532 if (opt) {
533 opt = ipv6_dup_options(newsk, opt);
534 RCU_INIT_POINTER(newnp->opt, opt);
535 }
536 inet_csk(newsk)->icsk_ext_hdr_len = 0;
537 if (opt)
538 inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen +
539 opt->opt_flen;
540
541 dccp_sync_mss(newsk, dst_mtu(dst));
542
543 newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
544 newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
545
546 if (__inet_inherit_port(sk, newsk) < 0) {
547 inet_csk_prepare_forced_close(newsk);
548 dccp_done(newsk);
549 goto out;
550 }
551 *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash), NULL);
552
553 if (*own_req && ireq->pktopts) {
554 newnp->pktoptions = skb_clone(ireq->pktopts, GFP_ATOMIC);
555 consume_skb(ireq->pktopts);
556 ireq->pktopts = NULL;
557 if (newnp->pktoptions)
558 skb_set_owner_r(newnp->pktoptions, newsk);
559 }
560
561 return newsk;
562
563out_overflow:
564 __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
565out_nonewsk:
566 dst_release(dst);
567out:
568 __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENDROPS);
569 return NULL;
570}
571
572
573
574
575
576
577
578
579
580static int dccp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
581{
582 struct ipv6_pinfo *np = inet6_sk(sk);
583 struct sk_buff *opt_skb = NULL;
584
585
586
587
588
589
590
591
592
593 if (skb->protocol == htons(ETH_P_IP))
594 return dccp_v4_do_rcv(sk, skb);
595
596 if (sk_filter(sk, skb))
597 goto discard;
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617 if (np->rxopt.all)
618 opt_skb = skb_clone(skb, GFP_ATOMIC);
619
620 if (sk->sk_state == DCCP_OPEN) {
621 if (dccp_rcv_established(sk, skb, dccp_hdr(skb), skb->len))
622 goto reset;
623 if (opt_skb)
624 goto ipv6_pktoptions;
625 return 0;
626 }
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653 if (dccp_rcv_state_process(sk, skb, dccp_hdr(skb), skb->len))
654 goto reset;
655 if (opt_skb)
656 goto ipv6_pktoptions;
657 return 0;
658
659reset:
660 dccp_v6_ctl_send_reset(sk, skb);
661discard:
662 if (opt_skb != NULL)
663 __kfree_skb(opt_skb);
664 kfree_skb(skb);
665 return 0;
666
667
668
669
670ipv6_pktoptions:
671 if (!((1 << sk->sk_state) & (DCCPF_CLOSED | DCCPF_LISTEN))) {
672 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
673 np->mcast_oif = inet6_iif(opt_skb);
674 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
675 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
676 if (np->rxopt.bits.rxflow || np->rxopt.bits.rxtclass)
677 np->rcv_flowinfo = ip6_flowinfo(ipv6_hdr(opt_skb));
678 if (np->repflow)
679 np->flow_label = ip6_flowlabel(ipv6_hdr(opt_skb));
680 if (ipv6_opt_accepted(sk, opt_skb,
681 &DCCP_SKB_CB(opt_skb)->header.h6)) {
682 skb_set_owner_r(opt_skb, sk);
683 memmove(IP6CB(opt_skb),
684 &DCCP_SKB_CB(opt_skb)->header.h6,
685 sizeof(struct inet6_skb_parm));
686 opt_skb = xchg(&np->pktoptions, opt_skb);
687 } else {
688 __kfree_skb(opt_skb);
689 opt_skb = xchg(&np->pktoptions, NULL);
690 }
691 }
692
693 kfree_skb(opt_skb);
694 return 0;
695}
696
697static int dccp_v6_rcv(struct sk_buff *skb)
698{
699 const struct dccp_hdr *dh;
700 bool refcounted;
701 struct sock *sk;
702 int min_cov;
703
704
705
706 if (dccp_invalid_packet(skb))
707 goto discard_it;
708
709
710 if (dccp_v6_csum_finish(skb, &ipv6_hdr(skb)->saddr,
711 &ipv6_hdr(skb)->daddr)) {
712 DCCP_WARN("dropped packet with invalid checksum\n");
713 goto discard_it;
714 }
715
716 dh = dccp_hdr(skb);
717
718 DCCP_SKB_CB(skb)->dccpd_seq = dccp_hdr_seq(dh);
719 DCCP_SKB_CB(skb)->dccpd_type = dh->dccph_type;
720
721 if (dccp_packet_without_ack(skb))
722 DCCP_SKB_CB(skb)->dccpd_ack_seq = DCCP_PKT_WITHOUT_ACK_SEQ;
723 else
724 DCCP_SKB_CB(skb)->dccpd_ack_seq = dccp_hdr_ack_seq(skb);
725
726lookup:
727 sk = __inet6_lookup_skb(&dccp_hashinfo, skb, __dccp_hdr_len(dh),
728 dh->dccph_sport, dh->dccph_dport,
729 inet6_iif(skb), 0, &refcounted);
730 if (!sk) {
731 dccp_pr_debug("failed to look up flow ID in table and "
732 "get corresponding socket\n");
733 goto no_dccp_socket;
734 }
735
736
737
738
739
740
741
742 if (sk->sk_state == DCCP_TIME_WAIT) {
743 dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: do_time_wait\n");
744 inet_twsk_put(inet_twsk(sk));
745 goto no_dccp_socket;
746 }
747
748 if (sk->sk_state == DCCP_NEW_SYN_RECV) {
749 struct request_sock *req = inet_reqsk(sk);
750 struct sock *nsk;
751
752 sk = req->rsk_listener;
753 if (unlikely(sk->sk_state != DCCP_LISTEN)) {
754 inet_csk_reqsk_queue_drop_and_put(sk, req);
755 goto lookup;
756 }
757 sock_hold(sk);
758 refcounted = true;
759 nsk = dccp_check_req(sk, skb, req);
760 if (!nsk) {
761 reqsk_put(req);
762 goto discard_and_relse;
763 }
764 if (nsk == sk) {
765 reqsk_put(req);
766 } else if (dccp_child_process(sk, nsk, skb)) {
767 dccp_v6_ctl_send_reset(sk, skb);
768 goto discard_and_relse;
769 } else {
770 sock_put(sk);
771 return 0;
772 }
773 }
774
775
776
777
778
779 min_cov = dccp_sk(sk)->dccps_pcrlen;
780 if (dh->dccph_cscov && (min_cov == 0 || dh->dccph_cscov < min_cov)) {
781 dccp_pr_debug("Packet CsCov %d does not satisfy MinCsCov %d\n",
782 dh->dccph_cscov, min_cov);
783
784 goto discard_and_relse;
785 }
786
787 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
788 goto discard_and_relse;
789
790 return __sk_receive_skb(sk, skb, 1, dh->dccph_doff * 4,
791 refcounted) ? -1 : 0;
792
793no_dccp_socket:
794 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
795 goto discard_it;
796
797
798
799
800
801
802 if (dh->dccph_type != DCCP_PKT_RESET) {
803 DCCP_SKB_CB(skb)->dccpd_reset_code =
804 DCCP_RESET_CODE_NO_CONNECTION;
805 dccp_v6_ctl_send_reset(sk, skb);
806 }
807
808discard_it:
809 kfree_skb(skb);
810 return 0;
811
812discard_and_relse:
813 if (refcounted)
814 sock_put(sk);
815 goto discard_it;
816}
817
818static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
819 int addr_len)
820{
821 struct sockaddr_in6 *usin = (struct sockaddr_in6 *)uaddr;
822 struct inet_connection_sock *icsk = inet_csk(sk);
823 struct inet_sock *inet = inet_sk(sk);
824 struct ipv6_pinfo *np = inet6_sk(sk);
825 struct dccp_sock *dp = dccp_sk(sk);
826 struct in6_addr *saddr = NULL, *final_p, final;
827 struct ipv6_txoptions *opt;
828 struct flowi6 fl6;
829 struct dst_entry *dst;
830 int addr_type;
831 int err;
832
833 dp->dccps_role = DCCP_ROLE_CLIENT;
834
835 if (addr_len < SIN6_LEN_RFC2133)
836 return -EINVAL;
837
838 if (usin->sin6_family != AF_INET6)
839 return -EAFNOSUPPORT;
840
841 memset(&fl6, 0, sizeof(fl6));
842
843 if (np->sndflow) {
844 fl6.flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
845 IP6_ECN_flow_init(fl6.flowlabel);
846 if (fl6.flowlabel & IPV6_FLOWLABEL_MASK) {
847 struct ip6_flowlabel *flowlabel;
848 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
849 if (IS_ERR(flowlabel))
850 return -EINVAL;
851 fl6_sock_release(flowlabel);
852 }
853 }
854
855
856
857 if (ipv6_addr_any(&usin->sin6_addr))
858 usin->sin6_addr.s6_addr[15] = 1;
859
860 addr_type = ipv6_addr_type(&usin->sin6_addr);
861
862 if (addr_type & IPV6_ADDR_MULTICAST)
863 return -ENETUNREACH;
864
865 if (addr_type & IPV6_ADDR_LINKLOCAL) {
866 if (addr_len >= sizeof(struct sockaddr_in6) &&
867 usin->sin6_scope_id) {
868
869
870
871 if (sk->sk_bound_dev_if &&
872 sk->sk_bound_dev_if != usin->sin6_scope_id)
873 return -EINVAL;
874
875 sk->sk_bound_dev_if = usin->sin6_scope_id;
876 }
877
878
879 if (!sk->sk_bound_dev_if)
880 return -EINVAL;
881 }
882
883 sk->sk_v6_daddr = usin->sin6_addr;
884 np->flow_label = fl6.flowlabel;
885
886
887
888
889 if (addr_type == IPV6_ADDR_MAPPED) {
890 u32 exthdrlen = icsk->icsk_ext_hdr_len;
891 struct sockaddr_in sin;
892
893 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
894
895 if (__ipv6_only_sock(sk))
896 return -ENETUNREACH;
897
898 sin.sin_family = AF_INET;
899 sin.sin_port = usin->sin6_port;
900 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
901
902 icsk->icsk_af_ops = &dccp_ipv6_mapped;
903 sk->sk_backlog_rcv = dccp_v4_do_rcv;
904
905 err = dccp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
906 if (err) {
907 icsk->icsk_ext_hdr_len = exthdrlen;
908 icsk->icsk_af_ops = &dccp_ipv6_af_ops;
909 sk->sk_backlog_rcv = dccp_v6_do_rcv;
910 goto failure;
911 }
912 np->saddr = sk->sk_v6_rcv_saddr;
913 return err;
914 }
915
916 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
917 saddr = &sk->sk_v6_rcv_saddr;
918
919 fl6.flowi6_proto = IPPROTO_DCCP;
920 fl6.daddr = sk->sk_v6_daddr;
921 fl6.saddr = saddr ? *saddr : np->saddr;
922 fl6.flowi6_oif = sk->sk_bound_dev_if;
923 fl6.fl6_dport = usin->sin6_port;
924 fl6.fl6_sport = inet->inet_sport;
925 security_sk_classify_flow(sk, flowi6_to_flowi_common(&fl6));
926
927 opt = rcu_dereference_protected(np->opt, lockdep_sock_is_held(sk));
928 final_p = fl6_update_dst(&fl6, opt, &final);
929
930 dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
931 if (IS_ERR(dst)) {
932 err = PTR_ERR(dst);
933 goto failure;
934 }
935
936 if (saddr == NULL) {
937 saddr = &fl6.saddr;
938 sk->sk_v6_rcv_saddr = *saddr;
939 }
940
941
942 np->saddr = *saddr;
943 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
944
945 ip6_dst_store(sk, dst, NULL, NULL);
946
947 icsk->icsk_ext_hdr_len = 0;
948 if (opt)
949 icsk->icsk_ext_hdr_len = opt->opt_flen + opt->opt_nflen;
950
951 inet->inet_dport = usin->sin6_port;
952
953 dccp_set_state(sk, DCCP_REQUESTING);
954 err = inet6_hash_connect(&dccp_death_row, sk);
955 if (err)
956 goto late_failure;
957
958 dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,
959 sk->sk_v6_daddr.s6_addr32,
960 inet->inet_sport,
961 inet->inet_dport);
962 err = dccp_connect(sk);
963 if (err)
964 goto late_failure;
965
966 return 0;
967
968late_failure:
969 dccp_set_state(sk, DCCP_CLOSED);
970 __sk_dst_reset(sk);
971failure:
972 inet->inet_dport = 0;
973 sk->sk_route_caps = 0;
974 return err;
975}
976
977static const struct inet_connection_sock_af_ops dccp_ipv6_af_ops = {
978 .queue_xmit = inet6_csk_xmit,
979 .send_check = dccp_v6_send_check,
980 .rebuild_header = inet6_sk_rebuild_header,
981 .conn_request = dccp_v6_conn_request,
982 .syn_recv_sock = dccp_v6_request_recv_sock,
983 .net_header_len = sizeof(struct ipv6hdr),
984 .setsockopt = ipv6_setsockopt,
985 .getsockopt = ipv6_getsockopt,
986 .addr2sockaddr = inet6_csk_addr2sockaddr,
987 .sockaddr_len = sizeof(struct sockaddr_in6),
988};
989
990
991
992
993static const struct inet_connection_sock_af_ops dccp_ipv6_mapped = {
994 .queue_xmit = ip_queue_xmit,
995 .send_check = dccp_v4_send_check,
996 .rebuild_header = inet_sk_rebuild_header,
997 .conn_request = dccp_v6_conn_request,
998 .syn_recv_sock = dccp_v6_request_recv_sock,
999 .net_header_len = sizeof(struct iphdr),
1000 .setsockopt = ipv6_setsockopt,
1001 .getsockopt = ipv6_getsockopt,
1002 .addr2sockaddr = inet6_csk_addr2sockaddr,
1003 .sockaddr_len = sizeof(struct sockaddr_in6),
1004};
1005
1006
1007
1008
1009static int dccp_v6_init_sock(struct sock *sk)
1010{
1011 static __u8 dccp_v6_ctl_sock_initialized;
1012 int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized);
1013
1014 if (err == 0) {
1015 if (unlikely(!dccp_v6_ctl_sock_initialized))
1016 dccp_v6_ctl_sock_initialized = 1;
1017 inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops;
1018 }
1019
1020 return err;
1021}
1022
1023static void dccp_v6_destroy_sock(struct sock *sk)
1024{
1025 dccp_destroy_sock(sk);
1026 inet6_destroy_sock(sk);
1027}
1028
1029static struct timewait_sock_ops dccp6_timewait_sock_ops = {
1030 .twsk_obj_size = sizeof(struct dccp6_timewait_sock),
1031};
1032
1033static struct proto dccp_v6_prot = {
1034 .name = "DCCPv6",
1035 .owner = THIS_MODULE,
1036 .close = dccp_close,
1037 .connect = dccp_v6_connect,
1038 .disconnect = dccp_disconnect,
1039 .ioctl = dccp_ioctl,
1040 .init = dccp_v6_init_sock,
1041 .setsockopt = dccp_setsockopt,
1042 .getsockopt = dccp_getsockopt,
1043 .sendmsg = dccp_sendmsg,
1044 .recvmsg = dccp_recvmsg,
1045 .backlog_rcv = dccp_v6_do_rcv,
1046 .hash = inet6_hash,
1047 .unhash = inet_unhash,
1048 .accept = inet_csk_accept,
1049 .get_port = inet_csk_get_port,
1050 .shutdown = dccp_shutdown,
1051 .destroy = dccp_v6_destroy_sock,
1052 .orphan_count = &dccp_orphan_count,
1053 .max_header = MAX_DCCP_HEADER,
1054 .obj_size = sizeof(struct dccp6_sock),
1055 .slab_flags = SLAB_TYPESAFE_BY_RCU,
1056 .rsk_prot = &dccp6_request_sock_ops,
1057 .twsk_prot = &dccp6_timewait_sock_ops,
1058 .h.hashinfo = &dccp_hashinfo,
1059};
1060
1061static const struct inet6_protocol dccp_v6_protocol = {
1062 .handler = dccp_v6_rcv,
1063 .err_handler = dccp_v6_err,
1064 .flags = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
1065};
1066
1067static const struct proto_ops inet6_dccp_ops = {
1068 .family = PF_INET6,
1069 .owner = THIS_MODULE,
1070 .release = inet6_release,
1071 .bind = inet6_bind,
1072 .connect = inet_stream_connect,
1073 .socketpair = sock_no_socketpair,
1074 .accept = inet_accept,
1075 .getname = inet6_getname,
1076 .poll = dccp_poll,
1077 .ioctl = inet6_ioctl,
1078 .gettstamp = sock_gettstamp,
1079 .listen = inet_dccp_listen,
1080 .shutdown = inet_shutdown,
1081 .setsockopt = sock_common_setsockopt,
1082 .getsockopt = sock_common_getsockopt,
1083 .sendmsg = inet_sendmsg,
1084 .recvmsg = sock_common_recvmsg,
1085 .mmap = sock_no_mmap,
1086 .sendpage = sock_no_sendpage,
1087#ifdef CONFIG_COMPAT
1088 .compat_ioctl = inet6_compat_ioctl,
1089#endif
1090};
1091
1092static struct inet_protosw dccp_v6_protosw = {
1093 .type = SOCK_DCCP,
1094 .protocol = IPPROTO_DCCP,
1095 .prot = &dccp_v6_prot,
1096 .ops = &inet6_dccp_ops,
1097 .flags = INET_PROTOSW_ICSK,
1098};
1099
1100static int __net_init dccp_v6_init_net(struct net *net)
1101{
1102 struct dccp_v6_pernet *pn = net_generic(net, dccp_v6_pernet_id);
1103
1104 if (dccp_hashinfo.bhash == NULL)
1105 return -ESOCKTNOSUPPORT;
1106
1107 return inet_ctl_sock_create(&pn->v6_ctl_sk, PF_INET6,
1108 SOCK_DCCP, IPPROTO_DCCP, net);
1109}
1110
1111static void __net_exit dccp_v6_exit_net(struct net *net)
1112{
1113 struct dccp_v6_pernet *pn = net_generic(net, dccp_v6_pernet_id);
1114
1115 inet_ctl_sock_destroy(pn->v6_ctl_sk);
1116}
1117
1118static void __net_exit dccp_v6_exit_batch(struct list_head *net_exit_list)
1119{
1120 inet_twsk_purge(&dccp_hashinfo, AF_INET6);
1121}
1122
1123static struct pernet_operations dccp_v6_ops = {
1124 .init = dccp_v6_init_net,
1125 .exit = dccp_v6_exit_net,
1126 .exit_batch = dccp_v6_exit_batch,
1127 .id = &dccp_v6_pernet_id,
1128 .size = sizeof(struct dccp_v6_pernet),
1129};
1130
1131static int __init dccp_v6_init(void)
1132{
1133 int err = proto_register(&dccp_v6_prot, 1);
1134
1135 if (err)
1136 goto out;
1137
1138 inet6_register_protosw(&dccp_v6_protosw);
1139
1140 err = register_pernet_subsys(&dccp_v6_ops);
1141 if (err)
1142 goto out_destroy_ctl_sock;
1143
1144 err = inet6_add_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1145 if (err)
1146 goto out_unregister_proto;
1147
1148out:
1149 return err;
1150out_unregister_proto:
1151 unregister_pernet_subsys(&dccp_v6_ops);
1152out_destroy_ctl_sock:
1153 inet6_unregister_protosw(&dccp_v6_protosw);
1154 proto_unregister(&dccp_v6_prot);
1155 goto out;
1156}
1157
1158static void __exit dccp_v6_exit(void)
1159{
1160 inet6_del_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
1161 unregister_pernet_subsys(&dccp_v6_ops);
1162 inet6_unregister_protosw(&dccp_v6_protosw);
1163 proto_unregister(&dccp_v6_prot);
1164}
1165
1166module_init(dccp_v6_init);
1167module_exit(dccp_v6_exit);
1168
1169
1170
1171
1172
1173
1174MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 33, 6);
1175MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 0, 6);
1176MODULE_LICENSE("GPL");
1177MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
1178MODULE_DESCRIPTION("DCCPv6 - Datagram Congestion Controlled Protocol");
1179