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/dccp.h>
14 #include <linux/icmp.h>
15 #include <linux/module.h>
16 #include <linux/skbuff.h>
17 #include <linux/random.h>
20 #include <net/inet_common.h>
21 #include <net/inet_hashtables.h>
22 #include <net/inet_sock.h>
23 #include <net/protocol.h>
25 #include <net/timewait_sock.h>
26 #include <net/tcp_states.h>
35 * This is the global socket data structure used for responding to
36 * the Out-of-the-blue (OOTB) packets. A control sock will be created
37 * for this socket at the initialization time.
39 static struct socket
*dccp_v4_ctl_socket
;
41 static int dccp_v4_get_port(struct sock
*sk
, const unsigned short snum
)
43 return inet_csk_get_port(&dccp_hashinfo
, sk
, snum
,
44 inet_csk_bind_conflict
);
47 int dccp_v4_connect(struct sock
*sk
, struct sockaddr
*uaddr
, int addr_len
)
49 struct inet_sock
*inet
= inet_sk(sk
);
50 struct dccp_sock
*dp
= dccp_sk(sk
);
51 const struct sockaddr_in
*usin
= (struct sockaddr_in
*)uaddr
;
57 dp
->dccps_role
= DCCP_ROLE_CLIENT
;
59 if (dccp_service_not_initialized(sk
))
62 if (addr_len
< sizeof(struct sockaddr_in
))
65 if (usin
->sin_family
!= AF_INET
)
68 nexthop
= daddr
= usin
->sin_addr
.s_addr
;
69 if (inet
->opt
!= NULL
&& inet
->opt
->srr
) {
72 nexthop
= inet
->opt
->faddr
;
75 tmp
= ip_route_connect(&rt
, nexthop
, inet
->saddr
,
76 RT_CONN_FLAGS(sk
), sk
->sk_bound_dev_if
,
78 inet
->sport
, usin
->sin_port
, sk
);
82 if (rt
->rt_flags
& (RTCF_MULTICAST
| RTCF_BROADCAST
)) {
87 if (inet
->opt
== NULL
|| !inet
->opt
->srr
)
91 inet
->saddr
= rt
->rt_src
;
92 inet
->rcv_saddr
= inet
->saddr
;
94 inet
->dport
= usin
->sin_port
;
97 inet_csk(sk
)->icsk_ext_hdr_len
= 0;
98 if (inet
->opt
!= NULL
)
99 inet_csk(sk
)->icsk_ext_hdr_len
= inet
->opt
->optlen
;
101 * Socket identity is still unknown (sport may be zero).
102 * However we set state to DCCP_REQUESTING and not releasing socket
103 * lock select source port, enter ourselves into the hash tables and
104 * complete initialization after this.
106 dccp_set_state(sk
, DCCP_REQUESTING
);
107 err
= inet_hash_connect(&dccp_death_row
, sk
);
111 err
= ip_route_newports(&rt
, IPPROTO_DCCP
, inet
->sport
, inet
->dport
,
116 /* OK, now commit destination to socket. */
117 sk_setup_caps(sk
, &rt
->u
.dst
);
120 dp
->dccps_iss
= secure_dccp_sequence_number(inet
->saddr
,
124 dccp_update_gss(sk
, dp
->dccps_iss
);
126 inet
->id
= dp
->dccps_iss
^ jiffies
;
128 err
= dccp_connect(sk
);
136 * This unhashes the socket and releases the local port, if necessary.
138 dccp_set_state(sk
, DCCP_CLOSED
);
140 sk
->sk_route_caps
= 0;
145 EXPORT_SYMBOL_GPL(dccp_v4_connect
);
148 * This routine does path mtu discovery as defined in RFC1191.
150 static inline void dccp_do_pmtu_discovery(struct sock
*sk
,
151 const struct iphdr
*iph
,
154 struct dst_entry
*dst
;
155 const struct inet_sock
*inet
= inet_sk(sk
);
156 const struct dccp_sock
*dp
= dccp_sk(sk
);
158 /* We are not interested in DCCP_LISTEN and request_socks (RESPONSEs
159 * send out by Linux are always < 576bytes so they should go through
162 if (sk
->sk_state
== DCCP_LISTEN
)
165 /* We don't check in the destentry if pmtu discovery is forbidden
166 * on this route. We just assume that no packet_to_big packets
167 * are send back when pmtu discovery is not active.
168 * There is a small race when the user changes this flag in the
169 * route, but I think that's acceptable.
171 if ((dst
= __sk_dst_check(sk
, 0)) == NULL
)
174 dst
->ops
->update_pmtu(dst
, mtu
);
176 /* Something is about to be wrong... Remember soft error
177 * for the case, if this connection will not able to recover.
179 if (mtu
< dst_mtu(dst
) && ip_dont_fragment(sk
, dst
))
180 sk
->sk_err_soft
= EMSGSIZE
;
184 if (inet
->pmtudisc
!= IP_PMTUDISC_DONT
&&
185 inet_csk(sk
)->icsk_pmtu_cookie
> mtu
) {
186 dccp_sync_mss(sk
, mtu
);
189 * From: draft-ietf-dccp-spec-11.txt
191 * DCCP-Sync packets are the best choice for upward
192 * probing, since DCCP-Sync probes do not risk application
195 dccp_send_sync(sk
, dp
->dccps_gsr
, DCCP_PKT_SYNC
);
196 } /* else let the usual retransmit timer handle it */
199 static void dccp_v4_reqsk_send_ack(struct sk_buff
*rxskb
,
200 struct request_sock
*req
)
203 struct dccp_hdr
*rxdh
= dccp_hdr(rxskb
), *dh
;
204 const u32 dccp_hdr_ack_len
= sizeof(struct dccp_hdr
) +
205 sizeof(struct dccp_hdr_ext
) +
206 sizeof(struct dccp_hdr_ack_bits
);
209 if (((struct rtable
*)rxskb
->dst
)->rt_type
!= RTN_LOCAL
)
212 skb
= alloc_skb(dccp_v4_ctl_socket
->sk
->sk_prot
->max_header
, GFP_ATOMIC
);
216 /* Reserve space for headers. */
217 skb_reserve(skb
, dccp_v4_ctl_socket
->sk
->sk_prot
->max_header
);
219 skb
->dst
= dst_clone(rxskb
->dst
);
221 skb
->h
.raw
= skb_push(skb
, dccp_hdr_ack_len
);
223 memset(dh
, 0, dccp_hdr_ack_len
);
225 /* Build DCCP header and checksum it. */
226 dh
->dccph_type
= DCCP_PKT_ACK
;
227 dh
->dccph_sport
= rxdh
->dccph_dport
;
228 dh
->dccph_dport
= rxdh
->dccph_sport
;
229 dh
->dccph_doff
= dccp_hdr_ack_len
/ 4;
232 dccp_hdr_set_seq(dh
, DCCP_SKB_CB(rxskb
)->dccpd_ack_seq
);
233 dccp_hdr_set_ack(dccp_hdr_ack_bits(skb
),
234 DCCP_SKB_CB(rxskb
)->dccpd_seq
);
236 bh_lock_sock(dccp_v4_ctl_socket
->sk
);
237 err
= ip_build_and_send_pkt(skb
, dccp_v4_ctl_socket
->sk
,
238 rxskb
->nh
.iph
->daddr
,
239 rxskb
->nh
.iph
->saddr
, NULL
);
240 bh_unlock_sock(dccp_v4_ctl_socket
->sk
);
242 if (err
== NET_XMIT_CN
|| err
== 0) {
243 DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS
);
244 DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS
);
248 static int dccp_v4_send_response(struct sock
*sk
, struct request_sock
*req
,
249 struct dst_entry
*dst
)
254 /* First, grab a route. */
256 if (dst
== NULL
&& (dst
= inet_csk_route_req(sk
, req
)) == NULL
)
259 skb
= dccp_make_response(sk
, dst
, req
);
261 const struct inet_request_sock
*ireq
= inet_rsk(req
);
262 struct dccp_hdr
*dh
= dccp_hdr(skb
);
264 dh
->dccph_checksum
= dccp_v4_checksum(skb
, ireq
->loc_addr
,
266 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
267 err
= ip_build_and_send_pkt(skb
, sk
, ireq
->loc_addr
,
270 if (err
== NET_XMIT_CN
)
280 * This routine is called by the ICMP module when it gets some sort of error
281 * condition. If err < 0 then the socket should be closed and the error
282 * returned to the user. If err > 0 it's just the icmp type << 8 | icmp code.
283 * After adjustment header points to the first 8 bytes of the tcp header. We
284 * need to find the appropriate port.
286 * The locking strategy used here is very "optimistic". When someone else
287 * accesses the socket the ICMP is just dropped and for some paths there is no
288 * check at all. A more general error queue to queue errors for later handling
289 * is probably better.
291 static void dccp_v4_err(struct sk_buff
*skb
, u32 info
)
293 const struct iphdr
*iph
= (struct iphdr
*)skb
->data
;
294 const struct dccp_hdr
*dh
= (struct dccp_hdr
*)(skb
->data
+
296 struct dccp_sock
*dp
;
297 struct inet_sock
*inet
;
298 const int type
= skb
->h
.icmph
->type
;
299 const int code
= skb
->h
.icmph
->code
;
304 if (skb
->len
< (iph
->ihl
<< 2) + 8) {
305 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS
);
309 sk
= inet_lookup(&dccp_hashinfo
, iph
->daddr
, dh
->dccph_dport
,
310 iph
->saddr
, dh
->dccph_sport
, inet_iif(skb
));
312 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS
);
316 if (sk
->sk_state
== DCCP_TIME_WAIT
) {
317 inet_twsk_put((struct inet_timewait_sock
*)sk
);
322 /* If too many ICMPs get dropped on busy
323 * servers this needs to be solved differently.
325 if (sock_owned_by_user(sk
))
326 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS
);
328 if (sk
->sk_state
== DCCP_CLOSED
)
332 seq
= dccp_hdr_seq(skb
);
333 if (sk
->sk_state
!= DCCP_LISTEN
&&
334 !between48(seq
, dp
->dccps_swl
, dp
->dccps_swh
)) {
335 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS
);
340 case ICMP_SOURCE_QUENCH
:
341 /* Just silently ignore these. */
343 case ICMP_PARAMETERPROB
:
346 case ICMP_DEST_UNREACH
:
347 if (code
> NR_ICMP_UNREACH
)
350 if (code
== ICMP_FRAG_NEEDED
) { /* PMTU discovery (RFC1191) */
351 if (!sock_owned_by_user(sk
))
352 dccp_do_pmtu_discovery(sk
, iph
, info
);
356 err
= icmp_err_convert
[code
].errno
;
358 case ICMP_TIME_EXCEEDED
:
365 switch (sk
->sk_state
) {
366 struct request_sock
*req
, **prev
;
368 if (sock_owned_by_user(sk
))
370 req
= inet_csk_search_req(sk
, &prev
, dh
->dccph_dport
,
371 iph
->daddr
, iph
->saddr
);
376 * ICMPs are not backlogged, hence we cannot get an established
381 if (seq
!= dccp_rsk(req
)->dreq_iss
) {
382 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS
);
386 * Still in RESPOND, just remove it silently.
387 * There is no good way to pass the error to the newly
388 * created socket, and POSIX does not want network
389 * errors returned from accept().
391 inet_csk_reqsk_queue_drop(sk
, req
, prev
);
394 case DCCP_REQUESTING
:
396 if (!sock_owned_by_user(sk
)) {
397 DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS
);
400 sk
->sk_error_report(sk
);
404 sk
->sk_err_soft
= err
;
408 /* If we've already connected we will keep trying
409 * until we time out, or the user gives up.
411 * rfc1122 4.2.3.9 allows to consider as hard errors
412 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
413 * but it is obsoleted by pmtu discovery).
415 * Note, that in modern internet, where routing is unreliable
416 * and in each dark corner broken firewalls sit, sending random
417 * errors ordered by their masters even this two messages finally lose
418 * their original sense (even Linux sends invalid PORT_UNREACHs)
420 * Now we are in compliance with RFCs.
425 if (!sock_owned_by_user(sk
) && inet
->recverr
) {
427 sk
->sk_error_report(sk
);
428 } else /* Only an error on timeout */
429 sk
->sk_err_soft
= err
;
435 /* This routine computes an IPv4 DCCP checksum. */
436 void dccp_v4_send_check(struct sock
*sk
, int len
, struct sk_buff
*skb
)
438 const struct inet_sock
*inet
= inet_sk(sk
);
439 struct dccp_hdr
*dh
= dccp_hdr(skb
);
441 dh
->dccph_checksum
= dccp_v4_checksum(skb
, inet
->saddr
, inet
->daddr
);
444 EXPORT_SYMBOL_GPL(dccp_v4_send_check
);
446 static inline u64
dccp_v4_init_sequence(const struct sock
*sk
,
447 const struct sk_buff
*skb
)
449 return secure_dccp_sequence_number(skb
->nh
.iph
->daddr
,
451 dccp_hdr(skb
)->dccph_dport
,
452 dccp_hdr(skb
)->dccph_sport
);
455 int dccp_v4_conn_request(struct sock
*sk
, struct sk_buff
*skb
)
457 struct inet_request_sock
*ireq
;
459 struct request_sock
*req
;
460 struct dccp_request_sock
*dreq
;
461 const __be32 saddr
= skb
->nh
.iph
->saddr
;
462 const __be32 daddr
= skb
->nh
.iph
->daddr
;
463 const __be32 service
= dccp_hdr_request(skb
)->dccph_req_service
;
464 struct dccp_skb_cb
*dcb
= DCCP_SKB_CB(skb
);
465 __u8 reset_code
= DCCP_RESET_CODE_TOO_BUSY
;
467 /* Never answer to DCCP_PKT_REQUESTs send to broadcast or multicast */
468 if (((struct rtable
*)skb
->dst
)->rt_flags
&
469 (RTCF_BROADCAST
| RTCF_MULTICAST
)) {
470 reset_code
= DCCP_RESET_CODE_NO_CONNECTION
;
474 if (dccp_bad_service_code(sk
, service
)) {
475 reset_code
= DCCP_RESET_CODE_BAD_SERVICE_CODE
;
479 * TW buckets are converted to open requests without
480 * limitations, they conserve resources and peer is
481 * evidently real one.
483 if (inet_csk_reqsk_queue_is_full(sk
))
487 * Accept backlog is full. If we have already queued enough
488 * of warm entries in syn queue, drop request. It is better than
489 * clogging syn queue with openreqs with exponentially increasing
492 if (sk_acceptq_is_full(sk
) && inet_csk_reqsk_queue_young(sk
) > 1)
495 req
= reqsk_alloc(sk
->sk_prot
->rsk_prot
);
499 if (dccp_parse_options(sk
, skb
))
502 dccp_openreq_init(req
, &dp
, skb
);
504 ireq
= inet_rsk(req
);
505 ireq
->loc_addr
= daddr
;
506 ireq
->rmt_addr
= saddr
;
507 req
->rcv_wnd
= dccp_feat_default_sequence_window
;
511 * Step 3: Process LISTEN state
513 * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
515 * In fact we defer setting S.GSR, S.SWL, S.SWH to
516 * dccp_create_openreq_child.
518 dreq
= dccp_rsk(req
);
519 dreq
->dreq_isr
= dcb
->dccpd_seq
;
520 dreq
->dreq_iss
= dccp_v4_init_sequence(sk
, skb
);
521 dreq
->dreq_service
= service
;
523 if (dccp_v4_send_response(sk
, req
, NULL
))
526 inet_csk_reqsk_queue_hash_add(sk
, req
, DCCP_TIMEOUT_INIT
);
532 DCCP_INC_STATS_BH(DCCP_MIB_ATTEMPTFAILS
);
533 dcb
->dccpd_reset_code
= reset_code
;
537 EXPORT_SYMBOL_GPL(dccp_v4_conn_request
);
540 * The three way handshake has completed - we got a valid ACK or DATAACK -
541 * now create the new socket.
543 * This is the equivalent of TCP's tcp_v4_syn_recv_sock
545 struct sock
*dccp_v4_request_recv_sock(struct sock
*sk
, struct sk_buff
*skb
,
546 struct request_sock
*req
,
547 struct dst_entry
*dst
)
549 struct inet_request_sock
*ireq
;
550 struct inet_sock
*newinet
;
551 struct dccp_sock
*newdp
;
554 if (sk_acceptq_is_full(sk
))
557 if (dst
== NULL
&& (dst
= inet_csk_route_req(sk
, req
)) == NULL
)
560 newsk
= dccp_create_openreq_child(sk
, req
, skb
);
564 sk_setup_caps(newsk
, dst
);
566 newdp
= dccp_sk(newsk
);
567 newinet
= inet_sk(newsk
);
568 ireq
= inet_rsk(req
);
569 newinet
->daddr
= ireq
->rmt_addr
;
570 newinet
->rcv_saddr
= ireq
->loc_addr
;
571 newinet
->saddr
= ireq
->loc_addr
;
572 newinet
->opt
= ireq
->opt
;
574 newinet
->mc_index
= inet_iif(skb
);
575 newinet
->mc_ttl
= skb
->nh
.iph
->ttl
;
576 newinet
->id
= jiffies
;
578 dccp_sync_mss(newsk
, dst_mtu(dst
));
580 __inet_hash(&dccp_hashinfo
, newsk
, 0);
581 __inet_inherit_port(&dccp_hashinfo
, sk
, newsk
);
586 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS
);
588 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS
);
593 EXPORT_SYMBOL_GPL(dccp_v4_request_recv_sock
);
595 static struct sock
*dccp_v4_hnd_req(struct sock
*sk
, struct sk_buff
*skb
)
597 const struct dccp_hdr
*dh
= dccp_hdr(skb
);
598 const struct iphdr
*iph
= skb
->nh
.iph
;
600 struct request_sock
**prev
;
601 /* Find possible connection requests. */
602 struct request_sock
*req
= inet_csk_search_req(sk
, &prev
,
604 iph
->saddr
, iph
->daddr
);
606 return dccp_check_req(sk
, skb
, req
, prev
);
608 nsk
= __inet_lookup_established(&dccp_hashinfo
,
609 iph
->saddr
, dh
->dccph_sport
,
610 iph
->daddr
, ntohs(dh
->dccph_dport
),
613 if (nsk
->sk_state
!= DCCP_TIME_WAIT
) {
617 inet_twsk_put((struct inet_timewait_sock
*)nsk
);
624 int dccp_v4_checksum(const struct sk_buff
*skb
, const __be32 saddr
,
627 const struct dccp_hdr
* dh
= dccp_hdr(skb
);
631 if (dh
->dccph_cscov
== 0)
632 checksum_len
= skb
->len
;
634 checksum_len
= (dh
->dccph_cscov
+ dh
->dccph_x
) * sizeof(u32
);
635 checksum_len
= checksum_len
< skb
->len
? checksum_len
:
639 tmp
= csum_partial((unsigned char *)dh
, checksum_len
, 0);
640 return csum_tcpudp_magic(saddr
, daddr
, checksum_len
,
644 EXPORT_SYMBOL_GPL(dccp_v4_checksum
);
646 static int dccp_v4_verify_checksum(struct sk_buff
*skb
,
647 const __be32 saddr
, const __be32 daddr
)
649 struct dccp_hdr
*dh
= dccp_hdr(skb
);
653 if (dh
->dccph_cscov
== 0)
654 checksum_len
= skb
->len
;
656 checksum_len
= (dh
->dccph_cscov
+ dh
->dccph_x
) * sizeof(u32
);
657 checksum_len
= checksum_len
< skb
->len
? checksum_len
:
660 tmp
= csum_partial((unsigned char *)dh
, checksum_len
, 0);
661 return csum_tcpudp_magic(saddr
, daddr
, checksum_len
,
662 IPPROTO_DCCP
, tmp
) == 0 ? 0 : -1;
665 static struct dst_entry
* dccp_v4_route_skb(struct sock
*sk
,
669 struct flowi fl
= { .oif
= ((struct rtable
*)skb
->dst
)->rt_iif
,
671 { .daddr
= skb
->nh
.iph
->saddr
,
672 .saddr
= skb
->nh
.iph
->daddr
,
673 .tos
= RT_CONN_FLAGS(sk
) } },
674 .proto
= sk
->sk_protocol
,
676 { .sport
= dccp_hdr(skb
)->dccph_dport
,
677 .dport
= dccp_hdr(skb
)->dccph_sport
}
681 if (ip_route_output_flow(&rt
, &fl
, sk
, 0)) {
682 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES
);
689 static void dccp_v4_ctl_send_reset(struct sk_buff
*rxskb
)
692 struct dccp_hdr
*rxdh
= dccp_hdr(rxskb
), *dh
;
693 const int dccp_hdr_reset_len
= sizeof(struct dccp_hdr
) +
694 sizeof(struct dccp_hdr_ext
) +
695 sizeof(struct dccp_hdr_reset
);
697 struct dst_entry
*dst
;
700 /* Never send a reset in response to a reset. */
701 if (rxdh
->dccph_type
== DCCP_PKT_RESET
)
704 if (((struct rtable
*)rxskb
->dst
)->rt_type
!= RTN_LOCAL
)
707 dst
= dccp_v4_route_skb(dccp_v4_ctl_socket
->sk
, rxskb
);
711 skb
= alloc_skb(dccp_v4_ctl_socket
->sk
->sk_prot
->max_header
,
716 /* Reserve space for headers. */
717 skb_reserve(skb
, dccp_v4_ctl_socket
->sk
->sk_prot
->max_header
);
718 skb
->dst
= dst_clone(dst
);
720 skb
->h
.raw
= skb_push(skb
, dccp_hdr_reset_len
);
722 memset(dh
, 0, dccp_hdr_reset_len
);
724 /* Build DCCP header and checksum it. */
725 dh
->dccph_type
= DCCP_PKT_RESET
;
726 dh
->dccph_sport
= rxdh
->dccph_dport
;
727 dh
->dccph_dport
= rxdh
->dccph_sport
;
728 dh
->dccph_doff
= dccp_hdr_reset_len
/ 4;
730 dccp_hdr_reset(skb
)->dccph_reset_code
=
731 DCCP_SKB_CB(rxskb
)->dccpd_reset_code
;
733 /* See "8.3.1. Abnormal Termination" in draft-ietf-dccp-spec-11 */
735 if (DCCP_SKB_CB(rxskb
)->dccpd_ack_seq
!= DCCP_PKT_WITHOUT_ACK_SEQ
)
736 dccp_set_seqno(&seqno
, DCCP_SKB_CB(rxskb
)->dccpd_ack_seq
+ 1);
738 dccp_hdr_set_seq(dh
, seqno
);
739 dccp_hdr_set_ack(dccp_hdr_ack_bits(skb
),
740 DCCP_SKB_CB(rxskb
)->dccpd_seq
);
742 dh
->dccph_checksum
= dccp_v4_checksum(skb
, rxskb
->nh
.iph
->saddr
,
743 rxskb
->nh
.iph
->daddr
);
745 bh_lock_sock(dccp_v4_ctl_socket
->sk
);
746 err
= ip_build_and_send_pkt(skb
, dccp_v4_ctl_socket
->sk
,
747 rxskb
->nh
.iph
->daddr
,
748 rxskb
->nh
.iph
->saddr
, NULL
);
749 bh_unlock_sock(dccp_v4_ctl_socket
->sk
);
751 if (err
== NET_XMIT_CN
|| err
== 0) {
752 DCCP_INC_STATS_BH(DCCP_MIB_OUTSEGS
);
753 DCCP_INC_STATS_BH(DCCP_MIB_OUTRSTS
);
759 int dccp_v4_do_rcv(struct sock
*sk
, struct sk_buff
*skb
)
761 struct dccp_hdr
*dh
= dccp_hdr(skb
);
763 if (sk
->sk_state
== DCCP_OPEN
) { /* Fast path */
764 if (dccp_rcv_established(sk
, skb
, dh
, skb
->len
))
770 * Step 3: Process LISTEN state
771 * If S.state == LISTEN,
772 * If P.type == Request or P contains a valid Init Cookie
774 * * Must scan the packet's options to check for an Init
775 * Cookie. Only the Init Cookie is processed here,
776 * however; other options are processed in Step 8. This
777 * scan need only be performed if the endpoint uses Init
779 * * Generate a new socket and switch to that socket *
780 * Set S := new socket for this port pair
782 * Choose S.ISS (initial seqno) or set from Init Cookie
783 * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init Cookie
784 * Continue with S.state == RESPOND
785 * * A Response packet will be generated in Step 11 *
787 * Generate Reset(No Connection) unless P.type == Reset
788 * Drop packet and return
790 * NOTE: the check for the packet types is done in
791 * dccp_rcv_state_process
793 if (sk
->sk_state
== DCCP_LISTEN
) {
794 struct sock
*nsk
= dccp_v4_hnd_req(sk
, skb
);
800 if (dccp_child_process(sk
, nsk
, skb
))
806 if (dccp_rcv_state_process(sk
, skb
, dh
, skb
->len
))
811 dccp_v4_ctl_send_reset(skb
);
817 EXPORT_SYMBOL_GPL(dccp_v4_do_rcv
);
819 int dccp_invalid_packet(struct sk_buff
*skb
)
821 const struct dccp_hdr
*dh
;
823 if (skb
->pkt_type
!= PACKET_HOST
)
826 if (!pskb_may_pull(skb
, sizeof(struct dccp_hdr
))) {
827 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: pskb_may_pull failed\n");
833 /* If the packet type is not understood, drop packet and return */
834 if (dh
->dccph_type
>= DCCP_PKT_INVALID
) {
835 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: invalid packet type\n");
840 * If P.Data Offset is too small for packet type, or too large for
841 * packet, drop packet and return
843 if (dh
->dccph_doff
< dccp_hdr_len(skb
) / sizeof(u32
)) {
844 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: P.Data Offset(%u) "
850 if (!pskb_may_pull(skb
, dh
->dccph_doff
* sizeof(u32
))) {
851 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: P.Data Offset(%u) "
860 * If P.type is not Data, Ack, or DataAck and P.X == 0 (the packet
861 * has short sequence numbers), drop packet and return
863 if (dh
->dccph_x
== 0 &&
864 dh
->dccph_type
!= DCCP_PKT_DATA
&&
865 dh
->dccph_type
!= DCCP_PKT_ACK
&&
866 dh
->dccph_type
!= DCCP_PKT_DATAACK
) {
867 LIMIT_NETDEBUG(KERN_WARNING
"DCCP: P.type (%s) not Data, Ack "
868 "nor DataAck and P.X == 0\n",
869 dccp_packet_name(dh
->dccph_type
));
876 EXPORT_SYMBOL_GPL(dccp_invalid_packet
);
878 /* this is called when real data arrives */
879 static int dccp_v4_rcv(struct sk_buff
*skb
)
881 const struct dccp_hdr
*dh
;
884 /* Step 1: Check header basics: */
886 if (dccp_invalid_packet(skb
))
889 /* If the header checksum is incorrect, drop packet and return */
890 if (dccp_v4_verify_checksum(skb
, skb
->nh
.iph
->saddr
,
891 skb
->nh
.iph
->daddr
) < 0) {
892 LIMIT_NETDEBUG(KERN_WARNING
"%s: incorrect header checksum\n",
899 DCCP_SKB_CB(skb
)->dccpd_seq
= dccp_hdr_seq(skb
);
900 DCCP_SKB_CB(skb
)->dccpd_type
= dh
->dccph_type
;
902 dccp_pr_debug("%8.8s "
903 "src=%u.%u.%u.%u@%-5d "
904 "dst=%u.%u.%u.%u@%-5d seq=%llu",
905 dccp_packet_name(dh
->dccph_type
),
906 NIPQUAD(skb
->nh
.iph
->saddr
), ntohs(dh
->dccph_sport
),
907 NIPQUAD(skb
->nh
.iph
->daddr
), ntohs(dh
->dccph_dport
),
908 (unsigned long long) DCCP_SKB_CB(skb
)->dccpd_seq
);
910 if (dccp_packet_without_ack(skb
)) {
911 DCCP_SKB_CB(skb
)->dccpd_ack_seq
= DCCP_PKT_WITHOUT_ACK_SEQ
;
912 dccp_pr_debug_cat("\n");
914 DCCP_SKB_CB(skb
)->dccpd_ack_seq
= dccp_hdr_ack_seq(skb
);
915 dccp_pr_debug_cat(", ack=%llu\n",
917 DCCP_SKB_CB(skb
)->dccpd_ack_seq
);
921 * Look up flow ID in table and get corresponding socket */
922 sk
= __inet_lookup(&dccp_hashinfo
,
923 skb
->nh
.iph
->saddr
, dh
->dccph_sport
,
924 skb
->nh
.iph
->daddr
, ntohs(dh
->dccph_dport
),
930 * Generate Reset(No Connection) unless P.type == Reset
931 * Drop packet and return
934 dccp_pr_debug("failed to look up flow ID in table and "
935 "get corresponding socket\n");
941 * ... or S.state == TIMEWAIT,
942 * Generate Reset(No Connection) unless P.type == Reset
943 * Drop packet and return
946 if (sk
->sk_state
== DCCP_TIME_WAIT
) {
947 dccp_pr_debug("sk->sk_state == DCCP_TIME_WAIT: "
952 if (!xfrm4_policy_check(sk
, XFRM_POLICY_IN
, skb
))
953 goto discard_and_relse
;
956 return sk_receive_skb(sk
, skb
);
959 if (!xfrm4_policy_check(NULL
, XFRM_POLICY_IN
, skb
))
963 * Generate Reset(No Connection) unless P.type == Reset
964 * Drop packet and return
966 if (dh
->dccph_type
!= DCCP_PKT_RESET
) {
967 DCCP_SKB_CB(skb
)->dccpd_reset_code
=
968 DCCP_RESET_CODE_NO_CONNECTION
;
969 dccp_v4_ctl_send_reset(skb
);
982 inet_twsk_put((struct inet_timewait_sock
*)sk
);
986 static struct inet_connection_sock_af_ops dccp_ipv4_af_ops
= {
987 .queue_xmit
= ip_queue_xmit
,
988 .send_check
= dccp_v4_send_check
,
989 .rebuild_header
= inet_sk_rebuild_header
,
990 .conn_request
= dccp_v4_conn_request
,
991 .syn_recv_sock
= dccp_v4_request_recv_sock
,
992 .net_header_len
= sizeof(struct iphdr
),
993 .setsockopt
= ip_setsockopt
,
994 .getsockopt
= ip_getsockopt
,
995 .addr2sockaddr
= inet_csk_addr2sockaddr
,
996 .sockaddr_len
= sizeof(struct sockaddr_in
),
998 .compat_setsockopt
= compat_ip_setsockopt
,
999 .compat_getsockopt
= compat_ip_getsockopt
,
1003 static int dccp_v4_init_sock(struct sock
*sk
)
1005 static __u8 dccp_v4_ctl_sock_initialized
;
1006 int err
= dccp_init_sock(sk
, dccp_v4_ctl_sock_initialized
);
1009 if (unlikely(!dccp_v4_ctl_sock_initialized
))
1010 dccp_v4_ctl_sock_initialized
= 1;
1011 inet_csk(sk
)->icsk_af_ops
= &dccp_ipv4_af_ops
;
1017 static void dccp_v4_reqsk_destructor(struct request_sock
*req
)
1019 kfree(inet_rsk(req
)->opt
);
1022 static struct request_sock_ops dccp_request_sock_ops
= {
1024 .obj_size
= sizeof(struct dccp_request_sock
),
1025 .rtx_syn_ack
= dccp_v4_send_response
,
1026 .send_ack
= dccp_v4_reqsk_send_ack
,
1027 .destructor
= dccp_v4_reqsk_destructor
,
1028 .send_reset
= dccp_v4_ctl_send_reset
,
1031 static struct timewait_sock_ops dccp_timewait_sock_ops
= {
1032 .twsk_obj_size
= sizeof(struct inet_timewait_sock
),
1035 static struct proto dccp_v4_prot
= {
1037 .owner
= THIS_MODULE
,
1038 .close
= dccp_close
,
1039 .connect
= dccp_v4_connect
,
1040 .disconnect
= dccp_disconnect
,
1041 .ioctl
= dccp_ioctl
,
1042 .init
= dccp_v4_init_sock
,
1043 .setsockopt
= dccp_setsockopt
,
1044 .getsockopt
= dccp_getsockopt
,
1045 .sendmsg
= dccp_sendmsg
,
1046 .recvmsg
= dccp_recvmsg
,
1047 .backlog_rcv
= dccp_v4_do_rcv
,
1049 .unhash
= dccp_unhash
,
1050 .accept
= inet_csk_accept
,
1051 .get_port
= dccp_v4_get_port
,
1052 .shutdown
= dccp_shutdown
,
1053 .destroy
= dccp_destroy_sock
,
1054 .orphan_count
= &dccp_orphan_count
,
1055 .max_header
= MAX_DCCP_HEADER
,
1056 .obj_size
= sizeof(struct dccp_sock
),
1057 .rsk_prot
= &dccp_request_sock_ops
,
1058 .twsk_prot
= &dccp_timewait_sock_ops
,
1059 #ifdef CONFIG_COMPAT
1060 .compat_setsockopt
= compat_dccp_setsockopt
,
1061 .compat_getsockopt
= compat_dccp_getsockopt
,
1065 static struct net_protocol dccp_v4_protocol
= {
1066 .handler
= dccp_v4_rcv
,
1067 .err_handler
= dccp_v4_err
,
1071 static const struct proto_ops inet_dccp_ops
= {
1073 .owner
= THIS_MODULE
,
1074 .release
= inet_release
,
1076 .connect
= inet_stream_connect
,
1077 .socketpair
= sock_no_socketpair
,
1078 .accept
= inet_accept
,
1079 .getname
= inet_getname
,
1080 /* FIXME: work on tcp_poll to rename it to inet_csk_poll */
1082 .ioctl
= inet_ioctl
,
1083 /* FIXME: work on inet_listen to rename it to sock_common_listen */
1084 .listen
= inet_dccp_listen
,
1085 .shutdown
= inet_shutdown
,
1086 .setsockopt
= sock_common_setsockopt
,
1087 .getsockopt
= sock_common_getsockopt
,
1088 .sendmsg
= inet_sendmsg
,
1089 .recvmsg
= sock_common_recvmsg
,
1090 .mmap
= sock_no_mmap
,
1091 .sendpage
= sock_no_sendpage
,
1092 #ifdef CONFIG_COMPAT
1093 .compat_setsockopt
= compat_sock_common_setsockopt
,
1094 .compat_getsockopt
= compat_sock_common_getsockopt
,
1098 static struct inet_protosw dccp_v4_protosw
= {
1100 .protocol
= IPPROTO_DCCP
,
1101 .prot
= &dccp_v4_prot
,
1102 .ops
= &inet_dccp_ops
,
1105 .flags
= INET_PROTOSW_ICSK
,
1108 static int __init
dccp_v4_init(void)
1110 int err
= proto_register(&dccp_v4_prot
, 1);
1115 err
= inet_add_protocol(&dccp_v4_protocol
, IPPROTO_DCCP
);
1117 goto out_proto_unregister
;
1119 inet_register_protosw(&dccp_v4_protosw
);
1121 err
= inet_csk_ctl_sock_create(&dccp_v4_ctl_socket
, PF_INET
,
1122 SOCK_DCCP
, IPPROTO_DCCP
);
1124 goto out_unregister_protosw
;
1127 out_unregister_protosw
:
1128 inet_unregister_protosw(&dccp_v4_protosw
);
1129 inet_del_protocol(&dccp_v4_protocol
, IPPROTO_DCCP
);
1130 out_proto_unregister
:
1131 proto_unregister(&dccp_v4_prot
);
1135 static void __exit
dccp_v4_exit(void)
1137 inet_unregister_protosw(&dccp_v4_protosw
);
1138 inet_del_protocol(&dccp_v4_protocol
, IPPROTO_DCCP
);
1139 proto_unregister(&dccp_v4_prot
);
1142 module_init(dccp_v4_init
);
1143 module_exit(dccp_v4_exit
);
1146 * __stringify doesn't likes enums, so use SOCK_DCCP (6) and IPPROTO_DCCP (33)
1147 * values directly, Also cover the case where the protocol is not specified,
1148 * i.e. net-pf-PF_INET-proto-0-type-SOCK_DCCP
1150 MODULE_ALIAS("net-pf-" __stringify(PF_INET
) "-proto-33-type-6");
1151 MODULE_ALIAS("net-pf-" __stringify(PF_INET
) "-proto-0-type-6");
1152 MODULE_LICENSE("GPL");
1153 MODULE_AUTHOR("Arnaldo Carvalho de Melo <acme@mandriva.com>");
1154 MODULE_DESCRIPTION("DCCP - Datagram Congestion Controlled Protocol");