Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 1 | /* |
| 2 | * net/dccp/input.c |
Arnaldo Carvalho de Melo | 8109b02 | 2006-12-10 16:01:18 -0200 | [diff] [blame] | 3 | * |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 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 | |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 13 | #include <linux/dccp.h> |
| 14 | #include <linux/skbuff.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 15 | #include <linux/slab.h> |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 16 | |
| 17 | #include <net/sock.h> |
| 18 | |
Arnaldo Carvalho de Melo | ae31c33 | 2005-09-18 00:17:51 -0700 | [diff] [blame] | 19 | #include "ackvec.h" |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 20 | #include "ccid.h" |
| 21 | #include "dccp.h" |
| 22 | |
Ingo Molnar | bd5435e | 2007-10-17 19:33:06 -0700 | [diff] [blame] | 23 | /* rate-limit for syncs in reply to sequence-invalid packets; RFC 4340, 7.5.4 */ |
| 24 | int sysctl_dccp_sync_ratelimit __read_mostly = HZ / 8; |
| 25 | |
Gerrit Renker | 69567d0 | 2007-12-13 11:28:43 -0200 | [diff] [blame] | 26 | static void dccp_enqueue_skb(struct sock *sk, struct sk_buff *skb) |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 27 | { |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 28 | __skb_pull(skb, dccp_hdr(skb)->dccph_doff * 4); |
| 29 | __skb_queue_tail(&sk->sk_receive_queue, skb); |
| 30 | skb_set_owner_r(skb, sk); |
David S. Miller | 676d236 | 2014-04-11 16:15:36 -0400 | [diff] [blame] | 31 | sk->sk_data_ready(sk); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 32 | } |
| 33 | |
Gerrit Renker | 69567d0 | 2007-12-13 11:28:43 -0200 | [diff] [blame] | 34 | static void dccp_fin(struct sock *sk, struct sk_buff *skb) |
| 35 | { |
| 36 | /* |
| 37 | * On receiving Close/CloseReq, both RD/WR shutdown are performed. |
| 38 | * RFC 4340, 8.3 says that we MAY send further Data/DataAcks after |
| 39 | * receiving the closing segment, but there is no guarantee that such |
| 40 | * data will be processed at all. |
| 41 | */ |
| 42 | sk->sk_shutdown = SHUTDOWN_MASK; |
| 43 | sock_set_flag(sk, SOCK_DONE); |
| 44 | dccp_enqueue_skb(sk, skb); |
| 45 | } |
| 46 | |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 47 | static int dccp_rcv_close(struct sock *sk, struct sk_buff *skb) |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 48 | { |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 49 | int queued = 0; |
| 50 | |
| 51 | switch (sk->sk_state) { |
| 52 | /* |
| 53 | * We ignore Close when received in one of the following states: |
| 54 | * - CLOSED (may be a late or duplicate packet) |
| 55 | * - PASSIVE_CLOSEREQ (the peer has sent a CloseReq earlier) |
| 56 | * - RESPOND (already handled by dccp_check_req) |
| 57 | */ |
| 58 | case DCCP_CLOSING: |
| 59 | /* |
| 60 | * Simultaneous-close: receiving a Close after sending one. This |
| 61 | * can happen if both client and server perform active-close and |
| 62 | * will result in an endless ping-pong of crossing and retrans- |
| 63 | * mitted Close packets, which only terminates when one of the |
| 64 | * nodes times out (min. 64 seconds). Quicker convergence can be |
| 65 | * achieved when one of the nodes acts as tie-breaker. |
| 66 | * This is ok as both ends are done with data transfer and each |
| 67 | * end is just waiting for the other to acknowledge termination. |
| 68 | */ |
| 69 | if (dccp_sk(sk)->dccps_role != DCCP_ROLE_CLIENT) |
| 70 | break; |
| 71 | /* fall through */ |
| 72 | case DCCP_REQUESTING: |
| 73 | case DCCP_ACTIVE_CLOSEREQ: |
| 74 | dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED); |
| 75 | dccp_done(sk); |
| 76 | break; |
| 77 | case DCCP_OPEN: |
| 78 | case DCCP_PARTOPEN: |
| 79 | /* Give waiting application a chance to read pending data */ |
| 80 | queued = 1; |
| 81 | dccp_fin(sk, skb); |
| 82 | dccp_set_state(sk, DCCP_PASSIVE_CLOSE); |
| 83 | /* fall through */ |
| 84 | case DCCP_PASSIVE_CLOSE: |
| 85 | /* |
| 86 | * Retransmitted Close: we have already enqueued the first one. |
| 87 | */ |
| 88 | sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_HUP); |
| 89 | } |
| 90 | return queued; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 91 | } |
| 92 | |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 93 | static int dccp_rcv_closereq(struct sock *sk, struct sk_buff *skb) |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 94 | { |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 95 | int queued = 0; |
| 96 | |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 97 | /* |
| 98 | * Step 7: Check for unexpected packet types |
| 99 | * If (S.is_server and P.type == CloseReq) |
| 100 | * Send Sync packet acknowledging P.seqno |
| 101 | * Drop packet and return |
| 102 | */ |
| 103 | if (dccp_sk(sk)->dccps_role != DCCP_ROLE_CLIENT) { |
Arnaldo Carvalho de Melo | e92ae93 | 2005-08-17 03:10:59 -0300 | [diff] [blame] | 104 | dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq, DCCP_PKT_SYNC); |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 105 | return queued; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 106 | } |
| 107 | |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 108 | /* Step 13: process relevant Client states < CLOSEREQ */ |
| 109 | switch (sk->sk_state) { |
| 110 | case DCCP_REQUESTING: |
| 111 | dccp_send_close(sk, 0); |
Arnaldo Carvalho de Melo | 811265b | 2005-09-13 19:03:15 -0300 | [diff] [blame] | 112 | dccp_set_state(sk, DCCP_CLOSING); |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 113 | break; |
| 114 | case DCCP_OPEN: |
| 115 | case DCCP_PARTOPEN: |
| 116 | /* Give waiting application a chance to read pending data */ |
| 117 | queued = 1; |
| 118 | dccp_fin(sk, skb); |
| 119 | dccp_set_state(sk, DCCP_PASSIVE_CLOSEREQ); |
| 120 | /* fall through */ |
| 121 | case DCCP_PASSIVE_CLOSEREQ: |
| 122 | sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_HUP); |
| 123 | } |
| 124 | return queued; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 125 | } |
| 126 | |
Yoichi Yuasa | d9b52dc | 2010-05-24 18:37:02 -0700 | [diff] [blame] | 127 | static u16 dccp_reset_code_convert(const u8 code) |
Gerrit Renker | d8ef2c2 | 2007-10-24 10:27:48 -0200 | [diff] [blame] | 128 | { |
Yoichi Yuasa | d9b52dc | 2010-05-24 18:37:02 -0700 | [diff] [blame] | 129 | const u16 error_code[] = { |
Gerrit Renker | d8ef2c2 | 2007-10-24 10:27:48 -0200 | [diff] [blame] | 130 | [DCCP_RESET_CODE_CLOSED] = 0, /* normal termination */ |
| 131 | [DCCP_RESET_CODE_UNSPECIFIED] = 0, /* nothing known */ |
| 132 | [DCCP_RESET_CODE_ABORTED] = ECONNRESET, |
| 133 | |
| 134 | [DCCP_RESET_CODE_NO_CONNECTION] = ECONNREFUSED, |
| 135 | [DCCP_RESET_CODE_CONNECTION_REFUSED] = ECONNREFUSED, |
| 136 | [DCCP_RESET_CODE_TOO_BUSY] = EUSERS, |
| 137 | [DCCP_RESET_CODE_AGGRESSION_PENALTY] = EDQUOT, |
| 138 | |
| 139 | [DCCP_RESET_CODE_PACKET_ERROR] = ENOMSG, |
| 140 | [DCCP_RESET_CODE_BAD_INIT_COOKIE] = EBADR, |
| 141 | [DCCP_RESET_CODE_BAD_SERVICE_CODE] = EBADRQC, |
| 142 | [DCCP_RESET_CODE_OPTION_ERROR] = EILSEQ, |
| 143 | [DCCP_RESET_CODE_MANDATORY_ERROR] = EOPNOTSUPP, |
| 144 | }; |
| 145 | |
| 146 | return code >= DCCP_MAX_RESET_CODES ? 0 : error_code[code]; |
| 147 | } |
| 148 | |
| 149 | static void dccp_rcv_reset(struct sock *sk, struct sk_buff *skb) |
| 150 | { |
Yoichi Yuasa | d9b52dc | 2010-05-24 18:37:02 -0700 | [diff] [blame] | 151 | u16 err = dccp_reset_code_convert(dccp_hdr_reset(skb)->dccph_reset_code); |
Gerrit Renker | d8ef2c2 | 2007-10-24 10:27:48 -0200 | [diff] [blame] | 152 | |
| 153 | sk->sk_err = err; |
| 154 | |
| 155 | /* Queue the equivalent of TCP fin so that dccp_recvmsg exits the loop */ |
| 156 | dccp_fin(sk, skb); |
| 157 | |
| 158 | if (err && !sock_flag(sk, SOCK_DEAD)) |
Pavel Emelyanov | 8d8ad9d | 2007-11-26 20:10:50 +0800 | [diff] [blame] | 159 | sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR); |
Gerrit Renker | d8ef2c2 | 2007-10-24 10:27:48 -0200 | [diff] [blame] | 160 | dccp_time_wait(sk, DCCP_TIME_WAIT, 0); |
| 161 | } |
| 162 | |
Gerrit Renker | 1821946 | 2010-11-14 17:25:36 +0100 | [diff] [blame] | 163 | static void dccp_handle_ackvec_processing(struct sock *sk, struct sk_buff *skb) |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 164 | { |
Gerrit Renker | 1821946 | 2010-11-14 17:25:36 +0100 | [diff] [blame] | 165 | struct dccp_ackvec *av = dccp_sk(sk)->dccps_hc_rx_ackvec; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 166 | |
Gerrit Renker | 1821946 | 2010-11-14 17:25:36 +0100 | [diff] [blame] | 167 | if (av == NULL) |
| 168 | return; |
| 169 | if (DCCP_SKB_CB(skb)->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ) |
| 170 | dccp_ackvec_clear_state(av, DCCP_SKB_CB(skb)->dccpd_ack_seq); |
| 171 | dccp_ackvec_input(av, skb); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 172 | } |
| 173 | |
Gerrit Renker | 8e8c71f | 2007-11-21 09:56:48 -0200 | [diff] [blame] | 174 | static void dccp_deliver_input_to_ccids(struct sock *sk, struct sk_buff *skb) |
| 175 | { |
| 176 | const struct dccp_sock *dp = dccp_sk(sk); |
| 177 | |
| 178 | /* Don't deliver to RX CCID when node has shut down read end. */ |
| 179 | if (!(sk->sk_shutdown & RCV_SHUTDOWN)) |
| 180 | ccid_hc_rx_packet_recv(dp->dccps_hc_rx_ccid, sk, skb); |
| 181 | /* |
| 182 | * Until the TX queue has been drained, we can not honour SHUT_WR, since |
| 183 | * we need received feedback as input to adjust congestion control. |
| 184 | */ |
| 185 | if (sk->sk_write_queue.qlen > 0 || !(sk->sk_shutdown & SEND_SHUTDOWN)) |
| 186 | ccid_hc_tx_packet_recv(dp->dccps_hc_tx_ccid, sk, skb); |
| 187 | } |
| 188 | |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 189 | static int dccp_check_seqno(struct sock *sk, struct sk_buff *skb) |
| 190 | { |
| 191 | const struct dccp_hdr *dh = dccp_hdr(skb); |
| 192 | struct dccp_sock *dp = dccp_sk(sk); |
Gerrit Renker | cbe1f5f | 2007-09-25 22:41:19 -0700 | [diff] [blame] | 193 | u64 lswl, lawl, seqno = DCCP_SKB_CB(skb)->dccpd_seq, |
| 194 | ackno = DCCP_SKB_CB(skb)->dccpd_ack_seq; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 195 | |
| 196 | /* |
| 197 | * Step 5: Prepare sequence numbers for Sync |
| 198 | * If P.type == Sync or P.type == SyncAck, |
| 199 | * If S.AWL <= P.ackno <= S.AWH and P.seqno >= S.SWL, |
| 200 | * / * P is valid, so update sequence number variables |
| 201 | * accordingly. After this update, P will pass the tests |
| 202 | * in Step 6. A SyncAck is generated if necessary in |
| 203 | * Step 15 * / |
| 204 | * Update S.GSR, S.SWL, S.SWH |
| 205 | * Otherwise, |
| 206 | * Drop packet and return |
| 207 | */ |
Arnaldo Carvalho de Melo | 8109b02 | 2006-12-10 16:01:18 -0200 | [diff] [blame] | 208 | if (dh->dccph_type == DCCP_PKT_SYNC || |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 209 | dh->dccph_type == DCCP_PKT_SYNCACK) { |
Gerrit Renker | cbe1f5f | 2007-09-25 22:41:19 -0700 | [diff] [blame] | 210 | if (between48(ackno, dp->dccps_awl, dp->dccps_awh) && |
| 211 | dccp_delta_seqno(dp->dccps_swl, seqno) >= 0) |
| 212 | dccp_update_gsr(sk, seqno); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 213 | else |
| 214 | return -1; |
Arnaldo Carvalho de Melo | e92ae93 | 2005-08-17 03:10:59 -0300 | [diff] [blame] | 215 | } |
YOSHIFUJI Hideaki | c9eaf17 | 2007-02-09 23:24:38 +0900 | [diff] [blame] | 216 | |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 217 | /* |
| 218 | * Step 6: Check sequence numbers |
| 219 | * Let LSWL = S.SWL and LAWL = S.AWL |
| 220 | * If P.type == CloseReq or P.type == Close or P.type == Reset, |
| 221 | * LSWL := S.GSR + 1, LAWL := S.GAR |
| 222 | * If LSWL <= P.seqno <= S.SWH |
| 223 | * and (P.ackno does not exist or LAWL <= P.ackno <= S.AWH), |
| 224 | * Update S.GSR, S.SWL, S.SWH |
| 225 | * If P.type != Sync, |
| 226 | * Update S.GAR |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 227 | */ |
Arnaldo Carvalho de Melo | e92ae93 | 2005-08-17 03:10:59 -0300 | [diff] [blame] | 228 | lswl = dp->dccps_swl; |
| 229 | lawl = dp->dccps_awl; |
| 230 | |
| 231 | if (dh->dccph_type == DCCP_PKT_CLOSEREQ || |
Arnaldo Carvalho de Melo | c59eab4 | 2005-08-18 21:12:02 -0300 | [diff] [blame] | 232 | dh->dccph_type == DCCP_PKT_CLOSE || |
| 233 | dh->dccph_type == DCCP_PKT_RESET) { |
Gerrit Renker | cbe1f5f | 2007-09-25 22:41:19 -0700 | [diff] [blame] | 234 | lswl = ADD48(dp->dccps_gsr, 1); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 235 | lawl = dp->dccps_gar; |
| 236 | } |
| 237 | |
Gerrit Renker | cbe1f5f | 2007-09-25 22:41:19 -0700 | [diff] [blame] | 238 | if (between48(seqno, lswl, dp->dccps_swh) && |
| 239 | (ackno == DCCP_PKT_WITHOUT_ACK_SEQ || |
| 240 | between48(ackno, lawl, dp->dccps_awh))) { |
| 241 | dccp_update_gsr(sk, seqno); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 242 | |
| 243 | if (dh->dccph_type != DCCP_PKT_SYNC && |
Gerrit Renker | 0ac7887 | 2010-11-23 02:36:56 +0000 | [diff] [blame] | 244 | ackno != DCCP_PKT_WITHOUT_ACK_SEQ && |
| 245 | after48(ackno, dp->dccps_gar)) |
Gerrit Renker | cbe1f5f | 2007-09-25 22:41:19 -0700 | [diff] [blame] | 246 | dp->dccps_gar = ackno; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 247 | } else { |
Gerrit Renker | a94f0f9 | 2007-09-26 11:31:49 -0300 | [diff] [blame] | 248 | unsigned long now = jiffies; |
| 249 | /* |
| 250 | * Step 6: Check sequence numbers |
| 251 | * Otherwise, |
| 252 | * If P.type == Reset, |
| 253 | * Send Sync packet acknowledging S.GSR |
| 254 | * Otherwise, |
| 255 | * Send Sync packet acknowledging P.seqno |
| 256 | * Drop packet and return |
| 257 | * |
| 258 | * These Syncs are rate-limited as per RFC 4340, 7.5.4: |
| 259 | * at most 1 / (dccp_sync_rate_limit * HZ) Syncs per second. |
| 260 | */ |
| 261 | if (time_before(now, (dp->dccps_rate_last + |
| 262 | sysctl_dccp_sync_ratelimit))) |
Samuel Jero | 2cf5be9 | 2010-12-30 12:15:16 +0100 | [diff] [blame] | 263 | return -1; |
Gerrit Renker | a94f0f9 | 2007-09-26 11:31:49 -0300 | [diff] [blame] | 264 | |
Gerrit Renker | 2f34b32 | 2010-10-11 20:44:42 +0200 | [diff] [blame] | 265 | DCCP_WARN("Step 6 failed for %s packet, " |
Gerrit Renker | 59348b1 | 2006-11-20 18:39:23 -0200 | [diff] [blame] | 266 | "(LSWL(%llu) <= P.seqno(%llu) <= S.SWH(%llu)) and " |
| 267 | "(P.ackno %s or LAWL(%llu) <= P.ackno(%llu) <= S.AWH(%llu), " |
| 268 | "sending SYNC...\n", dccp_packet_name(dh->dccph_type), |
Gerrit Renker | cbe1f5f | 2007-09-25 22:41:19 -0700 | [diff] [blame] | 269 | (unsigned long long) lswl, (unsigned long long) seqno, |
Gerrit Renker | 59348b1 | 2006-11-20 18:39:23 -0200 | [diff] [blame] | 270 | (unsigned long long) dp->dccps_swh, |
Gerrit Renker | cbe1f5f | 2007-09-25 22:41:19 -0700 | [diff] [blame] | 271 | (ackno == DCCP_PKT_WITHOUT_ACK_SEQ) ? "doesn't exist" |
| 272 | : "exists", |
| 273 | (unsigned long long) lawl, (unsigned long long) ackno, |
Gerrit Renker | 59348b1 | 2006-11-20 18:39:23 -0200 | [diff] [blame] | 274 | (unsigned long long) dp->dccps_awh); |
Gerrit Renker | a94f0f9 | 2007-09-26 11:31:49 -0300 | [diff] [blame] | 275 | |
| 276 | dp->dccps_rate_last = now; |
| 277 | |
Gerrit Renker | e155d76 | 2007-09-25 22:41:56 -0700 | [diff] [blame] | 278 | if (dh->dccph_type == DCCP_PKT_RESET) |
| 279 | seqno = dp->dccps_gsr; |
Gerrit Renker | cbe1f5f | 2007-09-25 22:41:19 -0700 | [diff] [blame] | 280 | dccp_send_sync(sk, seqno, DCCP_PKT_SYNC); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 281 | return -1; |
| 282 | } |
| 283 | |
| 284 | return 0; |
| 285 | } |
| 286 | |
Arnaldo Carvalho de Melo | c25a18b | 2006-03-20 21:58:56 -0800 | [diff] [blame] | 287 | static int __dccp_rcv_established(struct sock *sk, struct sk_buff *skb, |
Eric Dumazet | 95c9617 | 2012-04-15 05:58:06 +0000 | [diff] [blame] | 288 | const struct dccp_hdr *dh, const unsigned int len) |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 289 | { |
| 290 | struct dccp_sock *dp = dccp_sk(sk); |
| 291 | |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 292 | switch (dccp_hdr(skb)->dccph_type) { |
| 293 | case DCCP_PKT_DATAACK: |
| 294 | case DCCP_PKT_DATA: |
| 295 | /* |
Gerrit Renker | 8e8c71f | 2007-11-21 09:56:48 -0200 | [diff] [blame] | 296 | * FIXME: schedule DATA_DROPPED (RFC 4340, 11.7.2) if and when |
| 297 | * - sk_shutdown == RCV_SHUTDOWN, use Code 1, "Not Listening" |
| 298 | * - sk_receive_queue is full, use Code 2, "Receive Buffer" |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 299 | */ |
Gerrit Renker | 69567d0 | 2007-12-13 11:28:43 -0200 | [diff] [blame] | 300 | dccp_enqueue_skb(sk, skb); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 301 | return 0; |
| 302 | case DCCP_PKT_ACK: |
| 303 | goto discard; |
| 304 | case DCCP_PKT_RESET: |
| 305 | /* |
| 306 | * Step 9: Process Reset |
| 307 | * If P.type == Reset, |
| 308 | * Tear down connection |
| 309 | * S.state := TIMEWAIT |
| 310 | * Set TIMEWAIT timer |
| 311 | * Drop packet and return |
Gerrit Renker | d8ef2c2 | 2007-10-24 10:27:48 -0200 | [diff] [blame] | 312 | */ |
| 313 | dccp_rcv_reset(sk, skb); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 314 | return 0; |
| 315 | case DCCP_PKT_CLOSEREQ: |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 316 | if (dccp_rcv_closereq(sk, skb)) |
| 317 | return 0; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 318 | goto discard; |
| 319 | case DCCP_PKT_CLOSE: |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 320 | if (dccp_rcv_close(sk, skb)) |
| 321 | return 0; |
| 322 | goto discard; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 323 | case DCCP_PKT_REQUEST: |
Arnaldo Carvalho de Melo | 8109b02 | 2006-12-10 16:01:18 -0200 | [diff] [blame] | 324 | /* Step 7 |
| 325 | * or (S.is_server and P.type == Response) |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 326 | * or (S.is_client and P.type == Request) |
| 327 | * or (S.state >= OPEN and P.type == Request |
| 328 | * and P.seqno >= S.OSR) |
| 329 | * or (S.state >= OPEN and P.type == Response |
| 330 | * and P.seqno >= S.OSR) |
| 331 | * or (S.state == RESPOND and P.type == Data), |
| 332 | * Send Sync packet acknowledging P.seqno |
| 333 | * Drop packet and return |
| 334 | */ |
| 335 | if (dp->dccps_role != DCCP_ROLE_LISTEN) |
| 336 | goto send_sync; |
| 337 | goto check_seq; |
| 338 | case DCCP_PKT_RESPONSE: |
| 339 | if (dp->dccps_role != DCCP_ROLE_CLIENT) |
| 340 | goto send_sync; |
| 341 | check_seq: |
Gerrit Renker | 8d13bf9 | 2007-03-20 13:08:19 -0300 | [diff] [blame] | 342 | if (dccp_delta_seqno(dp->dccps_osr, |
| 343 | DCCP_SKB_CB(skb)->dccpd_seq) >= 0) { |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 344 | send_sync: |
Arnaldo Carvalho de Melo | e92ae93 | 2005-08-17 03:10:59 -0300 | [diff] [blame] | 345 | dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq, |
| 346 | DCCP_PKT_SYNC); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 347 | } |
| 348 | break; |
Arnaldo Carvalho de Melo | e92ae93 | 2005-08-17 03:10:59 -0300 | [diff] [blame] | 349 | case DCCP_PKT_SYNC: |
| 350 | dccp_send_sync(sk, DCCP_SKB_CB(skb)->dccpd_seq, |
| 351 | DCCP_PKT_SYNCACK); |
| 352 | /* |
Gerrit Renker | 0e64e94 | 2006-10-24 16:17:51 -0700 | [diff] [blame] | 353 | * From RFC 4340, sec. 5.7 |
Arnaldo Carvalho de Melo | e92ae93 | 2005-08-17 03:10:59 -0300 | [diff] [blame] | 354 | * |
| 355 | * As with DCCP-Ack packets, DCCP-Sync and DCCP-SyncAck packets |
| 356 | * MAY have non-zero-length application data areas, whose |
Gerrit Renker | 0e64e94 | 2006-10-24 16:17:51 -0700 | [diff] [blame] | 357 | * contents receivers MUST ignore. |
Arnaldo Carvalho de Melo | e92ae93 | 2005-08-17 03:10:59 -0300 | [diff] [blame] | 358 | */ |
| 359 | goto discard; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 360 | } |
| 361 | |
Eric Dumazet | 7309f88 | 2016-04-29 14:16:49 -0700 | [diff] [blame] | 362 | DCCP_INC_STATS(DCCP_MIB_INERRS); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 363 | discard: |
| 364 | __kfree_skb(skb); |
| 365 | return 0; |
| 366 | } |
| 367 | |
Andrea Bittau | 709dd3a | 2006-01-03 14:25:17 -0800 | [diff] [blame] | 368 | int dccp_rcv_established(struct sock *sk, struct sk_buff *skb, |
Eric Dumazet | 95c9617 | 2012-04-15 05:58:06 +0000 | [diff] [blame] | 369 | const struct dccp_hdr *dh, const unsigned int len) |
Andrea Bittau | 709dd3a | 2006-01-03 14:25:17 -0800 | [diff] [blame] | 370 | { |
Andrea Bittau | 709dd3a | 2006-01-03 14:25:17 -0800 | [diff] [blame] | 371 | if (dccp_check_seqno(sk, skb)) |
| 372 | goto discard; |
| 373 | |
Gerrit Renker | 8b81941 | 2007-12-13 12:29:24 -0200 | [diff] [blame] | 374 | if (dccp_parse_options(sk, NULL, skb)) |
Wei Yongjun | ba1a6c7 | 2008-08-23 13:28:27 +0200 | [diff] [blame] | 375 | return 1; |
Andrea Bittau | 709dd3a | 2006-01-03 14:25:17 -0800 | [diff] [blame] | 376 | |
Gerrit Renker | 1821946 | 2010-11-14 17:25:36 +0100 | [diff] [blame] | 377 | dccp_handle_ackvec_processing(sk, skb); |
Gerrit Renker | 8e8c71f | 2007-11-21 09:56:48 -0200 | [diff] [blame] | 378 | dccp_deliver_input_to_ccids(sk, skb); |
Andrea Bittau | 709dd3a | 2006-01-03 14:25:17 -0800 | [diff] [blame] | 379 | |
| 380 | return __dccp_rcv_established(sk, skb, dh, len); |
| 381 | discard: |
| 382 | __kfree_skb(skb); |
| 383 | return 0; |
| 384 | } |
| 385 | |
Arnaldo Carvalho de Melo | f21e68c | 2005-12-13 23:24:16 -0800 | [diff] [blame] | 386 | EXPORT_SYMBOL_GPL(dccp_rcv_established); |
| 387 | |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 388 | static int dccp_rcv_request_sent_state_process(struct sock *sk, |
| 389 | struct sk_buff *skb, |
| 390 | const struct dccp_hdr *dh, |
Eric Dumazet | 95c9617 | 2012-04-15 05:58:06 +0000 | [diff] [blame] | 391 | const unsigned int len) |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 392 | { |
Arnaldo Carvalho de Melo | 8109b02 | 2006-12-10 16:01:18 -0200 | [diff] [blame] | 393 | /* |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 394 | * Step 4: Prepare sequence numbers in REQUEST |
| 395 | * If S.state == REQUEST, |
| 396 | * If (P.type == Response or P.type == Reset) |
| 397 | * and S.AWL <= P.ackno <= S.AWH, |
| 398 | * / * Set sequence number variables corresponding to the |
| 399 | * other endpoint, so P will pass the tests in Step 6 * / |
| 400 | * Set S.GSR, S.ISR, S.SWL, S.SWH |
| 401 | * / * Response processing continues in Step 10; Reset |
| 402 | * processing continues in Step 9 * / |
| 403 | */ |
| 404 | if (dh->dccph_type == DCCP_PKT_RESPONSE) { |
| 405 | const struct inet_connection_sock *icsk = inet_csk(sk); |
| 406 | struct dccp_sock *dp = dccp_sk(sk); |
Gerrit Renker | 3393da8 | 2007-09-25 22:40:44 -0700 | [diff] [blame] | 407 | long tstamp = dccp_timestamp(); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 408 | |
Arnaldo Carvalho de Melo | 7690af3 | 2005-08-13 20:34:54 -0300 | [diff] [blame] | 409 | if (!between48(DCCP_SKB_CB(skb)->dccpd_ack_seq, |
| 410 | dp->dccps_awl, dp->dccps_awh)) { |
| 411 | dccp_pr_debug("invalid ackno: S.AWL=%llu, " |
Frans Pop | b138338 | 2010-03-24 07:57:28 +0000 | [diff] [blame] | 412 | "P.ackno=%llu, S.AWH=%llu\n", |
Arnaldo Carvalho de Melo | 7690af3 | 2005-08-13 20:34:54 -0300 | [diff] [blame] | 413 | (unsigned long long)dp->dccps_awl, |
| 414 | (unsigned long long)DCCP_SKB_CB(skb)->dccpd_ack_seq, |
| 415 | (unsigned long long)dp->dccps_awh); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 416 | goto out_invalid_packet; |
| 417 | } |
| 418 | |
Gerrit Renker | 991d927 | 2008-12-08 01:16:27 -0800 | [diff] [blame] | 419 | /* |
| 420 | * If option processing (Step 8) failed, return 1 here so that |
| 421 | * dccp_v4_do_rcv() sends a Reset. The Reset code depends on |
| 422 | * the option type and is set in dccp_parse_options(). |
| 423 | */ |
Gerrit Renker | 8b81941 | 2007-12-13 12:29:24 -0200 | [diff] [blame] | 424 | if (dccp_parse_options(sk, NULL, skb)) |
Gerrit Renker | 991d927 | 2008-12-08 01:16:27 -0800 | [diff] [blame] | 425 | return 1; |
Andrea Bittau | afe0025 | 2006-03-20 17:43:56 -0800 | [diff] [blame] | 426 | |
Gerrit Renker | 59b8080 | 2010-06-22 01:14:35 +0000 | [diff] [blame] | 427 | /* Obtain usec RTT sample from SYN exchange (used by TFRC). */ |
Gerrit Renker | 3393da8 | 2007-09-25 22:40:44 -0700 | [diff] [blame] | 428 | if (likely(dp->dccps_options_received.dccpor_timestamp_echo)) |
| 429 | dp->dccps_syn_rtt = dccp_sample_rtt(sk, 10 * (tstamp - |
| 430 | dp->dccps_options_received.dccpor_timestamp_echo)); |
Gerrit Renker | 89560b5 | 2007-03-20 15:27:17 -0300 | [diff] [blame] | 431 | |
Gerrit Renker | d28934a | 2008-08-18 21:14:20 -0700 | [diff] [blame] | 432 | /* Stop the REQUEST timer */ |
| 433 | inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS); |
| 434 | WARN_ON(sk->sk_send_head == NULL); |
| 435 | kfree_skb(sk->sk_send_head); |
| 436 | sk->sk_send_head = NULL; |
| 437 | |
Arnaldo Carvalho de Melo | 03ace39 | 2005-08-21 05:36:45 -0300 | [diff] [blame] | 438 | /* |
Gerrit Renker | 0b53d46 | 2010-10-11 20:35:40 +0200 | [diff] [blame] | 439 | * Set ISR, GSR from packet. ISS was set in dccp_v{4,6}_connect |
| 440 | * and GSS in dccp_transmit_skb(). Setting AWL/AWH and SWL/SWH |
| 441 | * is done as part of activating the feature values below, since |
| 442 | * these settings depend on the local/remote Sequence Window |
| 443 | * features, which were undefined or not confirmed until now. |
Arnaldo Carvalho de Melo | 03ace39 | 2005-08-21 05:36:45 -0300 | [diff] [blame] | 444 | */ |
Gerrit Renker | 0b53d46 | 2010-10-11 20:35:40 +0200 | [diff] [blame] | 445 | dp->dccps_gsr = dp->dccps_isr = DCCP_SKB_CB(skb)->dccpd_seq; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 446 | |
Arnaldo Carvalho de Melo | d83d846 | 2005-12-13 23:26:10 -0800 | [diff] [blame] | 447 | dccp_sync_mss(sk, icsk->icsk_pmtu_cookie); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 448 | |
| 449 | /* |
| 450 | * Step 10: Process REQUEST state (second part) |
| 451 | * If S.state == REQUEST, |
Arnaldo Carvalho de Melo | 7690af3 | 2005-08-13 20:34:54 -0300 | [diff] [blame] | 452 | * / * If we get here, P is a valid Response from the |
| 453 | * server (see Step 4), and we should move to |
| 454 | * PARTOPEN state. PARTOPEN means send an Ack, |
| 455 | * don't send Data packets, retransmit Acks |
| 456 | * periodically, and always include any Init Cookie |
| 457 | * from the Response * / |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 458 | * S.state := PARTOPEN |
| 459 | * Set PARTOPEN timer |
Arnaldo Carvalho de Melo | 8109b02 | 2006-12-10 16:01:18 -0200 | [diff] [blame] | 460 | * Continue with S.state == PARTOPEN |
Arnaldo Carvalho de Melo | 7690af3 | 2005-08-13 20:34:54 -0300 | [diff] [blame] | 461 | * / * Step 12 will send the Ack completing the |
| 462 | * three-way handshake * / |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 463 | */ |
| 464 | dccp_set_state(sk, DCCP_PARTOPEN); |
| 465 | |
Gerrit Renker | 991d927 | 2008-12-08 01:16:27 -0800 | [diff] [blame] | 466 | /* |
| 467 | * If feature negotiation was successful, activate features now; |
| 468 | * an activation failure means that this host could not activate |
| 469 | * one ore more features (e.g. insufficient memory), which would |
| 470 | * leave at least one feature in an undefined state. |
| 471 | */ |
| 472 | if (dccp_feat_activate_values(sk, &dp->dccps_featneg)) |
| 473 | goto unable_to_proceed; |
| 474 | |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 475 | /* Make sure socket is routed, for correct metrics. */ |
Arnaldo Carvalho de Melo | 57cca05 | 2005-12-13 23:16:16 -0800 | [diff] [blame] | 476 | icsk->icsk_af_ops->rebuild_header(sk); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 477 | |
| 478 | if (!sock_flag(sk, SOCK_DEAD)) { |
| 479 | sk->sk_state_change(sk); |
Pavel Emelyanov | 8d8ad9d | 2007-11-26 20:10:50 +0800 | [diff] [blame] | 480 | sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 481 | } |
| 482 | |
| 483 | if (sk->sk_write_pending || icsk->icsk_ack.pingpong || |
| 484 | icsk->icsk_accept_queue.rskq_defer_accept) { |
| 485 | /* Save one ACK. Data will be ready after |
| 486 | * several ticks, if write_pending is set. |
| 487 | * |
| 488 | * It may be deleted, but with this feature tcpdumps |
| 489 | * look so _wonderfully_ clever, that I was not able |
| 490 | * to stand against the temptation 8) --ANK |
| 491 | */ |
| 492 | /* |
| 493 | * OK, in DCCP we can as well do a similar trick, its |
| 494 | * even in the draft, but there is no need for us to |
| 495 | * schedule an ack here, as dccp_sendmsg does this for |
| 496 | * us, also stated in the draft. -acme |
| 497 | */ |
| 498 | __kfree_skb(skb); |
| 499 | return 0; |
Arnaldo Carvalho de Melo | 8109b02 | 2006-12-10 16:01:18 -0200 | [diff] [blame] | 500 | } |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 501 | dccp_send_ack(sk); |
| 502 | return -1; |
| 503 | } |
| 504 | |
| 505 | out_invalid_packet: |
Arnaldo Carvalho de Melo | 0c10c5d | 2005-09-16 16:58:33 -0700 | [diff] [blame] | 506 | /* dccp_v4_do_rcv will send a reset */ |
| 507 | DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_PACKET_ERROR; |
Arnaldo Carvalho de Melo | 8109b02 | 2006-12-10 16:01:18 -0200 | [diff] [blame] | 508 | return 1; |
Gerrit Renker | 991d927 | 2008-12-08 01:16:27 -0800 | [diff] [blame] | 509 | |
| 510 | unable_to_proceed: |
| 511 | DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_ABORTED; |
| 512 | /* |
| 513 | * We mark this socket as no longer usable, so that the loop in |
| 514 | * dccp_sendmsg() terminates and the application gets notified. |
| 515 | */ |
| 516 | dccp_set_state(sk, DCCP_CLOSED); |
| 517 | sk->sk_err = ECOMM; |
| 518 | return 1; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 519 | } |
| 520 | |
| 521 | static int dccp_rcv_respond_partopen_state_process(struct sock *sk, |
| 522 | struct sk_buff *skb, |
| 523 | const struct dccp_hdr *dh, |
Eric Dumazet | 95c9617 | 2012-04-15 05:58:06 +0000 | [diff] [blame] | 524 | const unsigned int len) |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 525 | { |
Gerrit Renker | 59b8080 | 2010-06-22 01:14:35 +0000 | [diff] [blame] | 526 | struct dccp_sock *dp = dccp_sk(sk); |
| 527 | u32 sample = dp->dccps_options_received.dccpor_timestamp_echo; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 528 | int queued = 0; |
| 529 | |
| 530 | switch (dh->dccph_type) { |
| 531 | case DCCP_PKT_RESET: |
| 532 | inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK); |
| 533 | break; |
Arnaldo Carvalho de Melo | 2a9bc9b | 2005-10-10 21:25:00 -0700 | [diff] [blame] | 534 | case DCCP_PKT_DATA: |
| 535 | if (sk->sk_state == DCCP_RESPOND) |
| 536 | break; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 537 | case DCCP_PKT_DATAACK: |
| 538 | case DCCP_PKT_ACK: |
| 539 | /* |
Fabian Frederick | a77b634 | 2014-11-17 22:00:22 +0100 | [diff] [blame] | 540 | * FIXME: we should be resetting the PARTOPEN (DELACK) timer |
Arnaldo Carvalho de Melo | 7690af3 | 2005-08-13 20:34:54 -0300 | [diff] [blame] | 541 | * here but only if we haven't used the DELACK timer for |
| 542 | * something else, like sending a delayed ack for a TIMESTAMP |
| 543 | * echo, etc, for now were not clearing it, sending an extra |
| 544 | * ACK when there is nothing else to do in DELACK is not a big |
| 545 | * deal after all. |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 546 | */ |
| 547 | |
| 548 | /* Stop the PARTOPEN timer */ |
| 549 | if (sk->sk_state == DCCP_PARTOPEN) |
| 550 | inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK); |
| 551 | |
Gerrit Renker | 59b8080 | 2010-06-22 01:14:35 +0000 | [diff] [blame] | 552 | /* Obtain usec RTT sample from SYN exchange (used by TFRC). */ |
| 553 | if (likely(sample)) { |
| 554 | long delta = dccp_timestamp() - sample; |
| 555 | |
| 556 | dp->dccps_syn_rtt = dccp_sample_rtt(sk, 10 * delta); |
| 557 | } |
| 558 | |
| 559 | dp->dccps_osr = DCCP_SKB_CB(skb)->dccpd_seq; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 560 | dccp_set_state(sk, DCCP_OPEN); |
| 561 | |
Arnaldo Carvalho de Melo | 2a9bc9b | 2005-10-10 21:25:00 -0700 | [diff] [blame] | 562 | if (dh->dccph_type == DCCP_PKT_DATAACK || |
| 563 | dh->dccph_type == DCCP_PKT_DATA) { |
Andrea Bittau | 709dd3a | 2006-01-03 14:25:17 -0800 | [diff] [blame] | 564 | __dccp_rcv_established(sk, skb, dh, len); |
Arnaldo Carvalho de Melo | 7690af3 | 2005-08-13 20:34:54 -0300 | [diff] [blame] | 565 | queued = 1; /* packet was queued |
Andrea Bittau | 709dd3a | 2006-01-03 14:25:17 -0800 | [diff] [blame] | 566 | (by __dccp_rcv_established) */ |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 567 | } |
| 568 | break; |
| 569 | } |
| 570 | |
| 571 | return queued; |
| 572 | } |
| 573 | |
| 574 | int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb, |
Eric Dumazet | 95c9617 | 2012-04-15 05:58:06 +0000 | [diff] [blame] | 575 | struct dccp_hdr *dh, unsigned int len) |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 576 | { |
| 577 | struct dccp_sock *dp = dccp_sk(sk); |
Arnaldo Carvalho de Melo | 0c10c5d | 2005-09-16 16:58:33 -0700 | [diff] [blame] | 578 | struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 579 | const int old_state = sk->sk_state; |
Eric Dumazet | 449809a | 2017-03-01 08:39:49 -0800 | [diff] [blame] | 580 | bool acceptable; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 581 | int queued = 0; |
| 582 | |
Arnaldo Carvalho de Melo | 8649b0d | 2005-08-13 20:36:01 -0300 | [diff] [blame] | 583 | /* |
| 584 | * Step 3: Process LISTEN state |
Arnaldo Carvalho de Melo | 8649b0d | 2005-08-13 20:36:01 -0300 | [diff] [blame] | 585 | * |
| 586 | * If S.state == LISTEN, |
Gerrit Renker | d83ca5a | 2006-11-10 16:29:14 -0200 | [diff] [blame] | 587 | * If P.type == Request or P contains a valid Init Cookie option, |
| 588 | * (* Must scan the packet's options to check for Init |
| 589 | * Cookies. Only Init Cookies are processed here, |
| 590 | * however; other options are processed in Step 8. This |
| 591 | * scan need only be performed if the endpoint uses Init |
| 592 | * Cookies *) |
| 593 | * (* Generate a new socket and switch to that socket *) |
| 594 | * Set S := new socket for this port pair |
| 595 | * S.state = RESPOND |
| 596 | * Choose S.ISS (initial seqno) or set from Init Cookies |
| 597 | * Initialize S.GAR := S.ISS |
| 598 | * Set S.ISR, S.GSR, S.SWL, S.SWH from packet or Init |
| 599 | * Cookies Continue with S.state == RESPOND |
| 600 | * (* A Response packet will be generated in Step 11 *) |
| 601 | * Otherwise, |
| 602 | * Generate Reset(No Connection) unless P.type == Reset |
| 603 | * Drop packet and return |
Arnaldo Carvalho de Melo | 8649b0d | 2005-08-13 20:36:01 -0300 | [diff] [blame] | 604 | */ |
| 605 | if (sk->sk_state == DCCP_LISTEN) { |
| 606 | if (dh->dccph_type == DCCP_PKT_REQUEST) { |
Eric Dumazet | 449809a | 2017-03-01 08:39:49 -0800 | [diff] [blame] | 607 | /* It is possible that we process SYN packets from backlog, |
| 608 | * so we need to make sure to disable BH right there. |
| 609 | */ |
| 610 | local_bh_disable(); |
| 611 | acceptable = inet_csk(sk)->icsk_af_ops->conn_request(sk, skb) >= 0; |
| 612 | local_bh_enable(); |
| 613 | if (!acceptable) |
Arnaldo Carvalho de Melo | 8649b0d | 2005-08-13 20:36:01 -0300 | [diff] [blame] | 614 | return 1; |
Andrey Konovalov | 5edabca | 2017-02-16 17:22:46 +0100 | [diff] [blame] | 615 | consume_skb(skb); |
| 616 | return 0; |
Arnaldo Carvalho de Melo | 8649b0d | 2005-08-13 20:36:01 -0300 | [diff] [blame] | 617 | } |
| 618 | if (dh->dccph_type == DCCP_PKT_RESET) |
| 619 | goto discard; |
| 620 | |
Arnaldo Carvalho de Melo | 0c10c5d | 2005-09-16 16:58:33 -0700 | [diff] [blame] | 621 | /* Caller (dccp_v4_do_rcv) will send Reset */ |
| 622 | dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION; |
Arnaldo Carvalho de Melo | 8649b0d | 2005-08-13 20:36:01 -0300 | [diff] [blame] | 623 | return 1; |
Gerrit Renker | 720dc34 | 2011-03-01 23:02:07 -0800 | [diff] [blame] | 624 | } else if (sk->sk_state == DCCP_CLOSED) { |
| 625 | dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION; |
| 626 | return 1; |
Arnaldo Carvalho de Melo | 8649b0d | 2005-08-13 20:36:01 -0300 | [diff] [blame] | 627 | } |
| 628 | |
Gerrit Renker | c0c2015 | 2011-07-03 09:49:16 -0600 | [diff] [blame] | 629 | /* Step 6: Check sequence numbers (omitted in LISTEN/REQUEST state) */ |
| 630 | if (sk->sk_state != DCCP_REQUESTING && dccp_check_seqno(sk, skb)) |
| 631 | goto discard; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 632 | |
Gerrit Renker | c0c2015 | 2011-07-03 09:49:16 -0600 | [diff] [blame] | 633 | /* |
| 634 | * Step 7: Check for unexpected packet types |
| 635 | * If (S.is_server and P.type == Response) |
| 636 | * or (S.is_client and P.type == Request) |
| 637 | * or (S.state == RESPOND and P.type == Data), |
| 638 | * Send Sync packet acknowledging P.seqno |
| 639 | * Drop packet and return |
| 640 | */ |
| 641 | if ((dp->dccps_role != DCCP_ROLE_CLIENT && |
| 642 | dh->dccph_type == DCCP_PKT_RESPONSE) || |
| 643 | (dp->dccps_role == DCCP_ROLE_CLIENT && |
| 644 | dh->dccph_type == DCCP_PKT_REQUEST) || |
| 645 | (sk->sk_state == DCCP_RESPOND && dh->dccph_type == DCCP_PKT_DATA)) { |
| 646 | dccp_send_sync(sk, dcb->dccpd_seq, DCCP_PKT_SYNC); |
| 647 | goto discard; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 648 | } |
| 649 | |
Gerrit Renker | c0c2015 | 2011-07-03 09:49:16 -0600 | [diff] [blame] | 650 | /* Step 8: Process options */ |
| 651 | if (dccp_parse_options(sk, NULL, skb)) |
| 652 | return 1; |
| 653 | |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 654 | /* |
| 655 | * Step 9: Process Reset |
| 656 | * If P.type == Reset, |
| 657 | * Tear down connection |
| 658 | * S.state := TIMEWAIT |
| 659 | * Set TIMEWAIT timer |
| 660 | * Drop packet and return |
Gerrit Renker | c0c2015 | 2011-07-03 09:49:16 -0600 | [diff] [blame] | 661 | */ |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 662 | if (dh->dccph_type == DCCP_PKT_RESET) { |
Gerrit Renker | d8ef2c2 | 2007-10-24 10:27:48 -0200 | [diff] [blame] | 663 | dccp_rcv_reset(sk, skb); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 664 | return 0; |
Gerrit Renker | c0c2015 | 2011-07-03 09:49:16 -0600 | [diff] [blame] | 665 | } else if (dh->dccph_type == DCCP_PKT_CLOSEREQ) { /* Step 13 */ |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 666 | if (dccp_rcv_closereq(sk, skb)) |
| 667 | return 0; |
Arnaldo Carvalho de Melo | 7ad07e7 | 2005-08-23 21:50:06 -0700 | [diff] [blame] | 668 | goto discard; |
Gerrit Renker | c0c2015 | 2011-07-03 09:49:16 -0600 | [diff] [blame] | 669 | } else if (dh->dccph_type == DCCP_PKT_CLOSE) { /* Step 14 */ |
Gerrit Renker | 0c86962 | 2007-11-28 11:59:48 -0200 | [diff] [blame] | 670 | if (dccp_rcv_close(sk, skb)) |
| 671 | return 0; |
| 672 | goto discard; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 673 | } |
| 674 | |
| 675 | switch (sk->sk_state) { |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 676 | case DCCP_REQUESTING: |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 677 | queued = dccp_rcv_request_sent_state_process(sk, skb, dh, len); |
| 678 | if (queued >= 0) |
| 679 | return queued; |
| 680 | |
| 681 | __kfree_skb(skb); |
| 682 | return 0; |
| 683 | |
Gerrit Renker | 410e27a | 2008-09-09 13:27:22 +0200 | [diff] [blame] | 684 | case DCCP_PARTOPEN: |
Gerrit Renker | c0c2015 | 2011-07-03 09:49:16 -0600 | [diff] [blame] | 685 | /* Step 8: if using Ack Vectors, mark packet acknowledgeable */ |
| 686 | dccp_handle_ackvec_processing(sk, skb); |
| 687 | dccp_deliver_input_to_ccids(sk, skb); |
| 688 | /* fall through */ |
| 689 | case DCCP_RESPOND: |
Arnaldo Carvalho de Melo | 7690af3 | 2005-08-13 20:34:54 -0300 | [diff] [blame] | 690 | queued = dccp_rcv_respond_partopen_state_process(sk, skb, |
| 691 | dh, len); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 692 | break; |
| 693 | } |
| 694 | |
Arnaldo Carvalho de Melo | 7690af3 | 2005-08-13 20:34:54 -0300 | [diff] [blame] | 695 | if (dh->dccph_type == DCCP_PKT_ACK || |
| 696 | dh->dccph_type == DCCP_PKT_DATAACK) { |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 697 | switch (old_state) { |
| 698 | case DCCP_PARTOPEN: |
| 699 | sk->sk_state_change(sk); |
Pavel Emelyanov | 8d8ad9d | 2007-11-26 20:10:50 +0800 | [diff] [blame] | 700 | sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT); |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 701 | break; |
| 702 | } |
Gerrit Renker | 0883170 | 2007-09-26 10:30:05 -0300 | [diff] [blame] | 703 | } else if (unlikely(dh->dccph_type == DCCP_PKT_SYNC)) { |
| 704 | dccp_send_sync(sk, dcb->dccpd_seq, DCCP_PKT_SYNCACK); |
| 705 | goto discard; |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 706 | } |
| 707 | |
Arnaldo Carvalho de Melo | 8109b02 | 2006-12-10 16:01:18 -0200 | [diff] [blame] | 708 | if (!queued) { |
Arnaldo Carvalho de Melo | 7c65787 | 2005-08-09 20:14:34 -0700 | [diff] [blame] | 709 | discard: |
| 710 | __kfree_skb(skb); |
| 711 | } |
| 712 | return 0; |
| 713 | } |
Arnaldo Carvalho de Melo | f21e68c | 2005-12-13 23:24:16 -0800 | [diff] [blame] | 714 | |
| 715 | EXPORT_SYMBOL_GPL(dccp_rcv_state_process); |
Gerrit Renker | 4712a79 | 2007-03-20 15:23:18 -0300 | [diff] [blame] | 716 | |
| 717 | /** |
Gerrit Renker | 3393da8 | 2007-09-25 22:40:44 -0700 | [diff] [blame] | 718 | * dccp_sample_rtt - Validate and finalise computation of RTT sample |
| 719 | * @delta: number of microseconds between packet and acknowledgment |
Ben Hutchings | 2c53040 | 2012-07-10 10:55:09 +0000 | [diff] [blame] | 720 | * |
Gerrit Renker | 3393da8 | 2007-09-25 22:40:44 -0700 | [diff] [blame] | 721 | * The routine is kept generic to work in different contexts. It should be |
| 722 | * called immediately when the ACK used for the RTT sample arrives. |
Gerrit Renker | 4712a79 | 2007-03-20 15:23:18 -0300 | [diff] [blame] | 723 | */ |
Gerrit Renker | 3393da8 | 2007-09-25 22:40:44 -0700 | [diff] [blame] | 724 | u32 dccp_sample_rtt(struct sock *sk, long delta) |
Gerrit Renker | 4712a79 | 2007-03-20 15:23:18 -0300 | [diff] [blame] | 725 | { |
Gerrit Renker | 3393da8 | 2007-09-25 22:40:44 -0700 | [diff] [blame] | 726 | /* dccpor_elapsed_time is either zeroed out or set and > 0 */ |
| 727 | delta -= dccp_sk(sk)->dccps_options_received.dccpor_elapsed_time * 10; |
Gerrit Renker | 4712a79 | 2007-03-20 15:23:18 -0300 | [diff] [blame] | 728 | |
Gerrit Renker | 410e27a | 2008-09-09 13:27:22 +0200 | [diff] [blame] | 729 | if (unlikely(delta <= 0)) { |
| 730 | DCCP_WARN("unusable RTT sample %ld, using min\n", delta); |
| 731 | return DCCP_SANE_RTT_MIN; |
| 732 | } |
| 733 | if (unlikely(delta > DCCP_SANE_RTT_MAX)) { |
| 734 | DCCP_WARN("RTT sample %ld too large, using max\n", delta); |
| 735 | return DCCP_SANE_RTT_MAX; |
| 736 | } |
| 737 | |
| 738 | return delta; |
Gerrit Renker | 4712a79 | 2007-03-20 15:23:18 -0300 | [diff] [blame] | 739 | } |