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