Commit | Line | Data |
---|---|---|
7c657876 ACM |
1 | /* |
2 | * net/dccp/options.c | |
3 | * | |
4 | * An implementation of the DCCP protocol | |
1bc09869 IM |
5 | * Copyright (c) 2005 Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org> |
6 | * Copyright (c) 2005 Arnaldo Carvalho de Melo <acme@ghostprotocols.net> | |
7 | * Copyright (c) 2005 Ian McDonald <iam4@cs.waikato.ac.nz> | |
7c657876 ACM |
8 | * |
9 | * This program is free software; you can redistribute it and/or | |
10 | * modify it under the terms of the GNU General Public License | |
11 | * as published by the Free Software Foundation; either version | |
12 | * 2 of the License, or (at your option) any later version. | |
13 | */ | |
14 | #include <linux/config.h> | |
15 | #include <linux/dccp.h> | |
16 | #include <linux/module.h> | |
17 | #include <linux/types.h> | |
18 | #include <linux/kernel.h> | |
19 | #include <linux/skbuff.h> | |
20 | ||
21 | #include "ccid.h" | |
22 | #include "dccp.h" | |
23 | ||
24 | static void dccp_ackpkts_check_rcv_ackvector(struct dccp_ackpkts *ap, | |
25 | struct sock *sk, | |
26 | const u64 ackno, | |
27 | const unsigned char len, | |
28 | const unsigned char *vector); | |
29 | ||
30 | /* stores the default values for new connection. may be changed with sysctl */ | |
31 | static const struct dccp_options dccpo_default_values = { | |
32 | .dccpo_sequence_window = DCCPF_INITIAL_SEQUENCE_WINDOW, | |
33 | .dccpo_ccid = DCCPF_INITIAL_CCID, | |
34 | .dccpo_send_ack_vector = DCCPF_INITIAL_SEND_ACK_VECTOR, | |
35 | .dccpo_send_ndp_count = DCCPF_INITIAL_SEND_NDP_COUNT, | |
36 | }; | |
37 | ||
38 | void dccp_options_init(struct dccp_options *dccpo) | |
39 | { | |
40 | memcpy(dccpo, &dccpo_default_values, sizeof(*dccpo)); | |
41 | } | |
42 | ||
43 | static u32 dccp_decode_value_var(const unsigned char *bf, const u8 len) | |
44 | { | |
45 | u32 value = 0; | |
46 | ||
47 | if (len > 3) | |
48 | value += *bf++ << 24; | |
49 | if (len > 2) | |
50 | value += *bf++ << 16; | |
51 | if (len > 1) | |
52 | value += *bf++ << 8; | |
53 | if (len > 0) | |
54 | value += *bf; | |
55 | ||
56 | return value; | |
57 | } | |
58 | ||
59 | int dccp_parse_options(struct sock *sk, struct sk_buff *skb) | |
60 | { | |
61 | struct dccp_sock *dp = dccp_sk(sk); | |
725ba8ee | 62 | #ifdef CONFIG_IP_DCCP_DEBUG |
7690af3f ACM |
63 | const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ? |
64 | "CLIENT rx opt: " : "server rx opt: "; | |
7c657876 ACM |
65 | #endif |
66 | const struct dccp_hdr *dh = dccp_hdr(skb); | |
67 | const u8 pkt_type = DCCP_SKB_CB(skb)->dccpd_type; | |
68 | unsigned char *options = (unsigned char *)dh + dccp_hdr_len(skb); | |
69 | unsigned char *opt_ptr = options; | |
7690af3f ACM |
70 | const unsigned char *opt_end = (unsigned char *)dh + |
71 | (dh->dccph_doff * 4); | |
7c657876 ACM |
72 | struct dccp_options_received *opt_recv = &dp->dccps_options_received; |
73 | unsigned char opt, len; | |
74 | unsigned char *value; | |
75 | ||
76 | memset(opt_recv, 0, sizeof(*opt_recv)); | |
77 | ||
78 | while (opt_ptr != opt_end) { | |
79 | opt = *opt_ptr++; | |
80 | len = 0; | |
81 | value = NULL; | |
82 | ||
83 | /* Check if this isn't a single byte option */ | |
84 | if (opt > DCCPO_MAX_RESERVED) { | |
85 | if (opt_ptr == opt_end) | |
86 | goto out_invalid_option; | |
87 | ||
88 | len = *opt_ptr++; | |
89 | if (len < 3) | |
90 | goto out_invalid_option; | |
91 | /* | |
92 | * Remove the type and len fields, leaving | |
93 | * just the value size | |
94 | */ | |
95 | len -= 2; | |
96 | value = opt_ptr; | |
97 | opt_ptr += len; | |
98 | ||
99 | if (opt_ptr > opt_end) | |
100 | goto out_invalid_option; | |
101 | } | |
102 | ||
103 | switch (opt) { | |
104 | case DCCPO_PADDING: | |
105 | break; | |
106 | case DCCPO_NDP_COUNT: | |
107 | if (len > 3) | |
108 | goto out_invalid_option; | |
109 | ||
110 | opt_recv->dccpor_ndp = dccp_decode_value_var(value, len); | |
7690af3f ACM |
111 | dccp_pr_debug("%sNDP count=%d\n", debug_prefix, |
112 | opt_recv->dccpor_ndp); | |
7c657876 ACM |
113 | break; |
114 | case DCCPO_ACK_VECTOR_0: | |
115 | if (len > DCCP_MAX_ACK_VECTOR_LEN) | |
116 | goto out_invalid_option; | |
117 | ||
118 | if (pkt_type == DCCP_PKT_DATA) | |
119 | continue; | |
120 | ||
121 | opt_recv->dccpor_ack_vector_len = len; | |
122 | opt_recv->dccpor_ack_vector_idx = value - options; | |
123 | ||
124 | dccp_pr_debug("%sACK vector 0, len=%d, ack_ackno=%llu\n", | |
f6ccf554 DM |
125 | debug_prefix, len, |
126 | (unsigned long long) | |
127 | DCCP_SKB_CB(skb)->dccpd_ack_seq); | |
7c657876 ACM |
128 | dccp_ackvector_print(DCCP_SKB_CB(skb)->dccpd_ack_seq, |
129 | value, len); | |
7690af3f ACM |
130 | dccp_ackpkts_check_rcv_ackvector(dp->dccps_hc_rx_ackpkts, |
131 | sk, | |
132 | DCCP_SKB_CB(skb)->dccpd_ack_seq, | |
7c657876 ACM |
133 | len, value); |
134 | break; | |
135 | case DCCPO_TIMESTAMP: | |
136 | if (len != 4) | |
137 | goto out_invalid_option; | |
138 | ||
139 | opt_recv->dccpor_timestamp = ntohl(*(u32 *)value); | |
140 | ||
141 | dp->dccps_timestamp_echo = opt_recv->dccpor_timestamp; | |
1bc09869 | 142 | do_gettimeofday(&dp->dccps_timestamp_time); |
7c657876 ACM |
143 | |
144 | dccp_pr_debug("%sTIMESTAMP=%u, ackno=%llu\n", | |
145 | debug_prefix, opt_recv->dccpor_timestamp, | |
f6ccf554 | 146 | (unsigned long long) |
7c657876 ACM |
147 | DCCP_SKB_CB(skb)->dccpd_ack_seq); |
148 | break; | |
149 | case DCCPO_TIMESTAMP_ECHO: | |
1bc09869 | 150 | if (len != 4 && len != 6 && len != 8) |
7c657876 ACM |
151 | goto out_invalid_option; |
152 | ||
153 | opt_recv->dccpor_timestamp_echo = ntohl(*(u32 *)value); | |
154 | ||
1bc09869 | 155 | dccp_pr_debug("%sTIMESTAMP_ECHO=%u, len=%d, ackno=%llu, ", |
7690af3f ACM |
156 | debug_prefix, |
157 | opt_recv->dccpor_timestamp_echo, | |
f6ccf554 DM |
158 | len + 2, |
159 | (unsigned long long) | |
1bc09869 IM |
160 | DCCP_SKB_CB(skb)->dccpd_ack_seq); |
161 | ||
162 | if (len > 4) { | |
163 | if (len == 6) | |
164 | opt_recv->dccpor_elapsed_time = | |
165 | ntohs(*(u16 *)(value + 4)); | |
166 | else | |
167 | opt_recv->dccpor_elapsed_time = | |
168 | ntohl(*(u32 *)(value + 4)); | |
169 | ||
170 | dccp_pr_debug("%sTIMESTAMP_ECHO ELAPSED_TIME=%d\n", | |
7690af3f | 171 | debug_prefix, |
7c657876 | 172 | opt_recv->dccpor_elapsed_time); |
1bc09869 | 173 | } |
7c657876 ACM |
174 | break; |
175 | case DCCPO_ELAPSED_TIME: | |
1bc09869 | 176 | if (len != 2 && len != 4) |
7c657876 ACM |
177 | goto out_invalid_option; |
178 | ||
179 | if (pkt_type == DCCP_PKT_DATA) | |
180 | continue; | |
1bc09869 IM |
181 | |
182 | if (len == 2) | |
183 | opt_recv->dccpor_elapsed_time = | |
184 | ntohs(*(u16 *)value); | |
185 | else | |
186 | opt_recv->dccpor_elapsed_time = | |
187 | ntohl(*(u32 *)value); | |
188 | ||
7c657876 ACM |
189 | dccp_pr_debug("%sELAPSED_TIME=%d\n", debug_prefix, |
190 | opt_recv->dccpor_elapsed_time); | |
191 | break; | |
192 | /* | |
193 | * From draft-ietf-dccp-spec-11.txt: | |
194 | * | |
7690af3f ACM |
195 | * Option numbers 128 through 191 are for |
196 | * options sent from the HC-Sender to the | |
197 | * HC-Receiver; option numbers 192 through 255 | |
198 | * are for options sent from the HC-Receiver to | |
199 | * the HC-Sender. | |
7c657876 ACM |
200 | */ |
201 | case 128 ... 191: { | |
202 | const u16 idx = value - options; | |
203 | ||
7690af3f ACM |
204 | if (ccid_hc_rx_parse_options(dp->dccps_hc_rx_ccid, sk, |
205 | opt, len, idx, | |
206 | value) != 0) | |
7c657876 ACM |
207 | goto out_invalid_option; |
208 | } | |
209 | break; | |
210 | case 192 ... 255: { | |
211 | const u16 idx = value - options; | |
212 | ||
7690af3f ACM |
213 | if (ccid_hc_tx_parse_options(dp->dccps_hc_tx_ccid, sk, |
214 | opt, len, idx, | |
215 | value) != 0) | |
7c657876 ACM |
216 | goto out_invalid_option; |
217 | } | |
218 | break; | |
219 | default: | |
7690af3f ACM |
220 | pr_info("DCCP(%p): option %d(len=%d) not " |
221 | "implemented, ignoring\n", | |
7c657876 ACM |
222 | sk, opt, len); |
223 | break; | |
224 | } | |
225 | } | |
226 | ||
227 | return 0; | |
228 | ||
229 | out_invalid_option: | |
230 | DCCP_INC_STATS_BH(DCCP_MIB_INVALIDOPT); | |
231 | DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_OPTION_ERROR; | |
232 | pr_info("DCCP(%p): invalid option %d, len=%d\n", sk, opt, len); | |
233 | return -1; | |
234 | } | |
235 | ||
236 | static void dccp_encode_value_var(const u32 value, unsigned char *to, | |
237 | const unsigned int len) | |
238 | { | |
239 | if (len > 3) | |
240 | *to++ = (value & 0xFF000000) >> 24; | |
241 | if (len > 2) | |
242 | *to++ = (value & 0xFF0000) >> 16; | |
243 | if (len > 1) | |
244 | *to++ = (value & 0xFF00) >> 8; | |
245 | if (len > 0) | |
246 | *to++ = (value & 0xFF); | |
247 | } | |
248 | ||
249 | static inline int dccp_ndp_len(const int ndp) | |
250 | { | |
251 | return likely(ndp <= 0xFF) ? 1 : ndp <= 0xFFFF ? 2 : 3; | |
252 | } | |
253 | ||
254 | void dccp_insert_option(struct sock *sk, struct sk_buff *skb, | |
255 | const unsigned char option, | |
256 | const void *value, const unsigned char len) | |
257 | { | |
258 | unsigned char *to; | |
259 | ||
260 | if (DCCP_SKB_CB(skb)->dccpd_opt_len + len + 2 > DCCP_MAX_OPT_LEN) { | |
7690af3f ACM |
261 | LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to insert " |
262 | "%d option!\n", option); | |
7c657876 ACM |
263 | return; |
264 | } | |
265 | ||
266 | DCCP_SKB_CB(skb)->dccpd_opt_len += len + 2; | |
267 | ||
268 | to = skb_push(skb, len + 2); | |
269 | *to++ = option; | |
270 | *to++ = len + 2; | |
271 | ||
272 | memcpy(to, value, len); | |
273 | } | |
274 | ||
275 | EXPORT_SYMBOL_GPL(dccp_insert_option); | |
276 | ||
277 | static void dccp_insert_option_ndp(struct sock *sk, struct sk_buff *skb) | |
278 | { | |
279 | struct dccp_sock *dp = dccp_sk(sk); | |
280 | int ndp = dp->dccps_ndp_count; | |
281 | ||
282 | if (dccp_non_data_packet(skb)) | |
283 | ++dp->dccps_ndp_count; | |
284 | else | |
285 | dp->dccps_ndp_count = 0; | |
286 | ||
287 | if (ndp > 0) { | |
288 | unsigned char *ptr; | |
289 | const int ndp_len = dccp_ndp_len(ndp); | |
290 | const int len = ndp_len + 2; | |
291 | ||
292 | if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) | |
293 | return; | |
294 | ||
295 | DCCP_SKB_CB(skb)->dccpd_opt_len += len; | |
296 | ||
297 | ptr = skb_push(skb, len); | |
298 | *ptr++ = DCCPO_NDP_COUNT; | |
299 | *ptr++ = len; | |
300 | dccp_encode_value_var(ndp, ptr, ndp_len); | |
301 | } | |
302 | } | |
303 | ||
304 | static inline int dccp_elapsed_time_len(const u32 elapsed_time) | |
305 | { | |
b1c9fe7b | 306 | return elapsed_time == 0 ? 0 : elapsed_time <= 0xFFFF ? 2 : 4; |
7c657876 ACM |
307 | } |
308 | ||
309 | void dccp_insert_option_elapsed_time(struct sock *sk, | |
310 | struct sk_buff *skb, | |
311 | u32 elapsed_time) | |
312 | { | |
725ba8ee | 313 | #ifdef CONFIG_IP_DCCP_DEBUG |
7c657876 | 314 | struct dccp_sock *dp = dccp_sk(sk); |
7690af3f ACM |
315 | const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ? |
316 | "CLIENT TX opt: " : "server TX opt: "; | |
7c657876 ACM |
317 | #endif |
318 | const int elapsed_time_len = dccp_elapsed_time_len(elapsed_time); | |
319 | const int len = 2 + elapsed_time_len; | |
320 | unsigned char *to; | |
321 | ||
1bc09869 | 322 | if (elapsed_time_len == 0) |
7c657876 ACM |
323 | return; |
324 | ||
325 | if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) { | |
7690af3f ACM |
326 | LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to " |
327 | "insert elapsed time!\n"); | |
7c657876 ACM |
328 | return; |
329 | } | |
330 | ||
331 | DCCP_SKB_CB(skb)->dccpd_opt_len += len; | |
332 | ||
333 | to = skb_push(skb, len); | |
334 | *to++ = DCCPO_ELAPSED_TIME; | |
335 | *to++ = len; | |
336 | ||
1bc09869 IM |
337 | if (elapsed_time_len == 2) { |
338 | const u16 var16 = htons((u16)elapsed_time); | |
339 | memcpy(to, &var16, 2); | |
340 | } else { | |
341 | const u32 var32 = htonl(elapsed_time); | |
342 | memcpy(to, &var32, 4); | |
343 | } | |
7c657876 ACM |
344 | |
345 | dccp_pr_debug("%sELAPSED_TIME=%u, len=%d, seqno=%llu\n", | |
346 | debug_prefix, elapsed_time, | |
f6ccf554 DM |
347 | len, |
348 | (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq); | |
7c657876 ACM |
349 | } |
350 | ||
d4b81ff7 | 351 | EXPORT_SYMBOL_GPL(dccp_insert_option_elapsed_time); |
7c657876 ACM |
352 | |
353 | static void dccp_insert_option_ack_vector(struct sock *sk, struct sk_buff *skb) | |
354 | { | |
355 | struct dccp_sock *dp = dccp_sk(sk); | |
725ba8ee | 356 | #ifdef CONFIG_IP_DCCP_DEBUG |
7690af3f ACM |
357 | const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ? |
358 | "CLIENT TX opt: " : "server TX opt: "; | |
7c657876 ACM |
359 | #endif |
360 | struct dccp_ackpkts *ap = dp->dccps_hc_rx_ackpkts; | |
361 | int len = ap->dccpap_buf_vector_len + 2; | |
b6ee3d4a | 362 | const u32 elapsed_time = timeval_now_delta(&ap->dccpap_time) / 10; |
7c657876 ACM |
363 | unsigned char *to, *from; |
364 | ||
365 | if (elapsed_time != 0) | |
366 | dccp_insert_option_elapsed_time(sk, skb, elapsed_time); | |
367 | ||
368 | if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) { | |
7690af3f ACM |
369 | LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to " |
370 | "insert ACK Vector!\n"); | |
7c657876 ACM |
371 | return; |
372 | } | |
373 | ||
374 | /* | |
375 | * XXX: now we have just one ack vector sent record, so | |
376 | * we have to wait for it to be cleared. | |
377 | * | |
378 | * Of course this is not acceptable, but this is just for | |
379 | * basic testing now. | |
380 | */ | |
381 | if (ap->dccpap_ack_seqno != DCCP_MAX_SEQNO + 1) | |
382 | return; | |
383 | ||
384 | DCCP_SKB_CB(skb)->dccpd_opt_len += len; | |
385 | ||
386 | to = skb_push(skb, len); | |
387 | *to++ = DCCPO_ACK_VECTOR_0; | |
388 | *to++ = len; | |
389 | ||
390 | len = ap->dccpap_buf_vector_len; | |
391 | from = ap->dccpap_buf + ap->dccpap_buf_head; | |
392 | ||
393 | /* Check if buf_head wraps */ | |
394 | if (ap->dccpap_buf_head + len > ap->dccpap_buf_len) { | |
7690af3f ACM |
395 | const unsigned int tailsize = (ap->dccpap_buf_len - |
396 | ap->dccpap_buf_head); | |
7c657876 ACM |
397 | |
398 | memcpy(to, from, tailsize); | |
399 | to += tailsize; | |
400 | len -= tailsize; | |
401 | from = ap->dccpap_buf; | |
402 | } | |
403 | ||
404 | memcpy(to, from, len); | |
405 | /* | |
406 | * From draft-ietf-dccp-spec-11.txt: | |
407 | * | |
408 | * For each acknowledgement it sends, the HC-Receiver will add an | |
409 | * acknowledgement record. ack_seqno will equal the HC-Receiver | |
410 | * sequence number it used for the ack packet; ack_ptr will equal | |
7690af3f ACM |
411 | * buf_head; ack_ackno will equal buf_ackno; and ack_nonce will |
412 | * equal buf_nonce. | |
7c657876 ACM |
413 | * |
414 | * This implemention uses just one ack record for now. | |
415 | */ | |
416 | ap->dccpap_ack_seqno = DCCP_SKB_CB(skb)->dccpd_seq; | |
417 | ap->dccpap_ack_ptr = ap->dccpap_buf_head; | |
418 | ap->dccpap_ack_ackno = ap->dccpap_buf_ackno; | |
419 | ap->dccpap_ack_nonce = ap->dccpap_buf_nonce; | |
420 | ap->dccpap_ack_vector_len = ap->dccpap_buf_vector_len; | |
421 | ||
7690af3f ACM |
422 | dccp_pr_debug("%sACK Vector 0, len=%d, ack_seqno=%llu, " |
423 | "ack_ackno=%llu\n", | |
7c657876 | 424 | debug_prefix, ap->dccpap_ack_vector_len, |
f6ccf554 DM |
425 | (unsigned long long) ap->dccpap_ack_seqno, |
426 | (unsigned long long) ap->dccpap_ack_ackno); | |
7c657876 ACM |
427 | } |
428 | ||
d4b81ff7 | 429 | void dccp_insert_option_timestamp(struct sock *sk, struct sk_buff *skb) |
7c657876 | 430 | { |
1bc09869 IM |
431 | struct timeval tv; |
432 | u32 now; | |
433 | ||
434 | do_gettimeofday(&tv); | |
435 | now = (tv.tv_sec * USEC_PER_SEC + tv.tv_usec) / 10; | |
436 | /* yes this will overflow but that is the point as we want a | |
437 | * 10 usec 32 bit timer which mean it wraps every 11.9 hours */ | |
438 | ||
439 | now = htonl(now); | |
7c657876 ACM |
440 | dccp_insert_option(sk, skb, DCCPO_TIMESTAMP, &now, sizeof(now)); |
441 | } | |
442 | ||
d4b81ff7 ACM |
443 | EXPORT_SYMBOL_GPL(dccp_insert_option_timestamp); |
444 | ||
7690af3f ACM |
445 | static void dccp_insert_option_timestamp_echo(struct sock *sk, |
446 | struct sk_buff *skb) | |
7c657876 ACM |
447 | { |
448 | struct dccp_sock *dp = dccp_sk(sk); | |
725ba8ee | 449 | #ifdef CONFIG_IP_DCCP_DEBUG |
7690af3f ACM |
450 | const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ? |
451 | "CLIENT TX opt: " : "server TX opt: "; | |
7c657876 ACM |
452 | #endif |
453 | u32 tstamp_echo; | |
b6ee3d4a ACM |
454 | const u32 elapsed_time = |
455 | timeval_now_delta(&dp->dccps_timestamp_time) / 10; | |
7c657876 ACM |
456 | const int elapsed_time_len = dccp_elapsed_time_len(elapsed_time); |
457 | const int len = 6 + elapsed_time_len; | |
458 | unsigned char *to; | |
459 | ||
460 | if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) { | |
7690af3f ACM |
461 | LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to insert " |
462 | "timestamp echo!\n"); | |
7c657876 ACM |
463 | return; |
464 | } | |
465 | ||
466 | DCCP_SKB_CB(skb)->dccpd_opt_len += len; | |
467 | ||
468 | to = skb_push(skb, len); | |
469 | *to++ = DCCPO_TIMESTAMP_ECHO; | |
470 | *to++ = len; | |
471 | ||
472 | tstamp_echo = htonl(dp->dccps_timestamp_echo); | |
473 | memcpy(to, &tstamp_echo, 4); | |
474 | to += 4; | |
1bc09869 IM |
475 | |
476 | if (elapsed_time_len == 2) { | |
477 | const u16 var16 = htons((u16)elapsed_time); | |
478 | memcpy(to, &var16, 2); | |
479 | } else if (elapsed_time_len == 4) { | |
480 | const u32 var32 = htonl(elapsed_time); | |
481 | memcpy(to, &var32, 4); | |
482 | } | |
7c657876 ACM |
483 | |
484 | dccp_pr_debug("%sTIMESTAMP_ECHO=%u, len=%d, seqno=%llu\n", | |
485 | debug_prefix, dp->dccps_timestamp_echo, | |
f6ccf554 DM |
486 | len, |
487 | (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq); | |
7c657876 ACM |
488 | |
489 | dp->dccps_timestamp_echo = 0; | |
1bc09869 IM |
490 | dp->dccps_timestamp_time.tv_sec = 0; |
491 | dp->dccps_timestamp_time.tv_usec = 0; | |
7c657876 ACM |
492 | } |
493 | ||
494 | void dccp_insert_options(struct sock *sk, struct sk_buff *skb) | |
495 | { | |
496 | struct dccp_sock *dp = dccp_sk(sk); | |
497 | ||
498 | DCCP_SKB_CB(skb)->dccpd_opt_len = 0; | |
499 | ||
500 | if (dp->dccps_options.dccpo_send_ndp_count) | |
501 | dccp_insert_option_ndp(sk, skb); | |
502 | ||
503 | if (!dccp_packet_without_ack(skb)) { | |
504 | if (dp->dccps_options.dccpo_send_ack_vector && | |
7690af3f ACM |
505 | (dp->dccps_hc_rx_ackpkts->dccpap_buf_ackno != |
506 | DCCP_MAX_SEQNO + 1)) | |
7c657876 | 507 | dccp_insert_option_ack_vector(sk, skb); |
7c657876 ACM |
508 | if (dp->dccps_timestamp_echo != 0) |
509 | dccp_insert_option_timestamp_echo(sk, skb); | |
510 | } | |
511 | ||
507d37cf ACM |
512 | if (dp->dccps_hc_rx_insert_options) { |
513 | ccid_hc_rx_insert_options(dp->dccps_hc_rx_ccid, sk, skb); | |
514 | dp->dccps_hc_rx_insert_options = 0; | |
515 | } | |
516 | if (dp->dccps_hc_tx_insert_options) { | |
517 | ccid_hc_tx_insert_options(dp->dccps_hc_tx_ccid, sk, skb); | |
518 | dp->dccps_hc_tx_insert_options = 0; | |
519 | } | |
7c657876 ACM |
520 | |
521 | /* XXX: insert other options when appropriate */ | |
522 | ||
523 | if (DCCP_SKB_CB(skb)->dccpd_opt_len != 0) { | |
524 | /* The length of all options has to be a multiple of 4 */ | |
525 | int padding = DCCP_SKB_CB(skb)->dccpd_opt_len % 4; | |
526 | ||
527 | if (padding != 0) { | |
528 | padding = 4 - padding; | |
529 | memset(skb_push(skb, padding), 0, padding); | |
530 | DCCP_SKB_CB(skb)->dccpd_opt_len += padding; | |
531 | } | |
532 | } | |
533 | } | |
534 | ||
a1d3a355 ACM |
535 | struct dccp_ackpkts *dccp_ackpkts_alloc(const unsigned int len, |
536 | const unsigned int __nocast priority) | |
7c657876 ACM |
537 | { |
538 | struct dccp_ackpkts *ap = kmalloc(sizeof(*ap) + len, priority); | |
539 | ||
540 | if (ap != NULL) { | |
725ba8ee | 541 | #ifdef CONFIG_IP_DCCP_DEBUG |
7c657876 ACM |
542 | memset(ap->dccpap_buf, 0xFF, len); |
543 | #endif | |
7690af3f ACM |
544 | ap->dccpap_buf_len = len; |
545 | ap->dccpap_buf_head = | |
546 | ap->dccpap_buf_tail = | |
547 | ap->dccpap_buf_len - 1; | |
548 | ap->dccpap_buf_ackno = | |
549 | ap->dccpap_ack_ackno = | |
550 | ap->dccpap_ack_seqno = DCCP_MAX_SEQNO + 1; | |
551 | ap->dccpap_buf_nonce = ap->dccpap_buf_nonce = 0; | |
552 | ap->dccpap_ack_ptr = 0; | |
1bc09869 IM |
553 | ap->dccpap_time.tv_sec = 0; |
554 | ap->dccpap_time.tv_usec = 0; | |
7c657876 ACM |
555 | ap->dccpap_buf_vector_len = ap->dccpap_ack_vector_len = 0; |
556 | } | |
557 | ||
558 | return ap; | |
559 | } | |
560 | ||
561 | void dccp_ackpkts_free(struct dccp_ackpkts *ap) | |
562 | { | |
563 | if (ap != NULL) { | |
725ba8ee | 564 | #ifdef CONFIG_IP_DCCP_DEBUG |
7c657876 ACM |
565 | memset(ap, 0xFF, sizeof(*ap) + ap->dccpap_buf_len); |
566 | #endif | |
567 | kfree(ap); | |
568 | } | |
569 | } | |
570 | ||
571 | static inline u8 dccp_ackpkts_state(const struct dccp_ackpkts *ap, | |
572 | const unsigned int index) | |
573 | { | |
574 | return ap->dccpap_buf[index] & DCCP_ACKPKTS_STATE_MASK; | |
575 | } | |
576 | ||
577 | static inline u8 dccp_ackpkts_len(const struct dccp_ackpkts *ap, | |
578 | const unsigned int index) | |
579 | { | |
580 | return ap->dccpap_buf[index] & DCCP_ACKPKTS_LEN_MASK; | |
581 | } | |
582 | ||
583 | /* | |
584 | * If several packets are missing, the HC-Receiver may prefer to enter multiple | |
585 | * bytes with run length 0, rather than a single byte with a larger run length; | |
586 | * this simplifies table updates if one of the missing packets arrives. | |
587 | */ | |
588 | static inline int dccp_ackpkts_set_buf_head_state(struct dccp_ackpkts *ap, | |
589 | const unsigned int packets, | |
590 | const unsigned char state) | |
591 | { | |
592 | unsigned int gap; | |
593 | signed long new_head; | |
594 | ||
595 | if (ap->dccpap_buf_vector_len + packets > ap->dccpap_buf_len) | |
596 | return -ENOBUFS; | |
597 | ||
598 | gap = packets - 1; | |
599 | new_head = ap->dccpap_buf_head - packets; | |
600 | ||
601 | if (new_head < 0) { | |
602 | if (gap > 0) { | |
603 | memset(ap->dccpap_buf, DCCP_ACKPKTS_STATE_NOT_RECEIVED, | |
604 | gap + new_head + 1); | |
605 | gap = -new_head; | |
606 | } | |
607 | new_head += ap->dccpap_buf_len; | |
608 | } | |
609 | ||
610 | ap->dccpap_buf_head = new_head; | |
611 | ||
612 | if (gap > 0) | |
613 | memset(ap->dccpap_buf + ap->dccpap_buf_head + 1, | |
614 | DCCP_ACKPKTS_STATE_NOT_RECEIVED, gap); | |
615 | ||
616 | ap->dccpap_buf[ap->dccpap_buf_head] = state; | |
617 | ap->dccpap_buf_vector_len += packets; | |
618 | return 0; | |
619 | } | |
620 | ||
621 | /* | |
622 | * Implements the draft-ietf-dccp-spec-11.txt Appendix A | |
623 | */ | |
624 | int dccp_ackpkts_add(struct dccp_ackpkts *ap, u64 ackno, u8 state) | |
625 | { | |
626 | /* | |
627 | * Check at the right places if the buffer is full, if it is, tell the | |
628 | * caller to start dropping packets till the HC-Sender acks our ACK | |
629 | * vectors, when we will free up space in dccpap_buf. | |
630 | * | |
631 | * We may well decide to do buffer compression, etc, but for now lets | |
632 | * just drop. | |
633 | * | |
634 | * From Appendix A: | |
635 | * | |
7690af3f ACM |
636 | * Of course, the circular buffer may overflow, either when the |
637 | * HC-Sender is sending data at a very high rate, when the | |
638 | * HC-Receiver's acknowledgements are not reaching the HC-Sender, | |
639 | * or when the HC-Sender is forgetting to acknowledge those acks | |
640 | * (so the HC-Receiver is unable to clean up old state). In this | |
641 | * case, the HC-Receiver should either compress the buffer (by | |
642 | * increasing run lengths when possible), transfer its state to | |
643 | * a larger buffer, or, as a last resort, drop all received | |
644 | * packets, without processing them whatsoever, until its buffer | |
645 | * shrinks again. | |
7c657876 ACM |
646 | */ |
647 | ||
648 | /* See if this is the first ackno being inserted */ | |
649 | if (ap->dccpap_buf_vector_len == 0) { | |
650 | ap->dccpap_buf[ap->dccpap_buf_head] = state; | |
651 | ap->dccpap_buf_vector_len = 1; | |
652 | } else if (after48(ackno, ap->dccpap_buf_ackno)) { | |
7690af3f ACM |
653 | const u64 delta = dccp_delta_seqno(ap->dccpap_buf_ackno, |
654 | ackno); | |
7c657876 ACM |
655 | |
656 | /* | |
7690af3f ACM |
657 | * Look if the state of this packet is the same as the |
658 | * previous ackno and if so if we can bump the head len. | |
7c657876 ACM |
659 | */ |
660 | if (delta == 1 && | |
661 | dccp_ackpkts_state(ap, ap->dccpap_buf_head) == state && | |
7690af3f ACM |
662 | (dccp_ackpkts_len(ap, ap->dccpap_buf_head) < |
663 | DCCP_ACKPKTS_LEN_MASK)) | |
7c657876 ACM |
664 | ap->dccpap_buf[ap->dccpap_buf_head]++; |
665 | else if (dccp_ackpkts_set_buf_head_state(ap, delta, state)) | |
666 | return -ENOBUFS; | |
667 | } else { | |
668 | /* | |
669 | * A.1.2. Old Packets | |
670 | * | |
7690af3f ACM |
671 | * When a packet with Sequence Number S arrives, and |
672 | * S <= buf_ackno, the HC-Receiver will scan the table | |
673 | * for the byte corresponding to S. (Indexing structures | |
674 | * could reduce the complexity of this scan.) | |
7c657876 ACM |
675 | */ |
676 | u64 delta = dccp_delta_seqno(ackno, ap->dccpap_buf_ackno); | |
677 | unsigned int index = ap->dccpap_buf_head; | |
678 | ||
679 | while (1) { | |
680 | const u8 len = dccp_ackpkts_len(ap, index); | |
681 | const u8 state = dccp_ackpkts_state(ap, index); | |
682 | /* | |
7690af3f ACM |
683 | * valid packets not yet in dccpap_buf have a reserved |
684 | * entry, with a len equal to 0. | |
7c657876 ACM |
685 | */ |
686 | if (state == DCCP_ACKPKTS_STATE_NOT_RECEIVED && | |
7690af3f ACM |
687 | len == 0 && delta == 0) { /* Found our |
688 | reserved seat! */ | |
f6ccf554 DM |
689 | dccp_pr_debug("Found %llu reserved seat!\n", |
690 | (unsigned long long) ackno); | |
7c657876 ACM |
691 | ap->dccpap_buf[index] = state; |
692 | goto out; | |
693 | } | |
694 | /* len == 0 means one packet */ | |
695 | if (delta < len + 1) | |
696 | goto out_duplicate; | |
697 | ||
698 | delta -= len + 1; | |
699 | if (++index == ap->dccpap_buf_len) | |
700 | index = 0; | |
701 | } | |
702 | } | |
703 | ||
704 | ap->dccpap_buf_ackno = ackno; | |
1bc09869 | 705 | do_gettimeofday(&ap->dccpap_time); |
7c657876 ACM |
706 | out: |
707 | dccp_pr_debug(""); | |
708 | dccp_ackpkts_print(ap); | |
709 | return 0; | |
710 | ||
711 | out_duplicate: | |
712 | /* Duplicate packet */ | |
7690af3f ACM |
713 | dccp_pr_debug("Received a dup or already considered lost " |
714 | "packet: %llu\n", (unsigned long long) ackno); | |
7c657876 ACM |
715 | return -EILSEQ; |
716 | } | |
717 | ||
725ba8ee | 718 | #ifdef CONFIG_IP_DCCP_DEBUG |
7690af3f ACM |
719 | void dccp_ackvector_print(const u64 ackno, const unsigned char *vector, |
720 | int len) | |
7c657876 ACM |
721 | { |
722 | if (!dccp_debug) | |
723 | return; | |
724 | ||
f6ccf554 DM |
725 | printk("ACK vector len=%d, ackno=%llu |", len, |
726 | (unsigned long long) ackno); | |
7c657876 ACM |
727 | |
728 | while (len--) { | |
729 | const u8 state = (*vector & DCCP_ACKPKTS_STATE_MASK) >> 6; | |
730 | const u8 rl = (*vector & DCCP_ACKPKTS_LEN_MASK); | |
731 | ||
732 | printk("%d,%d|", state, rl); | |
733 | ++vector; | |
734 | } | |
735 | ||
736 | printk("\n"); | |
737 | } | |
738 | ||
739 | void dccp_ackpkts_print(const struct dccp_ackpkts *ap) | |
740 | { | |
741 | dccp_ackvector_print(ap->dccpap_buf_ackno, | |
742 | ap->dccpap_buf + ap->dccpap_buf_head, | |
743 | ap->dccpap_buf_vector_len); | |
744 | } | |
745 | #endif | |
746 | ||
747 | static void dccp_ackpkts_trow_away_ack_record(struct dccp_ackpkts *ap) | |
748 | { | |
749 | /* | |
750 | * As we're keeping track of the ack vector size | |
751 | * (dccpap_buf_vector_len) and the sent ack vector size | |
752 | * (dccpap_ack_vector_len) we don't need dccpap_buf_tail at all, but | |
7690af3f ACM |
753 | * keep this code here as in the future we'll implement a vector of |
754 | * ack records, as suggested in draft-ietf-dccp-spec-11.txt | |
755 | * Appendix A. -acme | |
7c657876 ACM |
756 | */ |
757 | #if 0 | |
758 | ap->dccpap_buf_tail = ap->dccpap_ack_ptr + 1; | |
759 | if (ap->dccpap_buf_tail >= ap->dccpap_buf_len) | |
760 | ap->dccpap_buf_tail -= ap->dccpap_buf_len; | |
761 | #endif | |
762 | ap->dccpap_buf_vector_len -= ap->dccpap_ack_vector_len; | |
763 | } | |
764 | ||
765 | void dccp_ackpkts_check_rcv_ackno(struct dccp_ackpkts *ap, struct sock *sk, | |
766 | u64 ackno) | |
767 | { | |
768 | /* Check if we actually sent an ACK vector */ | |
769 | if (ap->dccpap_ack_seqno == DCCP_MAX_SEQNO + 1) | |
770 | return; | |
771 | ||
772 | if (ackno == ap->dccpap_ack_seqno) { | |
725ba8ee | 773 | #ifdef CONFIG_IP_DCCP_DEBUG |
7c657876 | 774 | struct dccp_sock *dp = dccp_sk(sk); |
7690af3f ACM |
775 | const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ? |
776 | "CLIENT rx ack: " : "server rx ack: "; | |
7c657876 | 777 | #endif |
7690af3f ACM |
778 | dccp_pr_debug("%sACK packet 0, len=%d, ack_seqno=%llu, " |
779 | "ack_ackno=%llu, ACKED!\n", | |
7c657876 | 780 | debug_prefix, 1, |
f6ccf554 DM |
781 | (unsigned long long) ap->dccpap_ack_seqno, |
782 | (unsigned long long) ap->dccpap_ack_ackno); | |
7c657876 ACM |
783 | dccp_ackpkts_trow_away_ack_record(ap); |
784 | ap->dccpap_ack_seqno = DCCP_MAX_SEQNO + 1; | |
785 | } | |
786 | } | |
787 | ||
788 | static void dccp_ackpkts_check_rcv_ackvector(struct dccp_ackpkts *ap, | |
789 | struct sock *sk, u64 ackno, | |
790 | const unsigned char len, | |
791 | const unsigned char *vector) | |
792 | { | |
793 | unsigned char i; | |
794 | ||
795 | /* Check if we actually sent an ACK vector */ | |
796 | if (ap->dccpap_ack_seqno == DCCP_MAX_SEQNO + 1) | |
797 | return; | |
798 | /* | |
7690af3f ACM |
799 | * We're in the receiver half connection, so if the received an ACK |
800 | * vector ackno (e.g. 50) before dccpap_ack_seqno (e.g. 52), we're | |
801 | * not interested. | |
7c657876 ACM |
802 | * |
803 | * Extra explanation with example: | |
804 | * | |
805 | * if we received an ACK vector with ackno 50, it can only be acking | |
806 | * 50, 49, 48, etc, not 52 (the seqno for the ACK vector we sent). | |
807 | */ | |
7690af3f | 808 | /* dccp_pr_debug("is %llu < %llu? ", ackno, ap->dccpap_ack_seqno); */ |
7c657876 | 809 | if (before48(ackno, ap->dccpap_ack_seqno)) { |
7690af3f | 810 | /* dccp_pr_debug_cat("yes\n"); */ |
7c657876 ACM |
811 | return; |
812 | } | |
7690af3f | 813 | /* dccp_pr_debug_cat("no\n"); */ |
7c657876 ACM |
814 | |
815 | i = len; | |
816 | while (i--) { | |
817 | const u8 rl = (*vector & DCCP_ACKPKTS_LEN_MASK); | |
818 | u64 ackno_end_rl; | |
819 | ||
820 | dccp_set_seqno(&ackno_end_rl, ackno - rl); | |
821 | ||
7690af3f ACM |
822 | /* |
823 | * dccp_pr_debug("is %llu <= %llu <= %llu? ", ackno_end_rl, | |
824 | * ap->dccpap_ack_seqno, ackno); | |
825 | */ | |
7c657876 | 826 | if (between48(ap->dccpap_ack_seqno, ackno_end_rl, ackno)) { |
7690af3f ACM |
827 | const u8 state = (*vector & |
828 | DCCP_ACKPKTS_STATE_MASK) >> 6; | |
829 | /* dccp_pr_debug_cat("yes\n"); */ | |
7c657876 ACM |
830 | |
831 | if (state != DCCP_ACKPKTS_STATE_NOT_RECEIVED) { | |
725ba8ee | 832 | #ifdef CONFIG_IP_DCCP_DEBUG |
7c657876 | 833 | struct dccp_sock *dp = dccp_sk(sk); |
7690af3f ACM |
834 | const char *debug_prefix = |
835 | dp->dccps_role == DCCP_ROLE_CLIENT ? | |
836 | "CLIENT rx ack: " : "server rx ack: "; | |
7c657876 | 837 | #endif |
7690af3f ACM |
838 | dccp_pr_debug("%sACK vector 0, len=%d, " |
839 | "ack_seqno=%llu, ack_ackno=%llu, " | |
840 | "ACKED!\n", | |
7c657876 | 841 | debug_prefix, len, |
f6ccf554 DM |
842 | (unsigned long long) |
843 | ap->dccpap_ack_seqno, | |
844 | (unsigned long long) | |
845 | ap->dccpap_ack_ackno); | |
7c657876 ACM |
846 | dccp_ackpkts_trow_away_ack_record(ap); |
847 | } | |
848 | /* | |
7690af3f ACM |
849 | * If dccpap_ack_seqno was not received, no problem |
850 | * we'll send another ACK vector. | |
7c657876 ACM |
851 | */ |
852 | ap->dccpap_ack_seqno = DCCP_MAX_SEQNO + 1; | |
853 | break; | |
854 | } | |
7690af3f | 855 | /* dccp_pr_debug_cat("no\n"); */ |
7c657876 ACM |
856 | |
857 | dccp_set_seqno(&ackno, ackno_end_rl - 1); | |
858 | ++vector; | |
859 | } | |
860 | } |