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