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