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