[DCCP] options: Fix some aspects of mandatory option processing
[linux-2.6.git] / net / dccp / options.c
1 /*
2  *  net/dccp/options.c
3  *
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>
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 "ackvec.h"
22 #include "ccid.h"
23 #include "dccp.h"
24 #include "feat.h"
25
26 int dccp_feat_default_sequence_window = DCCPF_INITIAL_SEQUENCE_WINDOW;
27 int dccp_feat_default_rx_ccid         = DCCPF_INITIAL_CCID;
28 int dccp_feat_default_tx_ccid         = DCCPF_INITIAL_CCID;
29 int dccp_feat_default_ack_ratio       = DCCPF_INITIAL_ACK_RATIO;
30 int dccp_feat_default_send_ack_vector = DCCPF_INITIAL_SEND_ACK_VECTOR;
31 int dccp_feat_default_send_ndp_count  = DCCPF_INITIAL_SEND_NDP_COUNT;
32
33 void dccp_options_init(struct dccp_options *dccpo)
34 {
35         dccpo->dccpo_sequence_window = dccp_feat_default_sequence_window;
36         dccpo->dccpo_rx_ccid         = dccp_feat_default_rx_ccid;
37         dccpo->dccpo_tx_ccid         = dccp_feat_default_tx_ccid;
38         dccpo->dccpo_ack_ratio       = dccp_feat_default_ack_ratio;
39         dccpo->dccpo_send_ack_vector = dccp_feat_default_send_ack_vector;
40         dccpo->dccpo_send_ndp_count  = dccp_feat_default_send_ndp_count;
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);
62 #ifdef CONFIG_IP_DCCP_DEBUG
63         const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ?
64                                         "CLIENT rx opt: " : "server rx opt: ";
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;
70         const unsigned char *opt_end = (unsigned char *)dh +
71                                         (dh->dccph_doff * 4);
72         struct dccp_options_received *opt_recv = &dp->dccps_options_received;
73         unsigned char opt, len;
74         unsigned char *value;
75         u32 elapsed_time;
76         int rc;
77         int mandatory = 0;
78
79         memset(opt_recv, 0, sizeof(*opt_recv));
80
81         while (opt_ptr != opt_end) {
82                 opt   = *opt_ptr++;
83                 len   = 0;
84                 value = NULL;
85
86                 /* Check if this isn't a single byte option */
87                 if (opt > DCCPO_MAX_RESERVED) {
88                         if (opt_ptr == opt_end)
89                                 goto out_invalid_option;
90
91                         len = *opt_ptr++;
92                         if (len < 3)
93                                 goto out_invalid_option;
94                         /*
95                          * Remove the type and len fields, leaving
96                          * just the value size
97                          */
98                         len     -= 2;
99                         value   = opt_ptr;
100                         opt_ptr += len;
101
102                         if (opt_ptr > opt_end)
103                                 goto out_invalid_option;
104                 }
105
106                 switch (opt) {
107                 case DCCPO_PADDING:
108                         break;
109                 case DCCPO_MANDATORY:
110                         if (mandatory)
111                                 goto out_invalid_option;
112                         if (pkt_type != DCCP_PKT_DATA)
113                                 mandatory = 1;
114                         break;
115                 case DCCPO_NDP_COUNT:
116                         if (len > 3)
117                                 goto out_invalid_option;
118
119                         opt_recv->dccpor_ndp = dccp_decode_value_var(value, len);
120                         dccp_pr_debug("%sNDP count=%d\n", debug_prefix,
121                                       opt_recv->dccpor_ndp);
122                         break;
123                 case DCCPO_CHANGE_L:
124                         /* fall through */
125                 case DCCPO_CHANGE_R:
126                         if (len < 2)
127                                 goto out_invalid_option;
128                         rc = dccp_feat_change_recv(sk, opt, *value, value + 1,
129                                                    len - 1);
130                         /*
131                          * When there is a change error, change_recv is
132                          * responsible for dealing with it.  i.e. reply with an
133                          * empty confirm.
134                          * If the change was mandatory, then we need to die.
135                          */
136                         if (rc && mandatory)
137                                 goto out_invalid_option;
138                         break;
139                 case DCCPO_CONFIRM_L:
140                         /* fall through */
141                 case DCCPO_CONFIRM_R:
142                         if (len < 2)
143                                 goto out_invalid_option;
144                         if (dccp_feat_confirm_recv(sk, opt, *value,
145                                                    value + 1, len - 1))
146                                 goto out_invalid_option;
147                         break;
148                 case DCCPO_ACK_VECTOR_0:
149                 case DCCPO_ACK_VECTOR_1:
150                         if (pkt_type == DCCP_PKT_DATA)
151                                 continue;
152
153                         if (dp->dccps_options.dccpo_send_ack_vector &&
154                             dccp_ackvec_parse(sk, skb, opt, value, len))
155                                 goto out_invalid_option;
156                         break;
157                 case DCCPO_TIMESTAMP:
158                         if (len != 4)
159                                 goto out_invalid_option;
160
161                         opt_recv->dccpor_timestamp = ntohl(*(__be32 *)value);
162
163                         dp->dccps_timestamp_echo = opt_recv->dccpor_timestamp;
164                         dccp_timestamp(sk, &dp->dccps_timestamp_time);
165
166                         dccp_pr_debug("%sTIMESTAMP=%u, ackno=%llu\n",
167                                       debug_prefix, opt_recv->dccpor_timestamp,
168                                       (unsigned long long)
169                                       DCCP_SKB_CB(skb)->dccpd_ack_seq);
170                         break;
171                 case DCCPO_TIMESTAMP_ECHO:
172                         if (len != 4 && len != 6 && len != 8)
173                                 goto out_invalid_option;
174
175                         opt_recv->dccpor_timestamp_echo = ntohl(*(__be32 *)value);
176
177                         dccp_pr_debug("%sTIMESTAMP_ECHO=%u, len=%d, ackno=%llu, ",
178                                       debug_prefix,
179                                       opt_recv->dccpor_timestamp_echo,
180                                       len + 2,
181                                       (unsigned long long)
182                                       DCCP_SKB_CB(skb)->dccpd_ack_seq);
183
184
185                         if (len == 4)
186                                 break;
187
188                         if (len == 6)
189                                 elapsed_time = ntohs(*(__be16 *)(value + 4));
190                         else
191                                 elapsed_time = ntohl(*(__be32 *)(value + 4));
192
193                         /* Give precedence to the biggest ELAPSED_TIME */
194                         if (elapsed_time > opt_recv->dccpor_elapsed_time)
195                                 opt_recv->dccpor_elapsed_time = elapsed_time;
196                         break;
197                 case DCCPO_ELAPSED_TIME:
198                         if (len != 2 && len != 4)
199                                 goto out_invalid_option;
200
201                         if (pkt_type == DCCP_PKT_DATA)
202                                 continue;
203
204                         if (len == 2)
205                                 elapsed_time = ntohs(*(__be16 *)value);
206                         else
207                                 elapsed_time = ntohl(*(__be32 *)value);
208
209                         if (elapsed_time > opt_recv->dccpor_elapsed_time)
210                                 opt_recv->dccpor_elapsed_time = elapsed_time;
211
212                         dccp_pr_debug("%sELAPSED_TIME=%d\n", debug_prefix,
213                                       elapsed_time);
214                         break;
215                         /*
216                          * From draft-ietf-dccp-spec-11.txt:
217                          *
218                          *      Option numbers 128 through 191 are for
219                          *      options sent from the HC-Sender to the
220                          *      HC-Receiver; option numbers 192 through 255
221                          *      are for options sent from the HC-Receiver to
222                          *      the HC-Sender.
223                          */
224                 case 128 ... 191: {
225                         const u16 idx = value - options;
226
227                         if (ccid_hc_rx_parse_options(dp->dccps_hc_rx_ccid, sk,
228                                                      opt, len, idx,
229                                                      value) != 0)
230                                 goto out_invalid_option;
231                 }
232                         break;
233                 case 192 ... 255: {
234                         const u16 idx = value - options;
235
236                         if (ccid_hc_tx_parse_options(dp->dccps_hc_tx_ccid, sk,
237                                                      opt, len, idx,
238                                                      value) != 0)
239                                 goto out_invalid_option;
240                 }
241                         break;
242                 default:
243                         pr_info("DCCP(%p): option %d(len=%d) not "
244                                 "implemented, ignoring\n",
245                                 sk, opt, len);
246                         break;
247                 }
248
249                 if (opt != DCCPO_MANDATORY)
250                         mandatory = 0;
251         }
252
253         /* mandatory was the last byte in option list -> reset connection */
254         if (mandatory)
255                 goto out_invalid_option;
256
257         return 0;
258
259 out_invalid_option:
260         DCCP_INC_STATS_BH(DCCP_MIB_INVALIDOPT);
261         DCCP_SKB_CB(skb)->dccpd_reset_code = DCCP_RESET_CODE_OPTION_ERROR;
262         pr_info("DCCP(%p): invalid option %d, len=%d\n", sk, opt, len);
263         return -1;
264 }
265
266 EXPORT_SYMBOL_GPL(dccp_parse_options);
267
268 static void dccp_encode_value_var(const u32 value, unsigned char *to,
269                                   const unsigned int len)
270 {
271         if (len > 3)
272                 *to++ = (value & 0xFF000000) >> 24;
273         if (len > 2)
274                 *to++ = (value & 0xFF0000) >> 16;
275         if (len > 1)
276                 *to++ = (value & 0xFF00) >> 8;
277         if (len > 0)
278                 *to++ = (value & 0xFF);
279 }
280
281 static inline int dccp_ndp_len(const int ndp)
282 {
283         return likely(ndp <= 0xFF) ? 1 : ndp <= 0xFFFF ? 2 : 3;
284 }
285
286 void dccp_insert_option(struct sock *sk, struct sk_buff *skb,
287                         const unsigned char option,
288                         const void *value, const unsigned char len)
289 {
290         unsigned char *to;
291
292         if (DCCP_SKB_CB(skb)->dccpd_opt_len + len + 2 > DCCP_MAX_OPT_LEN) {
293                 LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to insert "
294                                "%d option!\n", option);
295                 return;
296         }
297
298         DCCP_SKB_CB(skb)->dccpd_opt_len += len + 2;
299
300         to    = skb_push(skb, len + 2);
301         *to++ = option;
302         *to++ = len + 2;
303
304         memcpy(to, value, len);
305 }
306
307 EXPORT_SYMBOL_GPL(dccp_insert_option);
308
309 static void dccp_insert_option_ndp(struct sock *sk, struct sk_buff *skb)
310 {
311         struct dccp_sock *dp = dccp_sk(sk);
312         int ndp = dp->dccps_ndp_count;
313
314         if (dccp_non_data_packet(skb))
315                 ++dp->dccps_ndp_count;
316         else
317                 dp->dccps_ndp_count = 0;
318
319         if (ndp > 0) {
320                 unsigned char *ptr;
321                 const int ndp_len = dccp_ndp_len(ndp);
322                 const int len = ndp_len + 2;
323
324                 if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN)
325                         return;
326
327                 DCCP_SKB_CB(skb)->dccpd_opt_len += len;
328
329                 ptr = skb_push(skb, len);
330                 *ptr++ = DCCPO_NDP_COUNT;
331                 *ptr++ = len;
332                 dccp_encode_value_var(ndp, ptr, ndp_len);
333         }
334 }
335
336 static inline int dccp_elapsed_time_len(const u32 elapsed_time)
337 {
338         return elapsed_time == 0 ? 0 : elapsed_time <= 0xFFFF ? 2 : 4;
339 }
340
341 void dccp_insert_option_elapsed_time(struct sock *sk,
342                                      struct sk_buff *skb,
343                                      u32 elapsed_time)
344 {
345 #ifdef CONFIG_IP_DCCP_DEBUG
346         struct dccp_sock *dp = dccp_sk(sk);
347         const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ?
348                                         "CLIENT TX opt: " : "server TX opt: ";
349 #endif
350         const int elapsed_time_len = dccp_elapsed_time_len(elapsed_time);
351         const int len = 2 + elapsed_time_len;
352         unsigned char *to;
353
354         if (elapsed_time_len == 0)
355                 return;
356
357         if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) {
358                 LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to "
359                                          "insert elapsed time!\n");
360                 return;
361         }
362
363         DCCP_SKB_CB(skb)->dccpd_opt_len += len;
364
365         to    = skb_push(skb, len);
366         *to++ = DCCPO_ELAPSED_TIME;
367         *to++ = len;
368
369         if (elapsed_time_len == 2) {
370                 const __be16 var16 = htons((u16)elapsed_time);
371                 memcpy(to, &var16, 2);
372         } else {
373                 const __be32 var32 = htonl(elapsed_time);
374                 memcpy(to, &var32, 4);
375         }
376
377         dccp_pr_debug("%sELAPSED_TIME=%u, len=%d, seqno=%llu\n",
378                       debug_prefix, elapsed_time,
379                       len,
380                       (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq);
381 }
382
383 EXPORT_SYMBOL_GPL(dccp_insert_option_elapsed_time);
384
385 void dccp_timestamp(const struct sock *sk, struct timeval *tv)
386 {
387         const struct dccp_sock *dp = dccp_sk(sk);
388
389         do_gettimeofday(tv);
390         tv->tv_sec  -= dp->dccps_epoch.tv_sec;
391         tv->tv_usec -= dp->dccps_epoch.tv_usec;
392
393         while (tv->tv_usec < 0) {
394                 tv->tv_sec--;
395                 tv->tv_usec += USEC_PER_SEC;
396         }
397 }
398
399 EXPORT_SYMBOL_GPL(dccp_timestamp);
400
401 void dccp_insert_option_timestamp(struct sock *sk, struct sk_buff *skb)
402 {
403         struct timeval tv;
404         __be32 now;
405
406         dccp_timestamp(sk, &tv);
407         now = htonl(timeval_usecs(&tv) / 10);
408         /* yes this will overflow but that is the point as we want a
409          * 10 usec 32 bit timer which mean it wraps every 11.9 hours */
410
411         dccp_insert_option(sk, skb, DCCPO_TIMESTAMP, &now, sizeof(now));
412 }
413
414 EXPORT_SYMBOL_GPL(dccp_insert_option_timestamp);
415
416 static void dccp_insert_option_timestamp_echo(struct sock *sk,
417                                               struct sk_buff *skb)
418 {
419         struct dccp_sock *dp = dccp_sk(sk);
420 #ifdef CONFIG_IP_DCCP_DEBUG
421         const char *debug_prefix = dp->dccps_role == DCCP_ROLE_CLIENT ?
422                                         "CLIENT TX opt: " : "server TX opt: ";
423 #endif
424         struct timeval now;
425         __be32 tstamp_echo;
426         u32 elapsed_time;
427         int len, elapsed_time_len;
428         unsigned char *to;
429
430         dccp_timestamp(sk, &now);
431         elapsed_time = timeval_delta(&now, &dp->dccps_timestamp_time) / 10;
432         elapsed_time_len = dccp_elapsed_time_len(elapsed_time);
433         len = 6 + elapsed_time_len;
434
435         if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN) {
436                 LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small to insert "
437                                          "timestamp echo!\n");
438                 return;
439         }
440
441         DCCP_SKB_CB(skb)->dccpd_opt_len += len;
442
443         to    = skb_push(skb, len);
444         *to++ = DCCPO_TIMESTAMP_ECHO;
445         *to++ = len;
446
447         tstamp_echo = htonl(dp->dccps_timestamp_echo);
448         memcpy(to, &tstamp_echo, 4);
449         to += 4;
450
451         if (elapsed_time_len == 2) {
452                 const __be16 var16 = htons((u16)elapsed_time);
453                 memcpy(to, &var16, 2);
454         } else if (elapsed_time_len == 4) {
455                 const __be32 var32 = htonl(elapsed_time);
456                 memcpy(to, &var32, 4);
457         }
458
459         dccp_pr_debug("%sTIMESTAMP_ECHO=%u, len=%d, seqno=%llu\n",
460                       debug_prefix, dp->dccps_timestamp_echo,
461                       len,
462                       (unsigned long long) DCCP_SKB_CB(skb)->dccpd_seq);
463
464         dp->dccps_timestamp_echo = 0;
465         dp->dccps_timestamp_time.tv_sec = 0;
466         dp->dccps_timestamp_time.tv_usec = 0;
467 }
468
469 static int dccp_insert_feat_opt(struct sk_buff *skb, u8 type, u8 feat,
470                                 u8 *val, u8 len)
471 {
472         u8 *to;
473
474         if (DCCP_SKB_CB(skb)->dccpd_opt_len + len + 3 > DCCP_MAX_OPT_LEN) {
475                 LIMIT_NETDEBUG(KERN_INFO "DCCP: packet too small"
476                                " to insert feature %d option!\n", feat);
477                 return -1;
478         }
479
480         DCCP_SKB_CB(skb)->dccpd_opt_len += len + 3;
481
482         to    = skb_push(skb, len + 3);
483         *to++ = type;
484         *to++ = len + 3;
485         *to++ = feat;
486
487         if (len)
488                 memcpy(to, val, len);
489         dccp_pr_debug("option %d feat %d len %d\n", type, feat, len);
490
491         return 0;
492 }
493
494 static void dccp_insert_feat(struct sock *sk, struct sk_buff *skb)
495 {
496         struct dccp_sock *dp = dccp_sk(sk);
497         struct dccp_opt_pend *opt, *next;
498         int change = 0;
499
500         /* confirm any options [NN opts] */
501         list_for_each_entry_safe(opt, next, &dp->dccps_options.dccpo_conf,
502                                  dccpop_node) {
503                 dccp_insert_feat_opt(skb, opt->dccpop_type,
504                                      opt->dccpop_feat, opt->dccpop_val,
505                                      opt->dccpop_len);
506                 /* fear empty confirms */
507                 if (opt->dccpop_val)
508                         kfree(opt->dccpop_val);
509                 kfree(opt);
510         }
511         INIT_LIST_HEAD(&dp->dccps_options.dccpo_conf);
512
513         /* see which features we need to send */
514         list_for_each_entry(opt, &dp->dccps_options.dccpo_pending,
515                             dccpop_node) {
516                 /* see if we need to send any confirm */
517                 if (opt->dccpop_sc) {
518                         dccp_insert_feat_opt(skb, opt->dccpop_type + 1,
519                                              opt->dccpop_feat,
520                                              opt->dccpop_sc->dccpoc_val,
521                                              opt->dccpop_sc->dccpoc_len);
522
523                         BUG_ON(!opt->dccpop_sc->dccpoc_val);
524                         kfree(opt->dccpop_sc->dccpoc_val);
525                         kfree(opt->dccpop_sc);
526                         opt->dccpop_sc = NULL;
527                 }
528
529                 /* any option not confirmed, re-send it */
530                 if (!opt->dccpop_conf) {
531                         dccp_insert_feat_opt(skb, opt->dccpop_type,
532                                              opt->dccpop_feat, opt->dccpop_val,
533                                              opt->dccpop_len);
534                         change++;
535                 }
536         }
537
538         /* Retransmit timer.
539          * If this is the master listening sock, we don't set a timer on it.  It
540          * should be fine because if the dude doesn't receive our RESPONSE
541          * [which will contain the CHANGE] he will send another REQUEST which
542          * will "retrnasmit" the change.
543          */
544         if (change && dp->dccps_role != DCCP_ROLE_LISTEN) {
545                 dccp_pr_debug("reset feat negotiation timer %p\n", sk);
546
547                 /* XXX don't reset the timer on re-transmissions.  I.e. reset it
548                  * only when sending new stuff i guess.  Currently the timer
549                  * never backs off because on re-transmission it just resets it!
550                  */
551                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
552                                           inet_csk(sk)->icsk_rto, DCCP_RTO_MAX);
553         }
554 }
555
556 void dccp_insert_options(struct sock *sk, struct sk_buff *skb)
557 {
558         struct dccp_sock *dp = dccp_sk(sk);
559
560         DCCP_SKB_CB(skb)->dccpd_opt_len = 0;
561
562         if (dp->dccps_options.dccpo_send_ndp_count)
563                 dccp_insert_option_ndp(sk, skb);
564
565         if (!dccp_packet_without_ack(skb)) {
566                 if (dp->dccps_options.dccpo_send_ack_vector &&
567                     dccp_ackvec_pending(dp->dccps_hc_rx_ackvec))
568                         dccp_insert_option_ackvec(sk, skb);
569                 if (dp->dccps_timestamp_echo != 0)
570                         dccp_insert_option_timestamp_echo(sk, skb);
571         }
572
573         if (dp->dccps_hc_rx_insert_options) {
574                 ccid_hc_rx_insert_options(dp->dccps_hc_rx_ccid, sk, skb);
575                 dp->dccps_hc_rx_insert_options = 0;
576         }
577         if (dp->dccps_hc_tx_insert_options) {
578                 ccid_hc_tx_insert_options(dp->dccps_hc_tx_ccid, sk, skb);
579                 dp->dccps_hc_tx_insert_options = 0;
580         }
581
582         /* Feature negotiation */
583         switch(DCCP_SKB_CB(skb)->dccpd_type) {
584                 /* Data packets can't do feat negotiation */
585         case DCCP_PKT_DATA:
586         case DCCP_PKT_DATAACK:
587                 break;
588         default:
589                 dccp_insert_feat(sk, skb);
590                 break;
591         }
592
593         /* XXX: insert other options when appropriate */
594
595         if (DCCP_SKB_CB(skb)->dccpd_opt_len != 0) {
596                 /* The length of all options has to be a multiple of 4 */
597                 int padding = DCCP_SKB_CB(skb)->dccpd_opt_len % 4;
598
599                 if (padding != 0) {
600                         padding = 4 - padding;
601                         memset(skb_push(skb, padding), 0, padding);
602                         DCCP_SKB_CB(skb)->dccpd_opt_len += padding;
603                 }
604         }
605 }