xref: /openbmc/linux/net/dccp/input.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /*
2  *  net/dccp/input.c
3  *
4  *  An implementation of the DCCP protocol
5  *  Arnaldo Carvalho de Melo <acme@conectiva.com.br>
6  *
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.
11  */
12 
13 #include <linux/dccp.h>
14 #include <linux/skbuff.h>
15 
16 #include <net/sock.h>
17 
18 #include "ackvec.h"
19 #include "ccid.h"
20 #include "dccp.h"
21 
22 static void dccp_fin(struct sock *sk, struct sk_buff *skb)
23 {
24 	sk->sk_shutdown |= RCV_SHUTDOWN;
25 	sock_set_flag(sk, SOCK_DONE);
26 	__skb_pull(skb, dccp_hdr(skb)->dccph_doff * 4);
27 	__skb_queue_tail(&sk->sk_receive_queue, skb);
28 	skb_set_owner_r(skb, sk);
29 	sk->sk_data_ready(sk, 0);
30 }
31 
32 static void dccp_rcv_close(struct sock *sk, struct sk_buff *skb)
33 {
34 	dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
35 	dccp_fin(sk, skb);
36 	dccp_set_state(sk, DCCP_CLOSED);
37 	sk_wake_async(sk, 1, POLL_HUP);
38 }
39 
40 static void dccp_rcv_closereq(struct sock *sk, struct sk_buff *skb)
41 {
42 	/*
43 	 *   Step 7: Check for unexpected packet types
44 	 *      If (S.is_server and P.type == CloseReq)
45 	 *	  Send Sync packet acknowledging P.seqno
46 	 *	  Drop packet and return
47 	 */
48 	if (dccp_sk(sk)->dccps_role != DCCP_ROLE_CLIENT) {
49 		dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq, DCCP_PKT_SYNC);
50 		return;
51 	}
52 
53 	if (sk->sk_state != DCCP_CLOSING)
54 		dccp_set_state(sk, DCCP_CLOSING);
55 	dccp_send_close(sk, 0);
56 }
57 
58 static void dccp_event_ack_recv(struct sock *sk, struct sk_buff *skb)
59 {
60 	struct dccp_sock *dp = dccp_sk(sk);
61 
62 	if (dccp_msk(sk)->dccpms_send_ack_vector)
63 		dccp_ackvec_check_rcv_ackno(dp->dccps_hc_rx_ackvec, sk,
64 					    DCCP_SKB_CB(skb)->dccpd_ack_seq);
65 }
66 
67 static int dccp_check_seqno(struct sock *sk, struct sk_buff *skb)
68 {
69 	const struct dccp_hdr *dh = dccp_hdr(skb);
70 	struct dccp_sock *dp = dccp_sk(sk);
71 	u64 lswl, lawl;
72 
73 	/*
74 	 *   Step 5: Prepare sequence numbers for Sync
75 	 *     If P.type == Sync or P.type == SyncAck,
76 	 *	  If S.AWL <= P.ackno <= S.AWH and P.seqno >= S.SWL,
77 	 *	     / * P is valid, so update sequence number variables
78 	 *		 accordingly.  After this update, P will pass the tests
79 	 *		 in Step 6.  A SyncAck is generated if necessary in
80 	 *		 Step 15 * /
81 	 *	     Update S.GSR, S.SWL, S.SWH
82 	 *	  Otherwise,
83 	 *	     Drop packet and return
84 	 */
85 	if (dh->dccph_type == DCCP_PKT_SYNC ||
86 	    dh->dccph_type == DCCP_PKT_SYNCACK) {
87 		if (between48(DCCP_SKB_CB(skb)->dccpd_ack_seq,
88 			      dp->dccps_awl, dp->dccps_awh) &&
89 		    dccp_delta_seqno(dp->dccps_swl,
90 				     DCCP_SKB_CB(skb)->dccpd_seq) >= 0)
91 			dccp_update_gsr(sk, DCCP_SKB_CB(skb)->dccpd_seq);
92 		else
93 			return -1;
94 	}
95 
96 	/*
97 	 *   Step 6: Check sequence numbers
98 	 *      Let LSWL = S.SWL and LAWL = S.AWL
99 	 *      If P.type == CloseReq or P.type == Close or P.type == Reset,
100 	 *	  LSWL := S.GSR + 1, LAWL := S.GAR
101 	 *      If LSWL <= P.seqno <= S.SWH
102 	 *	     and (P.ackno does not exist or LAWL <= P.ackno <= S.AWH),
103 	 *	  Update S.GSR, S.SWL, S.SWH
104 	 *	  If P.type != Sync,
105 	 *	     Update S.GAR
106 	 *      Otherwise,
107 	 *	  Send Sync packet acknowledging P.seqno
108 	 *	  Drop packet and return
109 	 */
110 	lswl = dp->dccps_swl;
111 	lawl = dp->dccps_awl;
112 
113 	if (dh->dccph_type == DCCP_PKT_CLOSEREQ ||
114 	    dh->dccph_type == DCCP_PKT_CLOSE ||
115 	    dh->dccph_type == DCCP_PKT_RESET) {
116 		lswl = dp->dccps_gsr;
117 		dccp_inc_seqno(&lswl);
118 		lawl = dp->dccps_gar;
119 	}
120 
121 	if (between48(DCCP_SKB_CB(skb)->dccpd_seq, lswl, dp->dccps_swh) &&
122 	    (DCCP_SKB_CB(skb)->dccpd_ack_seq == DCCP_PKT_WITHOUT_ACK_SEQ ||
123 	     between48(DCCP_SKB_CB(skb)->dccpd_ack_seq,
124 		       lawl, dp->dccps_awh))) {
125 		dccp_update_gsr(sk, DCCP_SKB_CB(skb)->dccpd_seq);
126 
127 		if (dh->dccph_type != DCCP_PKT_SYNC &&
128 		    (DCCP_SKB_CB(skb)->dccpd_ack_seq !=
129 		     DCCP_PKT_WITHOUT_ACK_SEQ))
130 			dp->dccps_gar = DCCP_SKB_CB(skb)->dccpd_ack_seq;
131 	} else {
132 		DCCP_WARN("DCCP: Step 6 failed for %s packet, "
133 			  "(LSWL(%llu) <= P.seqno(%llu) <= S.SWH(%llu)) and "
134 			  "(P.ackno %s or LAWL(%llu) <= P.ackno(%llu) <= S.AWH(%llu), "
135 			  "sending SYNC...\n",  dccp_packet_name(dh->dccph_type),
136 			  (unsigned long long) lswl,
137 			  (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq,
138 			  (unsigned long long) dp->dccps_swh,
139 			  (DCCP_SKB_CB(skb)->dccpd_ack_seq ==
140 				DCCP_PKT_WITHOUT_ACK_SEQ) ? "doesn't exist" : "exists",
141 			  (unsigned long long) lawl,
142 			  (unsigned long long) DCCP_SKB_CB(skb)->dccpd_ack_seq,
143 			  (unsigned long long) dp->dccps_awh);
144 		dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq, DCCP_PKT_SYNC);
145 		return -1;
146 	}
147 
148 	return 0;
149 }
150 
151 static int __dccp_rcv_established(struct sock *sk, struct sk_buff *skb,
152 				  const struct dccp_hdr *dh, const unsigned len)
153 {
154 	struct dccp_sock *dp = dccp_sk(sk);
155 
156 	switch (dccp_hdr(skb)->dccph_type) {
157 	case DCCP_PKT_DATAACK:
158 	case DCCP_PKT_DATA:
159 		/*
160 		 * FIXME: check if sk_receive_queue is full, schedule DATA_DROPPED
161 		 * option if it is.
162 		 */
163 		__skb_pull(skb, dh->dccph_doff * 4);
164 		__skb_queue_tail(&sk->sk_receive_queue, skb);
165 		skb_set_owner_r(skb, sk);
166 		sk->sk_data_ready(sk, 0);
167 		return 0;
168 	case DCCP_PKT_ACK:
169 		goto discard;
170 	case DCCP_PKT_RESET:
171 		/*
172 		 *  Step 9: Process Reset
173 		 *	If P.type == Reset,
174 		 *		Tear down connection
175 		 *		S.state := TIMEWAIT
176 		 *		Set TIMEWAIT timer
177 		 *		Drop packet and return
178 		*/
179 		dccp_fin(sk, skb);
180 		dccp_time_wait(sk, DCCP_TIME_WAIT, 0);
181 		return 0;
182 	case DCCP_PKT_CLOSEREQ:
183 		dccp_rcv_closereq(sk, skb);
184 		goto discard;
185 	case DCCP_PKT_CLOSE:
186 		dccp_rcv_close(sk, skb);
187 		return 0;
188 	case DCCP_PKT_REQUEST:
189 		/* Step 7
190 		 *   or (S.is_server and P.type == Response)
191 		 *   or (S.is_client and P.type == Request)
192 		 *   or (S.state >= OPEN and P.type == Request
193 		 *	and P.seqno >= S.OSR)
194 		 *    or (S.state >= OPEN and P.type == Response
195 		 *	and P.seqno >= S.OSR)
196 		 *    or (S.state == RESPOND and P.type == Data),
197 		 *  Send Sync packet acknowledging P.seqno
198 		 *  Drop packet and return
199 		 */
200 		if (dp->dccps_role != DCCP_ROLE_LISTEN)
201 			goto send_sync;
202 		goto check_seq;
203 	case DCCP_PKT_RESPONSE:
204 		if (dp->dccps_role != DCCP_ROLE_CLIENT)
205 			goto send_sync;
206 check_seq:
207 		if (dccp_delta_seqno(dp->dccps_osr,
208 				     DCCP_SKB_CB(skb)->dccpd_seq) >= 0) {
209 send_sync:
210 			dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq,
211 				       DCCP_PKT_SYNC);
212 		}
213 		break;
214 	case DCCP_PKT_SYNC:
215 		dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq,
216 			       DCCP_PKT_SYNCACK);
217 		/*
218 		 * From RFC 4340, sec. 5.7
219 		 *
220 		 * As with DCCP-Ack packets, DCCP-Sync and DCCP-SyncAck packets
221 		 * MAY have non-zero-length application data areas, whose
222 		 * contents receivers MUST ignore.
223 		 */
224 		goto discard;
225 	}
226 
227 	DCCP_INC_STATS_BH(DCCP_MIB_INERRS);
228 discard:
229 	__kfree_skb(skb);
230 	return 0;
231 }
232 
233 int dccp_rcv_established(struct sock *sk, struct sk_buff *skb,
234 			 const struct dccp_hdr *dh, const unsigned len)
235 {
236 	struct dccp_sock *dp = dccp_sk(sk);
237 
238 	if (dccp_check_seqno(sk, skb))
239 		goto discard;
240 
241 	if (dccp_parse_options(sk, skb))
242 		goto discard;
243 
244 	if (DCCP_SKB_CB(skb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
245 		dccp_event_ack_recv(sk, skb);
246 
247 	if (dccp_msk(sk)->dccpms_send_ack_vector &&
248 	    dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
249 			    DCCP_SKB_CB(skb)->dccpd_seq,
250 			    DCCP_ACKVEC_STATE_RECEIVED))
251 		goto discard;
252 
253 	ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb);
254 	ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb);
255 
256 	return __dccp_rcv_established(sk, skb, dh, len);
257 discard:
258 	__kfree_skb(skb);
259 	return 0;
260 }
261 
262 EXPORT_SYMBOL_GPL(dccp_rcv_established);
263 
264 static int dccp_rcv_request_sent_state_process(struct sock *sk,
265 					       struct sk_buff *skb,
266 					       const struct dccp_hdr *dh,
267 					       const unsigned len)
268 {
269 	/*
270 	 *  Step 4: Prepare sequence numbers in REQUEST
271 	 *     If S.state == REQUEST,
272 	 *	  If (P.type == Response or P.type == Reset)
273 	 *		and S.AWL <= P.ackno <= S.AWH,
274 	 *	     / * Set sequence number variables corresponding to the
275 	 *		other endpoint, so P will pass the tests in Step 6 * /
276 	 *	     Set S.GSR, S.ISR, S.SWL, S.SWH
277 	 *	     / * Response processing continues in Step 10; Reset
278 	 *		processing continues in Step 9 * /
279 	*/
280 	if (dh->dccph_type == DCCP_PKT_RESPONSE) {
281 		const struct inet_connection_sock *icsk = inet_csk(sk);
282 		struct dccp_sock *dp = dccp_sk(sk);
283 
284 		/* Stop the REQUEST timer */
285 		inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
286 		BUG_TRAP(sk->sk_send_head != NULL);
287 		__kfree_skb(sk->sk_send_head);
288 		sk->sk_send_head = NULL;
289 
290 		if (!between48(DCCP_SKB_CB(skb)->dccpd_ack_seq,
291 			       dp->dccps_awl, dp->dccps_awh)) {
292 			dccp_pr_debug("invalid ackno: S.AWL=%llu, "
293 				      "P.ackno=%llu, S.AWH=%llu \n",
294 				      (unsigned long long)dp->dccps_awl,
295 			   (unsigned long long)DCCP_SKB_CB(skb)->dccpd_ack_seq,
296 				      (unsigned long long)dp->dccps_awh);
297 			goto out_invalid_packet;
298 		}
299 
300 		if (dccp_parse_options(sk, skb))
301 			goto out_invalid_packet;
302 
303 		/* Obtain RTT sample from SYN exchange (used by CCID 3) */
304 		if (dp->dccps_options_received.dccpor_timestamp_echo) {
305 			struct timeval now;
306 
307 			dccp_timestamp(sk, &now);
308 			dp->dccps_syn_rtt = dccp_sample_rtt(sk, &now, NULL);
309 		}
310 
311 		if (dccp_msk(sk)->dccpms_send_ack_vector &&
312 		    dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
313 				    DCCP_SKB_CB(skb)->dccpd_seq,
314 				    DCCP_ACKVEC_STATE_RECEIVED))
315 			goto out_invalid_packet; /* FIXME: change error code */
316 
317 		dp->dccps_isr = DCCP_SKB_CB(skb)->dccpd_seq;
318 		dccp_update_gsr(sk, dp->dccps_isr);
319 		/*
320 		 * SWL and AWL are initially adjusted so that they are not less than
321 		 * the initial Sequence Numbers received and sent, respectively:
322 		 *	SWL := max(GSR + 1 - floor(W/4), ISR),
323 		 *	AWL := max(GSS - W' + 1, ISS).
324 		 * These adjustments MUST be applied only at the beginning of the
325 		 * connection.
326 		 *
327 		 * AWL was adjusted in dccp_v4_connect -acme
328 		 */
329 		dccp_set_seqno(&dp->dccps_swl,
330 			       max48(dp->dccps_swl, dp->dccps_isr));
331 
332 		dccp_sync_mss(sk, icsk->icsk_pmtu_cookie);
333 
334 		/*
335 		 *    Step 10: Process REQUEST state (second part)
336 		 *       If S.state == REQUEST,
337 		 *	  / * If we get here, P is a valid Response from the
338 		 *	      server (see Step 4), and we should move to
339 		 *	      PARTOPEN state. PARTOPEN means send an Ack,
340 		 *	      don't send Data packets, retransmit Acks
341 		 *	      periodically, and always include any Init Cookie
342 		 *	      from the Response * /
343 		 *	  S.state := PARTOPEN
344 		 *	  Set PARTOPEN timer
345 		 *	  Continue with S.state == PARTOPEN
346 		 *	  / * Step 12 will send the Ack completing the
347 		 *	      three-way handshake * /
348 		 */
349 		dccp_set_state(sk, DCCP_PARTOPEN);
350 
351 		/* Make sure socket is routed, for correct metrics. */
352 		icsk->icsk_af_ops->rebuild_header(sk);
353 
354 		if (!sock_flag(sk, SOCK_DEAD)) {
355 			sk->sk_state_change(sk);
356 			sk_wake_async(sk, 0, POLL_OUT);
357 		}
358 
359 		if (sk->sk_write_pending || icsk->icsk_ack.pingpong ||
360 		    icsk->icsk_accept_queue.rskq_defer_accept) {
361 			/* Save one ACK. Data will be ready after
362 			 * several ticks, if write_pending is set.
363 			 *
364 			 * It may be deleted, but with this feature tcpdumps
365 			 * look so _wonderfully_ clever, that I was not able
366 			 * to stand against the temptation 8)     --ANK
367 			 */
368 			/*
369 			 * OK, in DCCP we can as well do a similar trick, its
370 			 * even in the draft, but there is no need for us to
371 			 * schedule an ack here, as dccp_sendmsg does this for
372 			 * us, also stated in the draft. -acme
373 			 */
374 			__kfree_skb(skb);
375 			return 0;
376 		}
377 		dccp_send_ack(sk);
378 		return -1;
379 	}
380 
381 out_invalid_packet:
382 	/* dccp_v4_do_rcv will send a reset */
383 	DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_PACKET_ERROR;
384 	return 1;
385 }
386 
387 static int dccp_rcv_respond_partopen_state_process(struct sock *sk,
388 						   struct sk_buff *skb,
389 						   const struct dccp_hdr *dh,
390 						   const unsigned len)
391 {
392 	int queued = 0;
393 
394 	switch (dh->dccph_type) {
395 	case DCCP_PKT_RESET:
396 		inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
397 		break;
398 	case DCCP_PKT_DATA:
399 		if (sk->sk_state == DCCP_RESPOND)
400 			break;
401 	case DCCP_PKT_DATAACK:
402 	case DCCP_PKT_ACK:
403 		/*
404 		 * FIXME: we should be reseting the PARTOPEN (DELACK) timer
405 		 * here but only if we haven't used the DELACK timer for
406 		 * something else, like sending a delayed ack for a TIMESTAMP
407 		 * echo, etc, for now were not clearing it, sending an extra
408 		 * ACK when there is nothing else to do in DELACK is not a big
409 		 * deal after all.
410 		 */
411 
412 		/* Stop the PARTOPEN timer */
413 		if (sk->sk_state == DCCP_PARTOPEN)
414 			inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
415 
416 		dccp_sk(sk)->dccps_osr = DCCP_SKB_CB(skb)->dccpd_seq;
417 		dccp_set_state(sk, DCCP_OPEN);
418 
419 		if (dh->dccph_type == DCCP_PKT_DATAACK ||
420 		    dh->dccph_type == DCCP_PKT_DATA) {
421 			__dccp_rcv_established(sk, skb, dh, len);
422 			queued = 1; /* packet was queued
423 				       (by __dccp_rcv_established) */
424 		}
425 		break;
426 	}
427 
428 	return queued;
429 }
430 
431 int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
432 			   struct dccp_hdr *dh, unsigned len)
433 {
434 	struct dccp_sock *dp = dccp_sk(sk);
435 	struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
436 	const int old_state = sk->sk_state;
437 	int queued = 0;
438 
439 	/*
440 	 *  Step 3: Process LISTEN state
441 	 *
442 	 *     If S.state == LISTEN,
443 	 *	 If P.type == Request or P contains a valid Init Cookie option,
444 	 *	      (* Must scan the packet's options to check for Init
445 	 *		 Cookies.  Only Init Cookies are processed here,
446 	 *		 however; other options are processed in Step 8.  This
447 	 *		 scan need only be performed if the endpoint uses Init
448 	 *		 Cookies *)
449 	 *	      (* Generate a new socket and switch to that socket *)
450 	 *	      Set S := new socket for this port pair
451 	 *	      S.state = RESPOND
452 	 *	      Choose S.ISS (initial seqno) or set from Init Cookies
453 	 *	      Initialize S.GAR := S.ISS
454 	 *	      Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init
455 	 *	      Cookies Continue with S.state == RESPOND
456 	 *	      (* A Response packet will be generated in Step 11 *)
457 	 *	 Otherwise,
458 	 *	      Generate Reset(No Connection) unless P.type == Reset
459 	 *	      Drop packet and return
460 	 */
461 	if (sk->sk_state == DCCP_LISTEN) {
462 		if (dh->dccph_type == DCCP_PKT_REQUEST) {
463 			if (inet_csk(sk)->icsk_af_ops->conn_request(sk,
464 								    skb) < 0)
465 				return 1;
466 
467 			/* FIXME: do congestion control initialization */
468 			goto discard;
469 		}
470 		if (dh->dccph_type == DCCP_PKT_RESET)
471 			goto discard;
472 
473 		/* Caller (dccp_v4_do_rcv) will send Reset */
474 		dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
475 		return 1;
476 	}
477 
478 	if (sk->sk_state != DCCP_REQUESTING) {
479 		if (dccp_check_seqno(sk, skb))
480 			goto discard;
481 
482 		/*
483 		 * Step 8: Process options and mark acknowledgeable
484 		 */
485 		if (dccp_parse_options(sk, skb))
486 			goto discard;
487 
488 		if (dcb->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
489 			dccp_event_ack_recv(sk, skb);
490 
491 		if (dccp_msk(sk)->dccpms_send_ack_vector &&
492 		    dccp_ackvec_add(dp->dccps_hc_rx_ackvec, sk,
493 				    DCCP_SKB_CB(skb)->dccpd_seq,
494 				    DCCP_ACKVEC_STATE_RECEIVED))
495 			goto discard;
496 
497 		ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb);
498 		ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb);
499 	}
500 
501 	/*
502 	 *  Step 9: Process Reset
503 	 *	If P.type == Reset,
504 	 *		Tear down connection
505 	 *		S.state := TIMEWAIT
506 	 *		Set TIMEWAIT timer
507 	 *		Drop packet and return
508 	*/
509 	if (dh->dccph_type == DCCP_PKT_RESET) {
510 		/*
511 		 * Queue the equivalent of TCP fin so that dccp_recvmsg
512 		 * exits the loop
513 		 */
514 		dccp_fin(sk, skb);
515 		dccp_time_wait(sk, DCCP_TIME_WAIT, 0);
516 		return 0;
517 		/*
518 		 *   Step 7: Check for unexpected packet types
519 		 *      If (S.is_server and P.type == CloseReq)
520 		 *	    or (S.is_server and P.type == Response)
521 		 *	    or (S.is_client and P.type == Request)
522 		 *	    or (S.state == RESPOND and P.type == Data),
523 		 *	  Send Sync packet acknowledging P.seqno
524 		 *	  Drop packet and return
525 		 */
526 	} else if ((dp->dccps_role != DCCP_ROLE_CLIENT &&
527 		    (dh->dccph_type == DCCP_PKT_RESPONSE ||
528 		     dh->dccph_type == DCCP_PKT_CLOSEREQ)) ||
529 		    (dp->dccps_role == DCCP_ROLE_CLIENT &&
530 		     dh->dccph_type == DCCP_PKT_REQUEST) ||
531 		    (sk->sk_state == DCCP_RESPOND &&
532 		     dh->dccph_type == DCCP_PKT_DATA)) {
533 		dccp_send_sync(sk, dcb->dccpd_seq, DCCP_PKT_SYNC);
534 		goto discard;
535 	} else if (dh->dccph_type == DCCP_PKT_CLOSEREQ) {
536 		dccp_rcv_closereq(sk, skb);
537 		goto discard;
538 	} else if (dh->dccph_type == DCCP_PKT_CLOSE) {
539 		dccp_rcv_close(sk, skb);
540 		return 0;
541 	}
542 
543 	if (unlikely(dh->dccph_type == DCCP_PKT_SYNC)) {
544 		dccp_send_sync(sk, dcb->dccpd_seq, DCCP_PKT_SYNCACK);
545 		goto discard;
546 	}
547 
548 	switch (sk->sk_state) {
549 	case DCCP_CLOSED:
550 		dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
551 		return 1;
552 
553 	case DCCP_REQUESTING:
554 		/* FIXME: do congestion control initialization */
555 
556 		queued = dccp_rcv_request_sent_state_process(sk, skb, dh, len);
557 		if (queued >= 0)
558 			return queued;
559 
560 		__kfree_skb(skb);
561 		return 0;
562 
563 	case DCCP_RESPOND:
564 	case DCCP_PARTOPEN:
565 		queued = dccp_rcv_respond_partopen_state_process(sk, skb,
566 								 dh, len);
567 		break;
568 	}
569 
570 	if (dh->dccph_type == DCCP_PKT_ACK ||
571 	    dh->dccph_type == DCCP_PKT_DATAACK) {
572 		switch (old_state) {
573 		case DCCP_PARTOPEN:
574 			sk->sk_state_change(sk);
575 			sk_wake_async(sk, 0, POLL_OUT);
576 			break;
577 		}
578 	}
579 
580 	if (!queued) {
581 discard:
582 		__kfree_skb(skb);
583 	}
584 	return 0;
585 }
586 
587 EXPORT_SYMBOL_GPL(dccp_rcv_state_process);
588 
589 /**
590  * dccp_sample_rtt  -  Sample RTT from packet exchange
591  *
592  * @sk:     connected dccp_sock
593  * @t_recv: receive timestamp of packet with timestamp echo
594  * @t_hist: packet history timestamp or NULL
595  */
596 u32 dccp_sample_rtt(struct sock *sk, struct timeval *t_recv,
597 				     struct timeval *t_hist)
598 {
599 	struct dccp_sock *dp = dccp_sk(sk);
600 	struct dccp_options_received *or = &dp->dccps_options_received;
601 	suseconds_t delta;
602 
603 	if (t_hist == NULL) {
604 		if (!or->dccpor_timestamp_echo) {
605 			DCCP_WARN("packet without timestamp echo\n");
606 			return DCCP_SANE_RTT_MAX;
607 		}
608 		timeval_sub_usecs(t_recv, or->dccpor_timestamp_echo * 10);
609 		delta = timeval_usecs(t_recv);
610 	} else
611 		delta = timeval_delta(t_recv, t_hist);
612 
613 	delta -= or->dccpor_elapsed_time * 10;		/* either set or 0 */
614 
615 	if (unlikely(delta <= 0)) {
616 		DCCP_WARN("unusable RTT sample %ld, using min\n", (long)delta);
617 		return DCCP_SANE_RTT_MIN;
618 	}
619 	if (unlikely(delta - (suseconds_t)DCCP_SANE_RTT_MAX > 0)) {
620 		DCCP_WARN("RTT sample %ld too large, using max\n", (long)delta);
621 		return DCCP_SANE_RTT_MAX;
622 	}
623 
624 	return delta;
625 }
626 
627 EXPORT_SYMBOL_GPL(dccp_sample_rtt);
628