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