4 * An implementation of the DCCP protocol
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>
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.
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>
25 /* stores the default values for new connection. may be changed with sysctl */
26 static const struct dccp_options dccpo_default_values
= {
27 .dccpo_sequence_window
= DCCPF_INITIAL_SEQUENCE_WINDOW
,
28 .dccpo_ccid
= DCCPF_INITIAL_CCID
,
29 .dccpo_send_ack_vector
= DCCPF_INITIAL_SEND_ACK_VECTOR
,
30 .dccpo_send_ndp_count
= DCCPF_INITIAL_SEND_NDP_COUNT
,
33 void dccp_options_init(struct dccp_options
*dccpo
)
35 memcpy(dccpo
, &dccpo_default_values
, sizeof(*dccpo
));
38 static u32
dccp_decode_value_var(const unsigned char *bf
, const u8 len
)
54 int dccp_parse_options(struct sock
*sk
, struct sk_buff
*skb
)
56 struct dccp_sock
*dp
= dccp_sk(sk
);
57 #ifdef CONFIG_IP_DCCP_DEBUG
58 const char *debug_prefix
= dp
->dccps_role
== DCCP_ROLE_CLIENT
?
59 "CLIENT rx opt: " : "server rx opt: ";
61 const struct dccp_hdr
*dh
= dccp_hdr(skb
);
62 const u8 pkt_type
= DCCP_SKB_CB(skb
)->dccpd_type
;
63 unsigned char *options
= (unsigned char *)dh
+ dccp_hdr_len(skb
);
64 unsigned char *opt_ptr
= options
;
65 const unsigned char *opt_end
= (unsigned char *)dh
+
67 struct dccp_options_received
*opt_recv
= &dp
->dccps_options_received
;
68 unsigned char opt
, len
;
72 memset(opt_recv
, 0, sizeof(*opt_recv
));
74 while (opt_ptr
!= opt_end
) {
79 /* Check if this isn't a single byte option */
80 if (opt
> DCCPO_MAX_RESERVED
) {
81 if (opt_ptr
== opt_end
)
82 goto out_invalid_option
;
86 goto out_invalid_option
;
88 * Remove the type and len fields, leaving
95 if (opt_ptr
> opt_end
)
96 goto out_invalid_option
;
102 case DCCPO_NDP_COUNT
:
104 goto out_invalid_option
;
106 opt_recv
->dccpor_ndp
= dccp_decode_value_var(value
, len
);
107 dccp_pr_debug("%sNDP count=%d\n", debug_prefix
,
108 opt_recv
->dccpor_ndp
);
110 case DCCPO_ACK_VECTOR_0
:
111 case DCCPO_ACK_VECTOR_1
:
112 if (pkt_type
== DCCP_PKT_DATA
)
115 if (dp
->dccps_options
.dccpo_send_ack_vector
&&
116 dccp_ackvec_parse(sk
, skb
, opt
, value
, len
))
117 goto out_invalid_option
;
119 case DCCPO_TIMESTAMP
:
121 goto out_invalid_option
;
123 opt_recv
->dccpor_timestamp
= ntohl(*(u32
*)value
);
125 dp
->dccps_timestamp_echo
= opt_recv
->dccpor_timestamp
;
126 dccp_timestamp(sk
, &dp
->dccps_timestamp_time
);
128 dccp_pr_debug("%sTIMESTAMP=%u, ackno=%llu\n",
129 debug_prefix
, opt_recv
->dccpor_timestamp
,
131 DCCP_SKB_CB(skb
)->dccpd_ack_seq
);
133 case DCCPO_TIMESTAMP_ECHO
:
134 if (len
!= 4 && len
!= 6 && len
!= 8)
135 goto out_invalid_option
;
137 opt_recv
->dccpor_timestamp_echo
= ntohl(*(u32
*)value
);
139 dccp_pr_debug("%sTIMESTAMP_ECHO=%u, len=%d, ackno=%llu, ",
141 opt_recv
->dccpor_timestamp_echo
,
144 DCCP_SKB_CB(skb
)->dccpd_ack_seq
);
151 elapsed_time
= ntohs(*(u16
*)(value
+ 4));
153 elapsed_time
= ntohl(*(u32
*)(value
+ 4));
155 /* Give precedence to the biggest ELAPSED_TIME */
156 if (elapsed_time
> opt_recv
->dccpor_elapsed_time
)
157 opt_recv
->dccpor_elapsed_time
= elapsed_time
;
159 case DCCPO_ELAPSED_TIME
:
160 if (len
!= 2 && len
!= 4)
161 goto out_invalid_option
;
163 if (pkt_type
== DCCP_PKT_DATA
)
167 elapsed_time
= ntohs(*(u16
*)value
);
169 elapsed_time
= ntohl(*(u32
*)value
);
171 if (elapsed_time
> opt_recv
->dccpor_elapsed_time
)
172 opt_recv
->dccpor_elapsed_time
= elapsed_time
;
174 dccp_pr_debug("%sELAPSED_TIME=%d\n", debug_prefix
,
178 * From draft-ietf-dccp-spec-11.txt:
180 * Option numbers 128 through 191 are for
181 * options sent from the HC-Sender to the
182 * HC-Receiver; option numbers 192 through 255
183 * are for options sent from the HC-Receiver to
187 const u16 idx
= value
- options
;
189 if (ccid_hc_rx_parse_options(dp
->dccps_hc_rx_ccid
, sk
,
192 goto out_invalid_option
;
196 const u16 idx
= value
- options
;
198 if (ccid_hc_tx_parse_options(dp
->dccps_hc_tx_ccid
, sk
,
201 goto out_invalid_option
;
205 pr_info("DCCP(%p): option %d(len=%d) not "
206 "implemented, ignoring\n",
215 DCCP_INC_STATS_BH(DCCP_MIB_INVALIDOPT
);
216 DCCP_SKB_CB(skb
)->dccpd_reset_code
= DCCP_RESET_CODE_OPTION_ERROR
;
217 pr_info("DCCP(%p): invalid option %d, len=%d\n", sk
, opt
, len
);
221 static void dccp_encode_value_var(const u32 value
, unsigned char *to
,
222 const unsigned int len
)
225 *to
++ = (value
& 0xFF000000) >> 24;
227 *to
++ = (value
& 0xFF0000) >> 16;
229 *to
++ = (value
& 0xFF00) >> 8;
231 *to
++ = (value
& 0xFF);
234 static inline int dccp_ndp_len(const int ndp
)
236 return likely(ndp
<= 0xFF) ? 1 : ndp
<= 0xFFFF ? 2 : 3;
239 void dccp_insert_option(struct sock
*sk
, struct sk_buff
*skb
,
240 const unsigned char option
,
241 const void *value
, const unsigned char len
)
245 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
+ len
+ 2 > DCCP_MAX_OPT_LEN
) {
246 LIMIT_NETDEBUG(KERN_INFO
"DCCP: packet too small to insert "
247 "%d option!\n", option
);
251 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= len
+ 2;
253 to
= skb_push(skb
, len
+ 2);
257 memcpy(to
, value
, len
);
260 EXPORT_SYMBOL_GPL(dccp_insert_option
);
262 static void dccp_insert_option_ndp(struct sock
*sk
, struct sk_buff
*skb
)
264 struct dccp_sock
*dp
= dccp_sk(sk
);
265 int ndp
= dp
->dccps_ndp_count
;
267 if (dccp_non_data_packet(skb
))
268 ++dp
->dccps_ndp_count
;
270 dp
->dccps_ndp_count
= 0;
274 const int ndp_len
= dccp_ndp_len(ndp
);
275 const int len
= ndp_len
+ 2;
277 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
+ len
> DCCP_MAX_OPT_LEN
)
280 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= len
;
282 ptr
= skb_push(skb
, len
);
283 *ptr
++ = DCCPO_NDP_COUNT
;
285 dccp_encode_value_var(ndp
, ptr
, ndp_len
);
289 static inline int dccp_elapsed_time_len(const u32 elapsed_time
)
291 return elapsed_time
== 0 ? 0 : elapsed_time
<= 0xFFFF ? 2 : 4;
294 void dccp_insert_option_elapsed_time(struct sock
*sk
,
298 #ifdef CONFIG_IP_DCCP_DEBUG
299 struct dccp_sock
*dp
= dccp_sk(sk
);
300 const char *debug_prefix
= dp
->dccps_role
== DCCP_ROLE_CLIENT
?
301 "CLIENT TX opt: " : "server TX opt: ";
303 const int elapsed_time_len
= dccp_elapsed_time_len(elapsed_time
);
304 const int len
= 2 + elapsed_time_len
;
307 if (elapsed_time_len
== 0)
310 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
+ len
> DCCP_MAX_OPT_LEN
) {
311 LIMIT_NETDEBUG(KERN_INFO
"DCCP: packet too small to "
312 "insert elapsed time!\n");
316 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= len
;
318 to
= skb_push(skb
, len
);
319 *to
++ = DCCPO_ELAPSED_TIME
;
322 if (elapsed_time_len
== 2) {
323 const u16 var16
= htons((u16
)elapsed_time
);
324 memcpy(to
, &var16
, 2);
326 const u32 var32
= htonl(elapsed_time
);
327 memcpy(to
, &var32
, 4);
330 dccp_pr_debug("%sELAPSED_TIME=%u, len=%d, seqno=%llu\n",
331 debug_prefix
, elapsed_time
,
333 (unsigned long long) DCCP_SKB_CB(skb
)->dccpd_seq
);
336 EXPORT_SYMBOL_GPL(dccp_insert_option_elapsed_time
);
338 void dccp_timestamp(const struct sock
*sk
, struct timeval
*tv
)
340 const struct dccp_sock
*dp
= dccp_sk(sk
);
343 tv
->tv_sec
-= dp
->dccps_epoch
.tv_sec
;
344 tv
->tv_usec
-= dp
->dccps_epoch
.tv_usec
;
346 while (tv
->tv_usec
< 0) {
348 tv
->tv_usec
+= USEC_PER_SEC
;
352 EXPORT_SYMBOL_GPL(dccp_timestamp
);
354 void dccp_insert_option_timestamp(struct sock
*sk
, struct sk_buff
*skb
)
359 dccp_timestamp(sk
, &tv
);
360 now
= timeval_usecs(&tv
) / 10;
361 /* yes this will overflow but that is the point as we want a
362 * 10 usec 32 bit timer which mean it wraps every 11.9 hours */
365 dccp_insert_option(sk
, skb
, DCCPO_TIMESTAMP
, &now
, sizeof(now
));
368 EXPORT_SYMBOL_GPL(dccp_insert_option_timestamp
);
370 static void dccp_insert_option_timestamp_echo(struct sock
*sk
,
373 struct dccp_sock
*dp
= dccp_sk(sk
);
374 #ifdef CONFIG_IP_DCCP_DEBUG
375 const char *debug_prefix
= dp
->dccps_role
== DCCP_ROLE_CLIENT
?
376 "CLIENT TX opt: " : "server TX opt: ";
381 int len
, elapsed_time_len
;
384 dccp_timestamp(sk
, &now
);
385 elapsed_time
= timeval_delta(&now
, &dp
->dccps_timestamp_time
) / 10;
386 elapsed_time_len
= dccp_elapsed_time_len(elapsed_time
);
387 len
= 6 + elapsed_time_len
;
389 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
+ len
> DCCP_MAX_OPT_LEN
) {
390 LIMIT_NETDEBUG(KERN_INFO
"DCCP: packet too small to insert "
391 "timestamp echo!\n");
395 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= len
;
397 to
= skb_push(skb
, len
);
398 *to
++ = DCCPO_TIMESTAMP_ECHO
;
401 tstamp_echo
= htonl(dp
->dccps_timestamp_echo
);
402 memcpy(to
, &tstamp_echo
, 4);
405 if (elapsed_time_len
== 2) {
406 const u16 var16
= htons((u16
)elapsed_time
);
407 memcpy(to
, &var16
, 2);
408 } else if (elapsed_time_len
== 4) {
409 const u32 var32
= htonl(elapsed_time
);
410 memcpy(to
, &var32
, 4);
413 dccp_pr_debug("%sTIMESTAMP_ECHO=%u, len=%d, seqno=%llu\n",
414 debug_prefix
, dp
->dccps_timestamp_echo
,
416 (unsigned long long) DCCP_SKB_CB(skb
)->dccpd_seq
);
418 dp
->dccps_timestamp_echo
= 0;
419 dp
->dccps_timestamp_time
.tv_sec
= 0;
420 dp
->dccps_timestamp_time
.tv_usec
= 0;
423 void dccp_insert_options(struct sock
*sk
, struct sk_buff
*skb
)
425 struct dccp_sock
*dp
= dccp_sk(sk
);
427 DCCP_SKB_CB(skb
)->dccpd_opt_len
= 0;
429 if (dp
->dccps_options
.dccpo_send_ndp_count
)
430 dccp_insert_option_ndp(sk
, skb
);
432 if (!dccp_packet_without_ack(skb
)) {
433 if (dp
->dccps_options
.dccpo_send_ack_vector
&&
434 dccp_ackvec_pending(dp
->dccps_hc_rx_ackvec
))
435 dccp_insert_option_ackvec(sk
, skb
);
436 if (dp
->dccps_timestamp_echo
!= 0)
437 dccp_insert_option_timestamp_echo(sk
, skb
);
440 if (dp
->dccps_hc_rx_insert_options
) {
441 ccid_hc_rx_insert_options(dp
->dccps_hc_rx_ccid
, sk
, skb
);
442 dp
->dccps_hc_rx_insert_options
= 0;
444 if (dp
->dccps_hc_tx_insert_options
) {
445 ccid_hc_tx_insert_options(dp
->dccps_hc_tx_ccid
, sk
, skb
);
446 dp
->dccps_hc_tx_insert_options
= 0;
449 /* XXX: insert other options when appropriate */
451 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
!= 0) {
452 /* The length of all options has to be a multiple of 4 */
453 int padding
= DCCP_SKB_CB(skb
)->dccpd_opt_len
% 4;
456 padding
= 4 - padding
;
457 memset(skb_push(skb
, padding
), 0, padding
);
458 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= padding
;