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 <ian.mcdonald@jandi.co.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/dccp.h>
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <asm/unaligned.h>
18 #include <linux/kernel.h>
19 #include <linux/skbuff.h>
26 int sysctl_dccp_feat_sequence_window
= DCCPF_INITIAL_SEQUENCE_WINDOW
;
27 int sysctl_dccp_feat_rx_ccid
= DCCPF_INITIAL_CCID
;
28 int sysctl_dccp_feat_tx_ccid
= DCCPF_INITIAL_CCID
;
29 int sysctl_dccp_feat_ack_ratio
= DCCPF_INITIAL_ACK_RATIO
;
30 int sysctl_dccp_feat_send_ack_vector
= DCCPF_INITIAL_SEND_ACK_VECTOR
;
31 int sysctl_dccp_feat_send_ndp_count
= DCCPF_INITIAL_SEND_NDP_COUNT
;
33 static u32
dccp_decode_value_var(const unsigned char *bf
, const u8 len
)
50 * dccp_parse_options - Parse DCCP options present in @skb
51 * @sk: client|server|listening dccp socket (when @dreq != NULL)
52 * @dreq: request socket to use during connection setup, or NULL
54 int dccp_parse_options(struct sock
*sk
, struct dccp_request_sock
*dreq
,
57 struct dccp_sock
*dp
= dccp_sk(sk
);
58 const struct dccp_hdr
*dh
= dccp_hdr(skb
);
59 const u8 pkt_type
= DCCP_SKB_CB(skb
)->dccpd_type
;
60 u64 ackno
= DCCP_SKB_CB(skb
)->dccpd_ack_seq
;
61 unsigned char *options
= (unsigned char *)dh
+ dccp_hdr_len(skb
);
62 unsigned char *opt_ptr
= options
;
63 const unsigned char *opt_end
= (unsigned char *)dh
+
65 struct dccp_options_received
*opt_recv
= &dp
->dccps_options_received
;
66 unsigned char opt
, len
;
73 memset(opt_recv
, 0, sizeof(*opt_recv
));
76 while (opt_ptr
!= opt_end
) {
81 /* Check if this isn't a single byte option */
82 if (opt
> DCCPO_MAX_RESERVED
) {
83 if (opt_ptr
== opt_end
)
84 goto out_invalid_option
;
88 goto out_invalid_option
;
90 * Remove the type and len fields, leaving
97 if (opt_ptr
> opt_end
)
98 goto out_invalid_option
;
102 * CCID-Specific Options (from RFC 4340, sec. 10.3):
104 * Option numbers 128 through 191 are for options sent from the
105 * HC-Sender to the HC-Receiver; option numbers 192 through 255
106 * are for options sent from the HC-Receiver to the HC-Sender.
108 * CCID-specific options are ignored during connection setup, as
109 * negotiation may still be in progress (see RFC 4340, 10.3).
110 * The same applies to Ack Vectors, as these depend on the CCID.
113 if (dreq
!= NULL
&& (opt
>= 128 ||
114 opt
== DCCPO_ACK_VECTOR_0
|| opt
== DCCPO_ACK_VECTOR_1
))
120 case DCCPO_MANDATORY
:
122 goto out_invalid_option
;
123 if (pkt_type
!= DCCP_PKT_DATA
)
126 case DCCPO_NDP_COUNT
:
128 goto out_invalid_option
;
130 opt_recv
->dccpor_ndp
= dccp_decode_value_var(value
, len
);
131 dccp_pr_debug("%s opt: NDP count=%llu\n", dccp_role(sk
),
132 (unsigned long long)opt_recv
->dccpor_ndp
);
137 if (pkt_type
== DCCP_PKT_DATA
)
140 goto out_invalid_option
;
141 rc
= dccp_feat_change_recv(sk
, opt
, *value
, value
+ 1,
144 * When there is a change error, change_recv is
145 * responsible for dealing with it. i.e. reply with an
147 * If the change was mandatory, then we need to die.
150 goto out_invalid_option
;
152 case DCCPO_CONFIRM_L
:
154 case DCCPO_CONFIRM_R
:
155 if (pkt_type
== DCCP_PKT_DATA
)
157 if (len
< 2) /* FIXME this disallows empty confirm */
158 goto out_invalid_option
;
159 if (dccp_feat_confirm_recv(sk
, opt
, *value
,
161 goto out_invalid_option
;
163 case DCCPO_ACK_VECTOR_0
:
164 case DCCPO_ACK_VECTOR_1
:
165 if (dccp_packet_without_ack(skb
)) /* RFC 4340, 11.4 */
168 if (dccp_msk(sk
)->dccpms_send_ack_vector
&&
169 dccp_ackvec_parse(sk
, skb
, &ackno
, opt
, value
, len
))
170 goto out_invalid_option
;
172 case DCCPO_TIMESTAMP
:
174 goto out_invalid_option
;
176 * RFC 4340 13.1: "The precise time corresponding to
177 * Timestamp Value zero is not specified". We use
178 * zero to indicate absence of a meaningful timestamp.
180 opt_val
= get_unaligned((__be32
*)value
);
181 if (unlikely(opt_val
== 0)) {
182 DCCP_WARN("Timestamp with zero value\n");
187 dreq
->dreq_timestamp_echo
= ntohl(opt_val
);
188 dreq
->dreq_timestamp_time
= dccp_timestamp();
190 opt_recv
->dccpor_timestamp
=
191 dp
->dccps_timestamp_echo
= ntohl(opt_val
);
192 dp
->dccps_timestamp_time
= dccp_timestamp();
194 dccp_pr_debug("%s rx opt: TIMESTAMP=%u, ackno=%llu\n",
195 dccp_role(sk
), ntohl(opt_val
),
197 DCCP_SKB_CB(skb
)->dccpd_ack_seq
);
199 case DCCPO_TIMESTAMP_ECHO
:
200 if (len
!= 4 && len
!= 6 && len
!= 8)
201 goto out_invalid_option
;
203 opt_val
= get_unaligned((__be32
*)value
);
204 opt_recv
->dccpor_timestamp_echo
= ntohl(opt_val
);
206 dccp_pr_debug("%s rx opt: TIMESTAMP_ECHO=%u, len=%d, "
207 "ackno=%llu", dccp_role(sk
),
208 opt_recv
->dccpor_timestamp_echo
,
211 DCCP_SKB_CB(skb
)->dccpd_ack_seq
);
215 if (len
== 4) { /* no elapsed time included */
216 dccp_pr_debug_cat("\n");
220 if (len
== 6) { /* 2-byte elapsed time */
221 __be16 opt_val2
= get_unaligned((__be16
*)value
);
222 elapsed_time
= ntohs(opt_val2
);
223 } else { /* 4-byte elapsed time */
224 opt_val
= get_unaligned((__be32
*)value
);
225 elapsed_time
= ntohl(opt_val
);
228 dccp_pr_debug_cat(", ELAPSED_TIME=%u\n", elapsed_time
);
230 /* Give precedence to the biggest ELAPSED_TIME */
231 if (elapsed_time
> opt_recv
->dccpor_elapsed_time
)
232 opt_recv
->dccpor_elapsed_time
= elapsed_time
;
234 case DCCPO_ELAPSED_TIME
:
235 if (dccp_packet_without_ack(skb
)) /* RFC 4340, 13.2 */
239 __be16 opt_val2
= get_unaligned((__be16
*)value
);
240 elapsed_time
= ntohs(opt_val2
);
241 } else if (len
== 4) {
242 opt_val
= get_unaligned((__be32
*)value
);
243 elapsed_time
= ntohl(opt_val
);
245 goto out_invalid_option
;
248 if (elapsed_time
> opt_recv
->dccpor_elapsed_time
)
249 opt_recv
->dccpor_elapsed_time
= elapsed_time
;
251 dccp_pr_debug("%s rx opt: ELAPSED_TIME=%d\n",
252 dccp_role(sk
), elapsed_time
);
255 const u16 idx
= value
- options
;
257 if (ccid_hc_rx_parse_options(dp
->dccps_hc_rx_ccid
, sk
,
260 goto out_invalid_option
;
264 const u16 idx
= value
- options
;
266 if (ccid_hc_tx_parse_options(dp
->dccps_hc_tx_ccid
, sk
,
269 goto out_invalid_option
;
273 DCCP_CRIT("DCCP(%p): option %d(len=%d) not "
274 "implemented, ignoring", sk
, opt
, len
);
278 if (opt
!= DCCPO_MANDATORY
)
282 /* mandatory was the last byte in option list -> reset connection */
284 goto out_invalid_option
;
289 DCCP_INC_STATS_BH(DCCP_MIB_INVALIDOPT
);
290 DCCP_SKB_CB(skb
)->dccpd_reset_code
= DCCP_RESET_CODE_OPTION_ERROR
;
291 DCCP_WARN("DCCP(%p): invalid option %d, len=%d", sk
, opt
, len
);
295 EXPORT_SYMBOL_GPL(dccp_parse_options
);
297 static void dccp_encode_value_var(const u32 value
, unsigned char *to
,
298 const unsigned int len
)
301 *to
++ = (value
& 0xFF000000) >> 24;
303 *to
++ = (value
& 0xFF0000) >> 16;
305 *to
++ = (value
& 0xFF00) >> 8;
307 *to
++ = (value
& 0xFF);
310 static inline u8
dccp_ndp_len(const u64 ndp
)
312 if (likely(ndp
<= 0xFF))
314 return likely(ndp
<= USHORT_MAX
) ? 2 : (ndp
<= UINT_MAX
? 4 : 6);
317 int dccp_insert_option(struct sock
*sk
, struct sk_buff
*skb
,
318 const unsigned char option
,
319 const void *value
, const unsigned char len
)
323 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
+ len
+ 2 > DCCP_MAX_OPT_LEN
)
326 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= len
+ 2;
328 to
= skb_push(skb
, len
+ 2);
332 memcpy(to
, value
, len
);
336 EXPORT_SYMBOL_GPL(dccp_insert_option
);
338 static int dccp_insert_option_ndp(struct sock
*sk
, struct sk_buff
*skb
)
340 struct dccp_sock
*dp
= dccp_sk(sk
);
341 u64 ndp
= dp
->dccps_ndp_count
;
343 if (dccp_non_data_packet(skb
))
344 ++dp
->dccps_ndp_count
;
346 dp
->dccps_ndp_count
= 0;
350 const int ndp_len
= dccp_ndp_len(ndp
);
351 const int len
= ndp_len
+ 2;
353 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
+ len
> DCCP_MAX_OPT_LEN
)
356 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= len
;
358 ptr
= skb_push(skb
, len
);
359 *ptr
++ = DCCPO_NDP_COUNT
;
361 dccp_encode_value_var(ndp
, ptr
, ndp_len
);
367 static inline int dccp_elapsed_time_len(const u32 elapsed_time
)
369 return elapsed_time
== 0 ? 0 : elapsed_time
<= 0xFFFF ? 2 : 4;
372 int dccp_insert_option_elapsed_time(struct sock
*sk
, struct sk_buff
*skb
,
375 const int elapsed_time_len
= dccp_elapsed_time_len(elapsed_time
);
376 const int len
= 2 + elapsed_time_len
;
379 if (elapsed_time_len
== 0)
382 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
+ len
> DCCP_MAX_OPT_LEN
)
385 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= len
;
387 to
= skb_push(skb
, len
);
388 *to
++ = DCCPO_ELAPSED_TIME
;
391 if (elapsed_time_len
== 2) {
392 const __be16 var16
= htons((u16
)elapsed_time
);
393 memcpy(to
, &var16
, 2);
395 const __be32 var32
= htonl(elapsed_time
);
396 memcpy(to
, &var32
, 4);
402 EXPORT_SYMBOL_GPL(dccp_insert_option_elapsed_time
);
404 int dccp_insert_option_timestamp(struct sock
*sk
, struct sk_buff
*skb
)
406 __be32 now
= htonl(dccp_timestamp());
407 /* yes this will overflow but that is the point as we want a
408 * 10 usec 32 bit timer which mean it wraps every 11.9 hours */
410 return dccp_insert_option(sk
, skb
, DCCPO_TIMESTAMP
, &now
, sizeof(now
));
413 EXPORT_SYMBOL_GPL(dccp_insert_option_timestamp
);
415 static int dccp_insert_option_timestamp_echo(struct dccp_sock
*dp
,
416 struct dccp_request_sock
*dreq
,
421 u32 elapsed_time
, elapsed_time_len
, len
;
424 elapsed_time
= dccp_timestamp() - dreq
->dreq_timestamp_time
;
425 tstamp_echo
= htonl(dreq
->dreq_timestamp_echo
);
426 dreq
->dreq_timestamp_echo
= 0;
428 elapsed_time
= dccp_timestamp() - dp
->dccps_timestamp_time
;
429 tstamp_echo
= htonl(dp
->dccps_timestamp_echo
);
430 dp
->dccps_timestamp_echo
= 0;
433 elapsed_time_len
= dccp_elapsed_time_len(elapsed_time
);
434 len
= 6 + elapsed_time_len
;
436 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
+ len
> DCCP_MAX_OPT_LEN
)
439 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= len
;
441 to
= skb_push(skb
, len
);
442 *to
++ = DCCPO_TIMESTAMP_ECHO
;
445 memcpy(to
, &tstamp_echo
, 4);
448 if (elapsed_time_len
== 2) {
449 const __be16 var16
= htons((u16
)elapsed_time
);
450 memcpy(to
, &var16
, 2);
451 } else if (elapsed_time_len
== 4) {
452 const __be32 var32
= htonl(elapsed_time
);
453 memcpy(to
, &var32
, 4);
459 static int dccp_insert_feat_opt(struct sk_buff
*skb
, u8 type
, u8 feat
,
464 if (DCCP_SKB_CB(skb
)->dccpd_opt_len
+ len
+ 3 > DCCP_MAX_OPT_LEN
) {
465 DCCP_WARN("packet too small for feature %d option!\n", feat
);
469 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= len
+ 3;
471 to
= skb_push(skb
, len
+ 3);
477 memcpy(to
, val
, len
);
479 dccp_pr_debug("%s(%s (%d), ...), length %d\n",
480 dccp_feat_typename(type
),
481 dccp_feat_name(feat
), feat
, len
);
485 static int dccp_insert_options_feat(struct sock
*sk
, struct sk_buff
*skb
)
487 struct dccp_sock
*dp
= dccp_sk(sk
);
488 struct dccp_minisock
*dmsk
= dccp_msk(sk
);
489 struct dccp_opt_pend
*opt
, *next
;
492 /* confirm any options [NN opts] */
493 list_for_each_entry_safe(opt
, next
, &dmsk
->dccpms_conf
, dccpop_node
) {
494 dccp_insert_feat_opt(skb
, opt
->dccpop_type
,
495 opt
->dccpop_feat
, opt
->dccpop_val
,
497 /* fear empty confirms */
499 kfree(opt
->dccpop_val
);
502 INIT_LIST_HEAD(&dmsk
->dccpms_conf
);
504 /* see which features we need to send */
505 list_for_each_entry(opt
, &dmsk
->dccpms_pending
, dccpop_node
) {
506 /* see if we need to send any confirm */
507 if (opt
->dccpop_sc
) {
508 dccp_insert_feat_opt(skb
, opt
->dccpop_type
+ 1,
510 opt
->dccpop_sc
->dccpoc_val
,
511 opt
->dccpop_sc
->dccpoc_len
);
513 BUG_ON(!opt
->dccpop_sc
->dccpoc_val
);
514 kfree(opt
->dccpop_sc
->dccpoc_val
);
515 kfree(opt
->dccpop_sc
);
516 opt
->dccpop_sc
= NULL
;
519 /* any option not confirmed, re-send it */
520 if (!opt
->dccpop_conf
) {
521 dccp_insert_feat_opt(skb
, opt
->dccpop_type
,
522 opt
->dccpop_feat
, opt
->dccpop_val
,
529 * If this is the master listening sock, we don't set a timer on it. It
530 * should be fine because if the dude doesn't receive our RESPONSE
531 * [which will contain the CHANGE] he will send another REQUEST which
532 * will "retrnasmit" the change.
534 if (change
&& dp
->dccps_role
!= DCCP_ROLE_LISTEN
) {
535 dccp_pr_debug("reset feat negotiation timer %p\n", sk
);
537 /* XXX don't reset the timer on re-transmissions. I.e. reset it
538 * only when sending new stuff i guess. Currently the timer
539 * never backs off because on re-transmission it just resets it!
541 inet_csk_reset_xmit_timer(sk
, ICSK_TIME_RETRANS
,
542 inet_csk(sk
)->icsk_rto
, DCCP_RTO_MAX
);
548 /* The length of all options needs to be a multiple of 4 (5.8) */
549 static void dccp_insert_option_padding(struct sk_buff
*skb
)
551 int padding
= DCCP_SKB_CB(skb
)->dccpd_opt_len
% 4;
554 padding
= 4 - padding
;
555 memset(skb_push(skb
, padding
), 0, padding
);
556 DCCP_SKB_CB(skb
)->dccpd_opt_len
+= padding
;
560 int dccp_insert_options(struct sock
*sk
, struct sk_buff
*skb
)
562 struct dccp_sock
*dp
= dccp_sk(sk
);
563 struct dccp_minisock
*dmsk
= dccp_msk(sk
);
565 DCCP_SKB_CB(skb
)->dccpd_opt_len
= 0;
567 if (dmsk
->dccpms_send_ndp_count
&&
568 dccp_insert_option_ndp(sk
, skb
))
571 if (!dccp_packet_without_ack(skb
)) {
572 if (dmsk
->dccpms_send_ack_vector
&&
573 dccp_ackvec_pending(dp
->dccps_hc_rx_ackvec
) &&
574 dccp_insert_option_ackvec(sk
, skb
))
578 if (dp
->dccps_hc_rx_insert_options
) {
579 if (ccid_hc_rx_insert_options(dp
->dccps_hc_rx_ccid
, sk
, skb
))
581 dp
->dccps_hc_rx_insert_options
= 0;
584 /* Feature negotiation */
585 /* Data packets can't do feat negotiation */
586 if (DCCP_SKB_CB(skb
)->dccpd_type
!= DCCP_PKT_DATA
&&
587 DCCP_SKB_CB(skb
)->dccpd_type
!= DCCP_PKT_DATAACK
&&
588 dccp_insert_options_feat(sk
, skb
))
592 * Obtain RTT sample from Request/Response exchange.
593 * This is currently used in CCID 3 initialisation.
595 if (DCCP_SKB_CB(skb
)->dccpd_type
== DCCP_PKT_REQUEST
&&
596 dccp_insert_option_timestamp(sk
, skb
))
599 if (dp
->dccps_timestamp_echo
!= 0 &&
600 dccp_insert_option_timestamp_echo(dp
, NULL
, skb
))
603 dccp_insert_option_padding(skb
);
607 int dccp_insert_options_rsk(struct dccp_request_sock
*dreq
, struct sk_buff
*skb
)
609 DCCP_SKB_CB(skb
)->dccpd_opt_len
= 0;
611 if (dreq
->dreq_timestamp_echo
!= 0 &&
612 dccp_insert_option_timestamp_echo(NULL
, dreq
, skb
))
615 dccp_insert_option_padding(skb
);