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