4 * An implementation of the DCCP protocol
5 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
13 #include <linux/config.h>
14 #include <linux/dccp.h>
15 #include <linux/icmp.h>
16 #include <linux/module.h>
17 #include <linux/skbuff.h>
18 #include <linux/random.h>
21 #include <net/inet_hashtables.h>
22 #include <net/inet_sock.h>
24 #include <net/timewait_sock.h>
25 #include <net/tcp_states.h>
32 struct inet_hashinfo __cacheline_aligned dccp_hashinfo
= {
33 .lhash_lock
= RW_LOCK_UNLOCKED
,
34 .lhash_users
= ATOMIC_INIT(0),
35 .lhash_wait
= __WAIT_QUEUE_HEAD_INITIALIZER(dccp_hashinfo
.lhash_wait
),
38 EXPORT_SYMBOL_GPL(dccp_hashinfo
);
40 static int dccp_v4_get_port(struct sock
*sk
, const unsigned short snum
)
42 return inet_csk_get_port(&dccp_hashinfo
, sk
, snum
,
43 inet_csk_bind_conflict
);
46 static void dccp_v4_hash(struct sock
*sk
)
48 inet_hash(&dccp_hashinfo
, sk
);
51 void dccp_unhash(struct sock
*sk
)
53 inet_unhash(&dccp_hashinfo
, sk
);
56 EXPORT_SYMBOL_GPL(dccp_unhash
);
58 int dccp_v4_connect(struct sock
*sk
, struct sockaddr
*uaddr
, int addr_len
)
60 struct inet_sock
*inet
= inet_sk(sk
);
61 struct dccp_sock
*dp
= dccp_sk(sk
);
62 const struct sockaddr_in
*usin
= (struct sockaddr_in
*)uaddr
;
68 dp
->dccps_role
= DCCP_ROLE_CLIENT
;
70 if (dccp_service_not_initialized(sk
))
73 if (addr_len
< sizeof(struct sockaddr_in
))
76 if (usin
->sin_family
!= AF_INET
)
79 nexthop
= daddr
= usin
->sin_addr
.s_addr
;
80 if (inet
->opt
!= NULL
&& inet
->opt
->srr
) {
83 nexthop
= inet
->opt
->faddr
;
86 tmp
= ip_route_connect(&rt
, nexthop
, inet
->saddr
,
87 RT_CONN_FLAGS(sk
), sk
->sk_bound_dev_if
,
89 inet
->sport
, usin
->sin_port
, sk
);
93 if (rt
->rt_flags
& (RTCF_MULTICAST
| RTCF_BROADCAST
)) {
98 if (inet
->opt
== NULL
|| !inet
->opt
->srr
)
101 if (inet
->saddr
== 0)
102 inet
->saddr
= rt
->rt_src
;
103 inet
->rcv_saddr
= inet
->saddr
;
105 inet
->dport
= usin
->sin_port
;
108 inet_csk(sk
)->icsk_ext_hdr_len
= 0;
109 if (inet
->opt
!= NULL
)
110 inet_csk(sk
)->icsk_ext_hdr_len
= inet
->opt
->optlen
;
112 * Socket identity is still unknown (sport may be zero).
113 * However we set state to DCCP_REQUESTING and not releasing socket
114 * lock select source port, enter ourselves into the hash tables and
115 * complete initialization after this.
117 dccp_set_state(sk
, DCCP_REQUESTING
);
118 err
= inet_hash_connect(&dccp_death_row
, sk
);
122 err
= ip_route_newports(&rt
, IPPROTO_DCCP
, inet
->sport
, inet
->dport
,
127 /* OK, now commit destination to socket. */
128 sk_setup_caps(sk
, &rt
->u
.dst
);
131 dp
->dccps_iss
= secure_dccp_sequence_number(inet
->saddr
,
135 dccp_update_gss(sk
, dp
->dccps_iss
);
137 inet
->id
= dp
->dccps_iss
^ jiffies
;
139 err
= dccp_connect(sk
);
147 * This unhashes the socket and releases the local port, if necessary.
149 dccp_set_state(sk
, DCCP_CLOSED
);
151 sk
->sk_route_caps
= 0;
156 EXPORT_SYMBOL_GPL(dccp_v4_connect
);
159 * This routine does path mtu discovery as defined in RFC1191.
161 static inline void dccp_do_pmtu_discovery(struct sock
*sk
,
162 const struct iphdr
*iph
,
165 struct dst_entry
*dst
;
166 const struct inet_sock
*inet
= inet_sk(sk
);
167 const struct dccp_sock
*dp
= dccp_sk(sk
);
169 /* We are not interested in DCCP_LISTEN and request_socks (RESPONSEs
170 * send out by Linux are always < 576bytes so they should go through
173 if (sk
->sk_state
== DCCP_LISTEN
)
176 /* We don't check in the destentry if pmtu discovery is forbidden
177 * on this route. We just assume that no packet_to_big packets
178 * are send back when pmtu discovery is not active.
179 * There is a small race when the user changes this flag in the
180 * route, but I think that's acceptable.
182 if ((dst
= __sk_dst_check(sk
, 0)) == NULL
)
185 dst
->ops
->update_pmtu(dst
, mtu
);
187 /* Something is about to be wrong... Remember soft error
188 * for the case, if this connection will not able to recover.
190 if (mtu
< dst_mtu(dst
) && ip_dont_fragment(sk
, dst
))
191 sk
->sk_err_soft
= EMSGSIZE
;
195 if (inet
->pmtudisc
!= IP_PMTUDISC_DONT
&&
196 inet_csk(sk
)->icsk_pmtu_cookie
> mtu
) {
197 dccp_sync_mss(sk
, mtu
);
200 * From: draft-ietf-dccp-spec-11.txt
202 * DCCP-Sync packets are the best choice for upward
203 * probing, since DCCP-Sync probes do not risk application
206 dccp_send_sync(sk
, dp
->dccps_gsr
, DCCP_PKT_SYNC
);
207 } /* else let the usual retransmit timer handle it */
210 static void dccp_v4_ctl_send_ack(struct sk_buff
*rxskb
)
213 struct dccp_hdr
*rxdh
= dccp_hdr(rxskb
), *dh
;
214 const int dccp_hdr_ack_len
= sizeof(struct dccp_hdr
) +
215 sizeof(struct dccp_hdr_ext
) +
216 sizeof(struct dccp_hdr_ack_bits
);
219 if (((struct rtable
*)rxskb
->dst
)->rt_type
!= RTN_LOCAL
)
222 skb
= alloc_skb(MAX_DCCP_HEADER
+ 15, GFP_ATOMIC
);
226 /* Reserve space for headers. */
227 skb_reserve(skb
, MAX_DCCP_HEADER
);
229 skb
->dst
= dst_clone(rxskb
->dst
);
231 skb
->h
.raw
= skb_push(skb
, dccp_hdr_ack_len
);
233 memset(dh
, 0, dccp_hdr_ack_len
);
235 /* Build DCCP header and checksum it. */
236 dh
->dccph_type
= DCCP_PKT_ACK
;
237 dh
->dccph_sport
= rxdh
->dccph_dport
;
238 dh
->dccph_dport
= rxdh
->dccph_sport
;
239 dh
->dccph_doff
= dccp_hdr_ack_len
/ 4;
242 dccp_hdr_set_seq(dh
, DCCP_SKB_CB(rxskb
)->dccpd_ack_seq
);
243 dccp_hdr_set_ack(dccp_hdr_ack_bits(skb
),
244 DCCP_SKB_CB(rxskb
)->dccpd_seq
);
246 bh_lock_sock(dccp_ctl_socket
->sk
);
247 err
= ip_build_and_send_pkt(skb
, dccp_ctl_socket
->sk
,
248 rxskb
->nh
.iph
->daddr
,
249 rxskb
->nh
.iph
->saddr
, NULL
);
250 bh_unlock_sock(dccp_ctl_socket
->sk
);
252 if (err
== NET_XMIT_CN
|| err
== 0) {
253 DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS
);
254 DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS
);
258 static void dccp_v4_reqsk_send_ack(struct sk_buff
*skb
,
259 struct request_sock
*req
)
261 dccp_v4_ctl_send_ack(skb
);
264 static int dccp_v4_send_response(struct sock
*sk
, struct request_sock
*req
,
265 struct dst_entry
*dst
)
270 /* First, grab a route. */
272 if (dst
== NULL
&& (dst
= inet_csk_route_req(sk
, req
)) == NULL
)
275 skb
= dccp_make_response(sk
, dst
, req
);
277 const struct inet_request_sock
*ireq
= inet_rsk(req
);
279 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
280 err
= ip_build_and_send_pkt(skb
, sk
, ireq
->loc_addr
,
283 if (err
== NET_XMIT_CN
)
293 * This routine is called by the ICMP module when it gets some sort of error
294 * condition. If err < 0 then the socket should be closed and the error
295 * returned to the user. If err > 0 it's just the icmp type << 8 | icmp code.
296 * After adjustment header points to the first 8 bytes of the tcp header. We
297 * need to find the appropriate port.
299 * The locking strategy used here is very "optimistic". When someone else
300 * accesses the socket the ICMP is just dropped and for some paths there is no
301 * check at all. A more general error queue to queue errors for later handling
302 * is probably better.
304 void dccp_v4_err(struct sk_buff
*skb
, u32 info
)
306 const struct iphdr
*iph
= (struct iphdr
*)skb
->data
;
307 const struct dccp_hdr
*dh
= (struct dccp_hdr
*)(skb
->data
+
309 struct dccp_sock
*dp
;
310 struct inet_sock
*inet
;
311 const int type
= skb
->h
.icmph
->type
;
312 const int code
= skb
->h
.icmph
->code
;
317 if (skb
->len
< (iph
->ihl
<< 2) + 8) {
318 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS
);
322 sk
= inet_lookup(&dccp_hashinfo
, iph
->daddr
, dh
->dccph_dport
,
323 iph
->saddr
, dh
->dccph_sport
, inet_iif(skb
));
325 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS
);
329 if (sk
->sk_state
== DCCP_TIME_WAIT
) {
330 inet_twsk_put((struct inet_timewait_sock
*)sk
);
335 /* If too many ICMPs get dropped on busy
336 * servers this needs to be solved differently.
338 if (sock_owned_by_user(sk
))
339 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS
);
341 if (sk
->sk_state
== DCCP_CLOSED
)
345 seq
= dccp_hdr_seq(skb
);
346 if (sk
->sk_state
!= DCCP_LISTEN
&&
347 !between48(seq
, dp
->dccps_swl
, dp
->dccps_swh
)) {
348 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS
);
353 case ICMP_SOURCE_QUENCH
:
354 /* Just silently ignore these. */
356 case ICMP_PARAMETERPROB
:
359 case ICMP_DEST_UNREACH
:
360 if (code
> NR_ICMP_UNREACH
)
363 if (code
== ICMP_FRAG_NEEDED
) { /* PMTU discovery (RFC1191) */
364 if (!sock_owned_by_user(sk
))
365 dccp_do_pmtu_discovery(sk
, iph
, info
);
369 err
= icmp_err_convert
[code
].errno
;
371 case ICMP_TIME_EXCEEDED
:
378 switch (sk
->sk_state
) {
379 struct request_sock
*req
, **prev
;
381 if (sock_owned_by_user(sk
))
383 req
= inet_csk_search_req(sk
, &prev
, dh
->dccph_dport
,
384 iph
->daddr
, iph
->saddr
);
389 * ICMPs are not backlogged, hence we cannot get an established
394 if (seq
!= dccp_rsk(req
)->dreq_iss
) {
395 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS
);
399 * Still in RESPOND, just remove it silently.
400 * There is no good way to pass the error to the newly
401 * created socket, and POSIX does not want network
402 * errors returned from accept().
404 inet_csk_reqsk_queue_drop(sk
, req
, prev
);
407 case DCCP_REQUESTING
:
409 if (!sock_owned_by_user(sk
)) {
410 DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS
);
413 sk
->sk_error_report(sk
);
417 sk
->sk_err_soft
= err
;
421 /* If we've already connected we will keep trying
422 * until we time out, or the user gives up.
424 * rfc1122 4.2.3.9 allows to consider as hard errors
425 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
426 * but it is obsoleted by pmtu discovery).
428 * Note, that in modern internet, where routing is unreliable
429 * and in each dark corner broken firewalls sit, sending random
430 * errors ordered by their masters even this two messages finally lose
431 * their original sense (even Linux sends invalid PORT_UNREACHs)
433 * Now we are in compliance with RFCs.
438 if (!sock_owned_by_user(sk
) && inet
->recverr
) {
440 sk
->sk_error_report(sk
);
441 } else /* Only an error on timeout */
442 sk
->sk_err_soft
= err
;
448 /* This routine computes an IPv4 DCCP checksum. */
449 void dccp_v4_send_check(struct sock
*sk
, int len
, struct sk_buff
*skb
)
451 const struct inet_sock
*inet
= inet_sk(sk
);
452 struct dccp_hdr
*dh
= dccp_hdr(skb
);
454 dh
->dccph_checksum
= dccp_v4_checksum(skb
, inet
->saddr
, inet
->daddr
);
457 EXPORT_SYMBOL_GPL(dccp_v4_send_check
);
459 int dccp_v4_send_reset(struct sock
*sk
, enum dccp_reset_codes code
)
463 * FIXME: what if rebuild_header fails?
464 * Should we be doing a rebuild_header here?
466 int err
= inet_sk_rebuild_header(sk
);
471 skb
= dccp_make_reset(sk
, sk
->sk_dst_cache
, code
);
473 const struct inet_sock
*inet
= inet_sk(sk
);
475 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
476 err
= ip_build_and_send_pkt(skb
, sk
,
477 inet
->saddr
, inet
->daddr
, NULL
);
478 if (err
== NET_XMIT_CN
)
485 static inline u64
dccp_v4_init_sequence(const struct sock
*sk
,
486 const struct sk_buff
*skb
)
488 return secure_dccp_sequence_number(skb
->nh
.iph
->daddr
,
490 dccp_hdr(skb
)->dccph_dport
,
491 dccp_hdr(skb
)->dccph_sport
);
494 int dccp_v4_conn_request(struct sock
*sk
, struct sk_buff
*skb
)
496 struct inet_request_sock
*ireq
;
498 struct request_sock
*req
;
499 struct dccp_request_sock
*dreq
;
500 const __u32 saddr
= skb
->nh
.iph
->saddr
;
501 const __u32 daddr
= skb
->nh
.iph
->daddr
;
502 const __u32 service
= dccp_hdr_request(skb
)->dccph_req_service
;
503 struct dccp_skb_cb
*dcb
= DCCP_SKB_CB(skb
);
504 __u8 reset_code
= DCCP_RESET_CODE_TOO_BUSY
;
506 /* Never answer to DCCP_PKT_REQUESTs send to broadcast or multicast */
507 if (((struct rtable
*)skb
->dst
)->rt_flags
&
508 (RTCF_BROADCAST
| RTCF_MULTICAST
)) {
509 reset_code
= DCCP_RESET_CODE_NO_CONNECTION
;
513 if (dccp_bad_service_code(sk
, service
)) {
514 reset_code
= DCCP_RESET_CODE_BAD_SERVICE_CODE
;
518 * TW buckets are converted to open requests without
519 * limitations, they conserve resources and peer is
520 * evidently real one.
522 if (inet_csk_reqsk_queue_is_full(sk
))
526 * Accept backlog is full. If we have already queued enough
527 * of warm entries in syn queue, drop request. It is better than
528 * clogging syn queue with openreqs with exponentially increasing
531 if (sk_acceptq_is_full(sk
) && inet_csk_reqsk_queue_young(sk
) > 1)
534 req
= reqsk_alloc(sk
->sk_prot
->rsk_prot
);
538 /* FIXME: process options */
540 dccp_openreq_init(req
, &dp
, skb
);
542 ireq
= inet_rsk(req
);
543 ireq
->loc_addr
= daddr
;
544 ireq
->rmt_addr
= saddr
;
545 req
->rcv_wnd
= 100; /* Fake, option parsing will get the
550 * Step 3: Process LISTEN state
552 * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
554 * In fact we defer setting S.GSR, S.SWL, S.SWH to
555 * dccp_create_openreq_child.
557 dreq
= dccp_rsk(req
);
558 dreq
->dreq_isr
= dcb
->dccpd_seq
;
559 dreq
->dreq_iss
= dccp_v4_init_sequence(sk
, skb
);
560 dreq
->dreq_service
= service
;
562 if (dccp_v4_send_response(sk
, req
, NULL
))
565 inet_csk_reqsk_queue_hash_add(sk
, req
, DCCP_TIMEOUT_INIT
);
571 DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS
);
572 dcb
->dccpd_reset_code
= reset_code
;
576 EXPORT_SYMBOL_GPL(dccp_v4_conn_request
);
579 * The three way handshake has completed - we got a valid ACK or DATAACK -
580 * now create the new socket.
582 * This is the equivalent of TCP's tcp_v4_syn_recv_sock
584 struct sock
*dccp_v4_request_recv_sock(struct sock
*sk
, struct sk_buff
*skb
,
585 struct request_sock
*req
,
586 struct dst_entry
*dst
)
588 struct inet_request_sock
*ireq
;
589 struct inet_sock
*newinet
;
590 struct dccp_sock
*newdp
;
593 if (sk_acceptq_is_full(sk
))
596 if (dst
== NULL
&& (dst
= inet_csk_route_req(sk
, req
)) == NULL
)
599 newsk
= dccp_create_openreq_child(sk
, req
, skb
);
603 sk_setup_caps(newsk
, dst
);
605 newdp
= dccp_sk(newsk
);
606 newinet
= inet_sk(newsk
);
607 ireq
= inet_rsk(req
);
608 newinet
->daddr
= ireq
->rmt_addr
;
609 newinet
->rcv_saddr
= ireq
->loc_addr
;
610 newinet
->saddr
= ireq
->loc_addr
;
611 newinet
->opt
= ireq
->opt
;
613 newinet
->mc_index
= inet_iif(skb
);
614 newinet
->mc_ttl
= skb
->nh
.iph
->ttl
;
615 newinet
->id
= jiffies
;
617 dccp_sync_mss(newsk
, dst_mtu(dst
));
619 __inet_hash(&dccp_hashinfo
, newsk
, 0);
620 __inet_inherit_port(&dccp_hashinfo
, sk
, newsk
);
625 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS
);
627 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS
);
632 EXPORT_SYMBOL_GPL(dccp_v4_request_recv_sock
);
634 static struct sock
*dccp_v4_hnd_req(struct sock
*sk
, struct sk_buff
*skb
)
636 const struct dccp_hdr
*dh
= dccp_hdr(skb
);
637 const struct iphdr
*iph
= skb
->nh
.iph
;
639 struct request_sock
**prev
;
640 /* Find possible connection requests. */
641 struct request_sock
*req
= inet_csk_search_req(sk
, &prev
,
643 iph
->saddr
, iph
->daddr
);
645 return dccp_check_req(sk
, skb
, req
, prev
);
647 nsk
= __inet_lookup_established(&dccp_hashinfo
,
648 iph
->saddr
, dh
->dccph_sport
,
649 iph
->daddr
, ntohs(dh
->dccph_dport
),
652 if (nsk
->sk_state
!= DCCP_TIME_WAIT
) {
656 inet_twsk_put((struct inet_timewait_sock
*)nsk
);
663 int dccp_v4_checksum(const struct sk_buff
*skb
, const u32 saddr
,
666 const struct dccp_hdr
* dh
= dccp_hdr(skb
);
670 if (dh
->dccph_cscov
== 0)
671 checksum_len
= skb
->len
;
673 checksum_len
= (dh
->dccph_cscov
+ dh
->dccph_x
) * sizeof(u32
);
674 checksum_len
= checksum_len
< skb
->len
? checksum_len
:
678 tmp
= csum_partial((unsigned char *)dh
, checksum_len
, 0);
679 return csum_tcpudp_magic(saddr
, daddr
, checksum_len
,
683 static int dccp_v4_verify_checksum(struct sk_buff
*skb
,
684 const u32 saddr
, const u32 daddr
)
686 struct dccp_hdr
*dh
= dccp_hdr(skb
);
690 if (dh
->dccph_cscov
== 0)
691 checksum_len
= skb
->len
;
693 checksum_len
= (dh
->dccph_cscov
+ dh
->dccph_x
) * sizeof(u32
);
694 checksum_len
= checksum_len
< skb
->len
? checksum_len
:
697 tmp
= csum_partial((unsigned char *)dh
, checksum_len
, 0);
698 return csum_tcpudp_magic(saddr
, daddr
, checksum_len
,
699 IPPROTO_DCCP
, tmp
) == 0 ? 0 : -1;
702 static struct dst_entry
* dccp_v4_route_skb(struct sock
*sk
,
706 struct flowi fl
= { .oif
= ((struct rtable
*)skb
->dst
)->rt_iif
,
708 { .daddr
= skb
->nh
.iph
->saddr
,
709 .saddr
= skb
->nh
.iph
->daddr
,
710 .tos
= RT_CONN_FLAGS(sk
) } },
711 .proto
= sk
->sk_protocol
,
713 { .sport
= dccp_hdr(skb
)->dccph_dport
,
714 .dport
= dccp_hdr(skb
)->dccph_sport
}
718 if (ip_route_output_flow(&rt
, &fl
, sk
, 0)) {
719 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES
);
726 static void dccp_v4_ctl_send_reset(struct sk_buff
*rxskb
)
729 struct dccp_hdr
*rxdh
= dccp_hdr(rxskb
), *dh
;
730 const int dccp_hdr_reset_len
= sizeof(struct dccp_hdr
) +
731 sizeof(struct dccp_hdr_ext
) +
732 sizeof(struct dccp_hdr_reset
);
734 struct dst_entry
*dst
;
737 /* Never send a reset in response to a reset. */
738 if (rxdh
->dccph_type
== DCCP_PKT_RESET
)
741 if (((struct rtable
*)rxskb
->dst
)->rt_type
!= RTN_LOCAL
)
744 dst
= dccp_v4_route_skb(dccp_ctl_socket
->sk
, rxskb
);
748 skb
= alloc_skb(MAX_DCCP_HEADER
+ 15, GFP_ATOMIC
);
752 /* Reserve space for headers. */
753 skb_reserve(skb
, MAX_DCCP_HEADER
);
754 skb
->dst
= dst_clone(dst
);
756 skb
->h
.raw
= skb_push(skb
, dccp_hdr_reset_len
);
758 memset(dh
, 0, dccp_hdr_reset_len
);
760 /* Build DCCP header and checksum it. */
761 dh
->dccph_type
= DCCP_PKT_RESET
;
762 dh
->dccph_sport
= rxdh
->dccph_dport
;
763 dh
->dccph_dport
= rxdh
->dccph_sport
;
764 dh
->dccph_doff
= dccp_hdr_reset_len
/ 4;
766 dccp_hdr_reset(skb
)->dccph_reset_code
=
767 DCCP_SKB_CB(rxskb
)->dccpd_reset_code
;
769 /* See "8.3.1. Abnormal Termination" in draft-ietf-dccp-spec-11 */
771 if (DCCP_SKB_CB(rxskb
)->dccpd_ack_seq
!= DCCP_PKT_WITHOUT_ACK_SEQ
)
772 dccp_set_seqno(&seqno
, DCCP_SKB_CB(rxskb
)->dccpd_ack_seq
+ 1);
774 dccp_hdr_set_seq(dh
, seqno
);
775 dccp_hdr_set_ack(dccp_hdr_ack_bits(skb
),
776 DCCP_SKB_CB(rxskb
)->dccpd_seq
);
778 dh
->dccph_checksum
= dccp_v4_checksum(skb
, rxskb
->nh
.iph
->saddr
,
779 rxskb
->nh
.iph
->daddr
);
781 bh_lock_sock(dccp_ctl_socket
->sk
);
782 err
= ip_build_and_send_pkt(skb
, dccp_ctl_socket
->sk
,
783 rxskb
->nh
.iph
->daddr
,
784 rxskb
->nh
.iph
->saddr
, NULL
);
785 bh_unlock_sock(dccp_ctl_socket
->sk
);
787 if (err
== NET_XMIT_CN
|| err
== 0) {
788 DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS
);
789 DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS
);
795 int dccp_v4_do_rcv(struct sock
*sk
, struct sk_buff
*skb
)
797 struct dccp_hdr
*dh
= dccp_hdr(skb
);
799 if (sk
->sk_state
== DCCP_OPEN
) { /* Fast path */
800 if (dccp_rcv_established(sk
, skb
, dh
, skb
->len
))
806 * Step 3: Process LISTEN state
807 * If S.state == LISTEN,
808 * If P.type == Request or P contains a valid Init Cookie
810 * * Must scan the packet's options to check for an Init
811 * Cookie. Only the Init Cookie is processed here,
812 * however; other options are processed in Step 8. This
813 * scan need only be performed if the endpoint uses Init
815 * * Generate a new socket and switch to that socket *
816 * Set S := new socket for this port pair
818 * Choose S.ISS (initial seqno) or set from Init Cookie
819 * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
820 * Continue with S.state == RESPOND
821 * * A Response packet will be generated in Step 11 *
823 * Generate Reset(No Connection) unless P.type == Reset
824 * Drop packet and return
826 * NOTE: the check for the packet types is done in
827 * dccp_rcv_state_process
829 if (sk
->sk_state
== DCCP_LISTEN
) {
830 struct sock
*nsk
= dccp_v4_hnd_req(sk
, skb
);
836 if (dccp_child_process(sk
, nsk
, skb
))
842 if (dccp_rcv_state_process(sk
, skb
, dh
, skb
->len
))
847 dccp_v4_ctl_send_reset(skb
);
853 EXPORT_SYMBOL_GPL(dccp_v4_do_rcv
);
855 int dccp_invalid_packet(struct sk_buff
*skb
)
857 const struct dccp_hdr
*dh
;
859 if (skb
->pkt_type
!= PACKET_HOST
)
862 if (!pskb_may_pull(skb
, sizeof(struct dccp_hdr
))) {
863 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: pskb_may_pull failed\n");
869 /* If the packet type is not understood, drop packet and return */
870 if (dh
->dccph_type
>= DCCP_PKT_INVALID
) {
871 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: invalid packet type\n");
876 * If P.Data Offset is too small for packet type, or too large for
877 * packet, drop packet and return
879 if (dh
->dccph_doff
< dccp_hdr_len(skb
) / sizeof(u32
)) {
880 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: P.Data Offset(%u) "
886 if (!pskb_may_pull(skb
, dh
->dccph_doff
* sizeof(u32
))) {
887 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: P.Data Offset(%u) "
896 * If P.type is not Data, Ack, or DataAck and P.X == 0 (the packet
897 * has short sequence numbers), drop packet and return
899 if (dh
->dccph_x
== 0 &&
900 dh
->dccph_type
!= DCCP_PKT_DATA
&&
901 dh
->dccph_type
!= DCCP_PKT_ACK
&&
902 dh
->dccph_type
!= DCCP_PKT_DATAACK
) {
903 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: P.type (%s) not Data, Ack "
904 "nor DataAck and P.X == 0\n",
905 dccp_packet_name(dh
->dccph_type
));
912 EXPORT_SYMBOL_GPL(dccp_invalid_packet
);
914 /* this is called when real data arrives */
915 int dccp_v4_rcv(struct sk_buff
*skb
)
917 const struct dccp_hdr
*dh
;
920 /* Step 1: Check header basics: */
922 if (dccp_invalid_packet(skb
))
925 /* If the header checksum is incorrect, drop packet and return */
926 if (dccp_v4_verify_checksum(skb
, skb
->nh
.iph
->saddr
,
927 skb
->nh
.iph
->daddr
) < 0) {
928 LIMIT_NETDEBUG(KERN_WARNING
"%s: incorrect header checksum\n",
935 DCCP_SKB_CB(skb
)->dccpd_seq
= dccp_hdr_seq(skb
);
936 DCCP_SKB_CB(skb
)->dccpd_type
= dh
->dccph_type
;
938 dccp_pr_debug("%8.8s "
939 "src=%u.%u.%u.%u@%-5d "
940 "dst=%u.%u.%u.%u@%-5d seq=%llu",
941 dccp_packet_name(dh
->dccph_type
),
942 NIPQUAD(skb
->nh
.iph
->saddr
), ntohs(dh
->dccph_sport
),
943 NIPQUAD(skb
->nh
.iph
->daddr
), ntohs(dh
->dccph_dport
),
944 (unsigned long long) DCCP_SKB_CB(skb
)->dccpd_seq
);
946 if (dccp_packet_without_ack(skb
)) {
947 DCCP_SKB_CB(skb
)->dccpd_ack_seq
= DCCP_PKT_WITHOUT_ACK_SEQ
;
948 dccp_pr_debug_cat("\n");
950 DCCP_SKB_CB(skb
)->dccpd_ack_seq
= dccp_hdr_ack_seq(skb
);
951 dccp_pr_debug_cat(", ack=%llu\n",
953 DCCP_SKB_CB(skb
)->dccpd_ack_seq
);
957 * Look up flow ID in table and get corresponding socket */
958 sk
= __inet_lookup(&dccp_hashinfo
,
959 skb
->nh
.iph
->saddr
, dh
->dccph_sport
,
960 skb
->nh
.iph
->daddr
, ntohs(dh
->dccph_dport
),
966 * Generate Reset(No Connection) unless P.type == Reset
967 * Drop packet and return
970 dccp_pr_debug("failed to look up flow ID in table and "
971 "get corresponding socket\n");
977 * ... or S.state == TIMEWAIT,
978 * Generate Reset(No Connection) unless P.type == Reset
979 * Drop packet and return
982 if (sk
->sk_state
== DCCP_TIME_WAIT
) {
983 dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: "
988 if (!xfrm4_policy_check(sk
, XFRM_POLICY_IN
, skb
))
989 goto discard_and_relse
;
992 return sk_receive_skb(sk
, skb
);
995 if (!xfrm4_policy_check(NULL
, XFRM_POLICY_IN
, skb
))
999 * Generate Reset(No Connection) unless P.type == Reset
1000 * Drop packet and return
1002 if (dh
->dccph_type
!= DCCP_PKT_RESET
) {
1003 DCCP_SKB_CB(skb
)->dccpd_reset_code
=
1004 DCCP_RESET_CODE_NO_CONNECTION
;
1005 dccp_v4_ctl_send_reset(skb
);
1009 /* Discard frame. */
1018 inet_twsk_put((struct inet_timewait_sock
*)sk
);
1019 goto no_dccp_socket
;
1022 struct inet_connection_sock_af_ops dccp_ipv4_af_ops
= {
1023 .queue_xmit
= ip_queue_xmit
,
1024 .send_check
= dccp_v4_send_check
,
1025 .rebuild_header
= inet_sk_rebuild_header
,
1026 .conn_request
= dccp_v4_conn_request
,
1027 .syn_recv_sock
= dccp_v4_request_recv_sock
,
1028 .net_header_len
= sizeof(struct iphdr
),
1029 .setsockopt
= ip_setsockopt
,
1030 .getsockopt
= ip_getsockopt
,
1031 .addr2sockaddr
= inet_csk_addr2sockaddr
,
1032 .sockaddr_len
= sizeof(struct sockaddr_in
),
1035 int dccp_v4_init_sock(struct sock
*sk
)
1037 struct dccp_sock
*dp
= dccp_sk(sk
);
1038 struct inet_connection_sock
*icsk
= inet_csk(sk
);
1039 static int dccp_ctl_socket_init
= 1;
1041 dccp_options_init(&dp
->dccps_options
);
1042 do_gettimeofday(&dp
->dccps_epoch
);
1044 if (dp
->dccps_options
.dccpo_send_ack_vector
) {
1045 dp
->dccps_hc_rx_ackvec
= dccp_ackvec_alloc(DCCP_MAX_ACKVEC_LEN
,
1047 if (dp
->dccps_hc_rx_ackvec
== NULL
)
1052 * FIXME: We're hardcoding the CCID, and doing this at this point makes
1053 * the listening (master) sock get CCID control blocks, which is not
1054 * necessary, but for now, to not mess with the test userspace apps,
1055 * lets leave it here, later the real solution is to do this in a
1056 * setsockopt(CCIDs-I-want/accept). -acme
1058 if (likely(!dccp_ctl_socket_init
)) {
1059 dp
->dccps_hc_rx_ccid
= ccid_init(dp
->dccps_options
.dccpo_rx_ccid
,
1061 dp
->dccps_hc_tx_ccid
= ccid_init(dp
->dccps_options
.dccpo_tx_ccid
,
1063 if (dp
->dccps_hc_rx_ccid
== NULL
||
1064 dp
->dccps_hc_tx_ccid
== NULL
) {
1065 ccid_exit(dp
->dccps_hc_rx_ccid
, sk
);
1066 ccid_exit(dp
->dccps_hc_tx_ccid
, sk
);
1067 if (dp
->dccps_options
.dccpo_send_ack_vector
) {
1068 dccp_ackvec_free(dp
->dccps_hc_rx_ackvec
);
1069 dp
->dccps_hc_rx_ackvec
= NULL
;
1071 dp
->dccps_hc_rx_ccid
= dp
->dccps_hc_tx_ccid
= NULL
;
1075 dccp_ctl_socket_init
= 0;
1077 dccp_init_xmit_timers(sk
);
1078 icsk
->icsk_rto
= DCCP_TIMEOUT_INIT
;
1079 sk
->sk_state
= DCCP_CLOSED
;
1080 sk
->sk_write_space
= dccp_write_space
;
1081 icsk
->icsk_af_ops
= &dccp_ipv4_af_ops
;
1082 icsk
->icsk_sync_mss
= dccp_sync_mss
;
1083 dp
->dccps_mss_cache
= 536;
1084 dp
->dccps_role
= DCCP_ROLE_UNDEFINED
;
1085 dp
->dccps_service
= DCCP_SERVICE_INVALID_VALUE
;
1090 EXPORT_SYMBOL_GPL(dccp_v4_init_sock
);
1092 int dccp_v4_destroy_sock(struct sock
*sk
)
1094 struct dccp_sock
*dp
= dccp_sk(sk
);
1097 * DCCP doesn't use sk_write_queue, just sk_send_head
1098 * for retransmissions
1100 if (sk
->sk_send_head
!= NULL
) {
1101 kfree_skb(sk
->sk_send_head
);
1102 sk
->sk_send_head
= NULL
;
1105 /* Clean up a referenced DCCP bind bucket. */
1106 if (inet_csk(sk
)->icsk_bind_hash
!= NULL
)
1107 inet_put_port(&dccp_hashinfo
, sk
);
1109 kfree(dp
->dccps_service_list
);
1110 dp
->dccps_service_list
= NULL
;
1112 ccid_hc_rx_exit(dp
->dccps_hc_rx_ccid
, sk
);
1113 ccid_hc_tx_exit(dp
->dccps_hc_tx_ccid
, sk
);
1114 if (dp
->dccps_options
.dccpo_send_ack_vector
) {
1115 dccp_ackvec_free(dp
->dccps_hc_rx_ackvec
);
1116 dp
->dccps_hc_rx_ackvec
= NULL
;
1118 ccid_exit(dp
->dccps_hc_rx_ccid
, sk
);
1119 ccid_exit(dp
->dccps_hc_tx_ccid
, sk
);
1120 dp
->dccps_hc_rx_ccid
= dp
->dccps_hc_tx_ccid
= NULL
;
1125 EXPORT_SYMBOL_GPL(dccp_v4_destroy_sock
);
1127 static void dccp_v4_reqsk_destructor(struct request_sock
*req
)
1129 kfree(inet_rsk(req
)->opt
);
1132 static struct request_sock_ops dccp_request_sock_ops
= {
1134 .obj_size
= sizeof(struct dccp_request_sock
),
1135 .rtx_syn_ack
= dccp_v4_send_response
,
1136 .send_ack
= dccp_v4_reqsk_send_ack
,
1137 .destructor
= dccp_v4_reqsk_destructor
,
1138 .send_reset
= dccp_v4_ctl_send_reset
,
1141 static struct timewait_sock_ops dccp_timewait_sock_ops
= {
1142 .twsk_obj_size
= sizeof(struct inet_timewait_sock
),
1145 struct proto dccp_prot
= {
1147 .owner
= THIS_MODULE
,
1148 .close
= dccp_close
,
1149 .connect
= dccp_v4_connect
,
1150 .disconnect
= dccp_disconnect
,
1151 .ioctl
= dccp_ioctl
,
1152 .init
= dccp_v4_init_sock
,
1153 .setsockopt
= dccp_setsockopt
,
1154 .getsockopt
= dccp_getsockopt
,
1155 .sendmsg
= dccp_sendmsg
,
1156 .recvmsg
= dccp_recvmsg
,
1157 .backlog_rcv
= dccp_v4_do_rcv
,
1158 .hash
= dccp_v4_hash
,
1159 .unhash
= dccp_unhash
,
1160 .accept
= inet_csk_accept
,
1161 .get_port
= dccp_v4_get_port
,
1162 .shutdown
= dccp_shutdown
,
1163 .destroy
= dccp_v4_destroy_sock
,
1164 .orphan_count
= &dccp_orphan_count
,
1165 .max_header
= MAX_DCCP_HEADER
,
1166 .obj_size
= sizeof(struct dccp_sock
),
1167 .rsk_prot
= &dccp_request_sock_ops
,
1168 .twsk_prot
= &dccp_timewait_sock_ops
,
1171 EXPORT_SYMBOL_GPL(dccp_prot
);