git.stricted.de - GitHub/MotorolaMobilityLLC/kernel-slsi.git/blob

1 /*

2 * net/dccp/options.c

3 *

4 * An implementation of the DCCP protocol

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/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>

21 #include "ackvec.h"

22 #include "ccid.h"

23 #include "dccp.h"

24 #include "feat.h"

26 u64 dccp_decode_value_var(const u8 *bf, const u8 len)

27 {

28 u64 value = 0;

30 if (len >= DCCP_OPTVAL_MAXLEN)

31 value += ((u64)*bf++) << 40;

32 if (len > 4)

33 value += ((u64)*bf++) << 32;

34 if (len > 3)

35 value += ((u64)*bf++) << 24;

36 if (len > 2)

37 value += ((u64)*bf++) << 16;

38 if (len > 1)

39 value += ((u64)*bf++) << 8;

40 if (len > 0)

41 value += *bf;

43 return value;

44 }

46 /**

47 * dccp_parse_options - Parse DCCP options present in @skb

48 * @sk: client|server|listening dccp socket (when @dreq != NULL)

49 * @dreq: request socket to use during connection setup, or NULL

50 */

51 int dccp_parse_options(struct sock *sk, struct dccp_request_sock *dreq,

52 struct sk_buff *skb)

53 {

54 struct dccp_sock *dp = dccp_sk(sk);

55 const struct dccp_hdr *dh = dccp_hdr(skb);

56 const u8 pkt_type = DCCP_SKB_CB(skb)->dccpd_type;

57 u64 ackno = DCCP_SKB_CB(skb)->dccpd_ack_seq;

58 unsigned char *options = (unsigned char *)dh + dccp_hdr_len(skb);

59 unsigned char *opt_ptr = options;

60 const unsigned char *opt_end = (unsigned char *)dh +

61 (dh->dccph_doff * 4);

62 struct dccp_options_received *opt_recv = &dp->dccps_options_received;

63 unsigned char opt, len;

64 unsigned char *uninitialized_var(value);

65 u32 elapsed_time;

66 __be32 opt_val;

67 int rc;

68 int mandatory = 0;

70 memset(opt_recv, 0, sizeof(*opt_recv));

72 opt = len = 0;

73 while (opt_ptr != opt_end) {

74 opt = *opt_ptr++;

75 len = 0;

76 value = NULL;

78 /* Check if this isn't a single byte option */

79 if (opt > DCCPO_MAX_RESERVED) {

80 if (opt_ptr == opt_end)

81 goto out_nonsensical_length;

83 len = *opt_ptr++;

84 if (len < 2)

85 goto out_nonsensical_length;

86 /*

87 * Remove the type and len fields, leaving

88 * just the value size

89 */

90 len -= 2;

91 value = opt_ptr;

92 opt_ptr += len;

94 if (opt_ptr > opt_end)

95 goto out_nonsensical_length;

96 }

98 /*

99 * CCID-specific options are ignored during connection setup, as

100 * negotiation may still be in progress (see RFC 4340, 10.3).

101 * The same applies to Ack Vectors, as these depend on the CCID.

102 */

103 if (dreq != NULL && (opt >= DCCPO_MIN_RX_CCID_SPECIFIC ||

104 opt == DCCPO_ACK_VECTOR_0 || opt == DCCPO_ACK_VECTOR_1))

105 goto ignore_option;

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 > 6)

118 goto out_invalid_option;

119

120 opt_recv->dccpor_ndp = dccp_decode_value_var(value, len);

121 dccp_pr_debug("%s opt: NDP count=%llu\n", dccp_role(sk),

122 (unsigned long long)opt_recv->dccpor_ndp);

123 break;

124 case DCCPO_CHANGE_L ... DCCPO_CONFIRM_R:

125 if (pkt_type == DCCP_PKT_DATA) /* RFC 4340, 6 */

126 break;

127 rc = dccp_feat_parse_options(sk, dreq, mandatory, opt,

128 *value, value + 1, len - 1);

129 if (rc)

130 goto out_featneg_failed;

131 break;

132 case DCCPO_ACK_VECTOR_0:

133 case DCCPO_ACK_VECTOR_1:

134 if (dccp_packet_without_ack(skb)) /* RFC 4340, 11.4 */

135 break;

136 if (dp->dccps_hc_rx_ackvec != NULL &&

137 dccp_ackvec_parse(sk, skb, &ackno, opt, value, len))

138 goto out_invalid_option;

139 break;

140 case DCCPO_TIMESTAMP:

141 if (len != 4)

142 goto out_invalid_option;

143 /*

144 * RFC 4340 13.1: "The precise time corresponding to

145 * Timestamp Value zero is not specified". We use

146 * zero to indicate absence of a meaningful timestamp.

147 */

148 opt_val = get_unaligned((__be32 *)value);

149 if (unlikely(opt_val == 0)) {

150 DCCP_WARN("Timestamp with zero value\n");

151 break;

152 }

153

154 if (dreq != NULL) {

155 dreq->dreq_timestamp_echo = ntohl(opt_val);

156 dreq->dreq_timestamp_time = dccp_timestamp();

157 } else {

158 opt_recv->dccpor_timestamp =

159 dp->dccps_timestamp_echo = ntohl(opt_val);

160 dp->dccps_timestamp_time = dccp_timestamp();

161 }

162 dccp_pr_debug("%s rx opt: TIMESTAMP=%u, ackno=%llu\n",

163 dccp_role(sk), ntohl(opt_val),

164 (unsigned long long)

165 DCCP_SKB_CB(skb)->dccpd_ack_seq);

166 break;

167 case DCCPO_TIMESTAMP_ECHO:

168 if (len != 4 && len != 6 && len != 8)

169 goto out_invalid_option;

170

171 opt_val = get_unaligned((__be32 *)value);

172 opt_recv->dccpor_timestamp_echo = ntohl(opt_val);

173

174 dccp_pr_debug("%s rx opt: TIMESTAMP_ECHO=%u, len=%d, "

175 "ackno=%llu", dccp_role(sk),

176 opt_recv->dccpor_timestamp_echo,

177 len + 2,

178 (unsigned long long)

179 DCCP_SKB_CB(skb)->dccpd_ack_seq);

180

181 value += 4;

182

183 if (len == 4) { /* no elapsed time included */

184 dccp_pr_debug_cat("\n");

185 break;

186 }

187

188 if (len == 6) { /* 2-byte elapsed time */

189 __be16 opt_val2 = get_unaligned((__be16 *)value);

190 elapsed_time = ntohs(opt_val2);

191 } else { /* 4-byte elapsed time */

192 opt_val = get_unaligned((__be32 *)value);

193 elapsed_time = ntohl(opt_val);

194 }

195

196 dccp_pr_debug_cat(", ELAPSED_TIME=%u\n", elapsed_time);

197

198 /* Give precedence to the biggest ELAPSED_TIME */

199 if (elapsed_time > opt_recv->dccpor_elapsed_time)

200 opt_recv->dccpor_elapsed_time = elapsed_time;

201 break;

202 case DCCPO_ELAPSED_TIME:

203 if (dccp_packet_without_ack(skb)) /* RFC 4340, 13.2 */

204 break;

205

206 if (len == 2) {

207 __be16 opt_val2 = get_unaligned((__be16 *)value);

208 elapsed_time = ntohs(opt_val2);

209 } else if (len == 4) {

210 opt_val = get_unaligned((__be32 *)value);

211 elapsed_time = ntohl(opt_val);

212 } else {

213 goto out_invalid_option;

214 }

215

216 if (elapsed_time > opt_recv->dccpor_elapsed_time)

217 opt_recv->dccpor_elapsed_time = elapsed_time;

218

219 dccp_pr_debug("%s rx opt: ELAPSED_TIME=%d\n",

220 dccp_role(sk), elapsed_time);

221 break;

222 case DCCPO_MIN_RX_CCID_SPECIFIC ... DCCPO_MAX_RX_CCID_SPECIFIC:

223 if (ccid_hc_rx_parse_options(dp->dccps_hc_rx_ccid, sk,

224 pkt_type, opt, value, len))

225 goto out_invalid_option;

226 break;

227 case DCCPO_MIN_TX_CCID_SPECIFIC ... DCCPO_MAX_TX_CCID_SPECIFIC:

228 if (ccid_hc_tx_parse_options(dp->dccps_hc_tx_ccid, sk,

229 pkt_type, opt, value, len))

230 goto out_invalid_option;

231 break;

232 default:

233 DCCP_CRIT("DCCP(%p): option %d(len=%d) not "

234 "implemented, ignoring", sk, opt, len);

235 break;

236 }

237 ignore_option:

238 if (opt != DCCPO_MANDATORY)

239 mandatory = 0;

240 }

241

242 /* mandatory was the last byte in option list -> reset connection */

243 if (mandatory)

244 goto out_invalid_option;

245

246 out_nonsensical_length:

247 /* RFC 4340, 5.8: ignore option and all remaining option space */

248 return 0;

249

250 out_invalid_option:

251 DCCP_INC_STATS_BH(DCCP_MIB_INVALIDOPT);

252 rc = DCCP_RESET_CODE_OPTION_ERROR;

253 out_featneg_failed:

254 DCCP_WARN("DCCP(%p): Option %d (len=%d) error=%u\n", sk, opt, len, rc);

255 DCCP_SKB_CB(skb)->dccpd_reset_code = rc;

256 DCCP_SKB_CB(skb)->dccpd_reset_data[0] = opt;

257 DCCP_SKB_CB(skb)->dccpd_reset_data[1] = len > 0 ? value[0] : 0;

258 DCCP_SKB_CB(skb)->dccpd_reset_data[2] = len > 1 ? value[1] : 0;

259 return -1;

260 }

261

262 EXPORT_SYMBOL_GPL(dccp_parse_options);

263

264 void dccp_encode_value_var(const u64 value, u8 *to, const u8 len)

265 {

266 if (len >= DCCP_OPTVAL_MAXLEN)

267 *to++ = (value & 0xFF0000000000ull) >> 40;

268 if (len > 4)

269 *to++ = (value & 0xFF00000000ull) >> 32;

270 if (len > 3)

271 *to++ = (value & 0xFF000000) >> 24;

272 if (len > 2)

273 *to++ = (value & 0xFF0000) >> 16;

274 if (len > 1)

275 *to++ = (value & 0xFF00) >> 8;

276 if (len > 0)

277 *to++ = (value & 0xFF);

278 }

279

280 static inline u8 dccp_ndp_len(const u64 ndp)

281 {

282 if (likely(ndp <= 0xFF))

283 return 1;

284 return likely(ndp <= USHRT_MAX) ? 2 : (ndp <= UINT_MAX ? 4 : 6);

285 }

286

287 int dccp_insert_option(struct sk_buff *skb, 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 return -1;

294

295 DCCP_SKB_CB(skb)->dccpd_opt_len += len + 2;

296

297 to = skb_push(skb, len + 2);

298 *to++ = option;

299 *to++ = len + 2;

300

301 memcpy(to, value, len);

302 return 0;

303 }

304

305 EXPORT_SYMBOL_GPL(dccp_insert_option);

306

307 static int dccp_insert_option_ndp(struct sock *sk, struct sk_buff *skb)

308 {

309 struct dccp_sock *dp = dccp_sk(sk);

310 u64 ndp = dp->dccps_ndp_count;

311

312 if (dccp_non_data_packet(skb))

313 ++dp->dccps_ndp_count;

314 else

315 dp->dccps_ndp_count = 0;

316

317 if (ndp > 0) {

318 unsigned char *ptr;

319 const int ndp_len = dccp_ndp_len(ndp);

320 const int len = ndp_len + 2;

321

322 if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN)

323 return -1;

324

325 DCCP_SKB_CB(skb)->dccpd_opt_len += len;

326

327 ptr = skb_push(skb, len);

328 *ptr++ = DCCPO_NDP_COUNT;

329 *ptr++ = len;

330 dccp_encode_value_var(ndp, ptr, ndp_len);

331 }

332

333 return 0;

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 int dccp_insert_option_elapsed_time(struct sk_buff *skb, u32 elapsed_time)

342 {

343 const int elapsed_time_len = dccp_elapsed_time_len(elapsed_time);

344 const int len = 2 + elapsed_time_len;

345 unsigned char *to;

346

347 if (elapsed_time_len == 0)

348 return 0;

349

350 if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN)

351 return -1;

352

353 DCCP_SKB_CB(skb)->dccpd_opt_len += len;

354

355 to = skb_push(skb, len);

356 *to++ = DCCPO_ELAPSED_TIME;

357 *to++ = len;

358

359 if (elapsed_time_len == 2) {

360 const __be16 var16 = htons((u16)elapsed_time);

361 memcpy(to, &var16, 2);

362 } else {

363 const __be32 var32 = htonl(elapsed_time);

364 memcpy(to, &var32, 4);

365 }

366

367 return 0;

368 }

369

370 EXPORT_SYMBOL_GPL(dccp_insert_option_elapsed_time);

371

372 int dccp_insert_option_timestamp(struct sk_buff *skb)

373 {

374 __be32 now = htonl(dccp_timestamp());

375 /* yes this will overflow but that is the point as we want a

376 * 10 usec 32 bit timer which mean it wraps every 11.9 hours */

377

378 return dccp_insert_option(skb, DCCPO_TIMESTAMP, &now, sizeof(now));

379 }

380

381 EXPORT_SYMBOL_GPL(dccp_insert_option_timestamp);

382

383 static int dccp_insert_option_timestamp_echo(struct dccp_sock *dp,

384 struct dccp_request_sock *dreq,

385 struct sk_buff *skb)

386 {

387 __be32 tstamp_echo;

388 unsigned char *to;

389 u32 elapsed_time, elapsed_time_len, len;

390

391 if (dreq != NULL) {

392 elapsed_time = dccp_timestamp() - dreq->dreq_timestamp_time;

393 tstamp_echo = htonl(dreq->dreq_timestamp_echo);

394 dreq->dreq_timestamp_echo = 0;

395 } else {

396 elapsed_time = dccp_timestamp() - dp->dccps_timestamp_time;

397 tstamp_echo = htonl(dp->dccps_timestamp_echo);

398 dp->dccps_timestamp_echo = 0;

399 }

400

401 elapsed_time_len = dccp_elapsed_time_len(elapsed_time);

402 len = 6 + elapsed_time_len;

403

404 if (DCCP_SKB_CB(skb)->dccpd_opt_len + len > DCCP_MAX_OPT_LEN)

405 return -1;

406

407 DCCP_SKB_CB(skb)->dccpd_opt_len += len;

408

409 to = skb_push(skb, len);

410 *to++ = DCCPO_TIMESTAMP_ECHO;

411 *to++ = len;

412

413 memcpy(to, &tstamp_echo, 4);

414 to += 4;

415

416 if (elapsed_time_len == 2) {

417 const __be16 var16 = htons((u16)elapsed_time);

418 memcpy(to, &var16, 2);

419 } else if (elapsed_time_len == 4) {

420 const __be32 var32 = htonl(elapsed_time);

421 memcpy(to, &var32, 4);

422 }

423

424 return 0;

425 }

426

427 /**

428 * dccp_insert_option_mandatory - Mandatory option (5.8.2)

429 * Note that since we are using skb_push, this function needs to be called

430 * _after_ inserting the option it is supposed to influence (stack order).

431 */

432 int dccp_insert_option_mandatory(struct sk_buff *skb)

433 {

434 if (DCCP_SKB_CB(skb)->dccpd_opt_len >= DCCP_MAX_OPT_LEN)

435 return -1;

436

437 DCCP_SKB_CB(skb)->dccpd_opt_len++;

438 *skb_push(skb, 1) = DCCPO_MANDATORY;

439 return 0;

440 }

441

442 /**

443 * dccp_insert_fn_opt - Insert single Feature-Negotiation option into @skb

444 * @type: %DCCPO_CHANGE_L, %DCCPO_CHANGE_R, %DCCPO_CONFIRM_L, %DCCPO_CONFIRM_R

445 * @feat: one out of %dccp_feature_numbers

446 * @val: NN value or SP array (preferred element first) to copy

447 * @len: true length of @val in bytes (excluding first element repetition)

448 * @repeat_first: whether to copy the first element of @val twice

449 * The last argument is used to construct Confirm options, where the preferred

450 * value and the preference list appear separately (RFC 4340, 6.3.1). Preference

451 * lists are kept such that the preferred entry is always first, so we only need

452 * to copy twice, and avoid the overhead of cloning into a bigger array.

453 */

454 int dccp_insert_fn_opt(struct sk_buff *skb, u8 type, u8 feat,

455 u8 *val, u8 len, bool repeat_first)

456 {

457 u8 tot_len, *to;

458

459 /* take the `Feature' field and possible repetition into account */

460 if (len > (DCCP_SINGLE_OPT_MAXLEN - 2)) {

461 DCCP_WARN("length %u for feature %u too large\n", len, feat);

462 return -1;

463 }

464

465 if (unlikely(val == NULL || len == 0))

466 len = repeat_first = 0;

467 tot_len = 3 + repeat_first + len;

468

469 if (DCCP_SKB_CB(skb)->dccpd_opt_len + tot_len > DCCP_MAX_OPT_LEN) {

470 DCCP_WARN("packet too small for feature %d option!\n", feat);

471 return -1;

472 }

473 DCCP_SKB_CB(skb)->dccpd_opt_len += tot_len;

474

475 to = skb_push(skb, tot_len);

476 *to++ = type;

477 *to++ = tot_len;

478 *to++ = feat;

479

480 if (repeat_first)

481 *to++ = *val;

482 if (len)

483 memcpy(to, val, len);

484 return 0;

485 }

486

487 /* The length of all options needs to be a multiple of 4 (5.8) */

488 static void dccp_insert_option_padding(struct sk_buff *skb)

489 {

490 int padding = DCCP_SKB_CB(skb)->dccpd_opt_len % 4;

491

492 if (padding != 0) {

493 padding = 4 - padding;

494 memset(skb_push(skb, padding), 0, padding);

495 DCCP_SKB_CB(skb)->dccpd_opt_len += padding;

496 }

497 }

498

499 int dccp_insert_options(struct sock *sk, struct sk_buff *skb)

500 {

501 struct dccp_sock *dp = dccp_sk(sk);

502

503 DCCP_SKB_CB(skb)->dccpd_opt_len = 0;

504

505 if (dp->dccps_send_ndp_count && dccp_insert_option_ndp(sk, skb))

506 return -1;

507

508 if (DCCP_SKB_CB(skb)->dccpd_type != DCCP_PKT_DATA) {

509

510 /* Feature Negotiation */

511 if (dccp_feat_insert_opts(dp, NULL, skb))

512 return -1;

513

514 if (DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_REQUEST) {

515 /*

516 * Obtain RTT sample from Request/Response exchange.

517 * This is currently used for TFRC initialisation.

518 */

519 if (dccp_insert_option_timestamp(skb))

520 return -1;

521

522 } else if (dp->dccps_hc_rx_ackvec != NULL &&

523 dccp_ackvec_pending(dp->dccps_hc_rx_ackvec) &&

524 dccp_insert_option_ackvec(sk, skb)) {

525 return -1;

526 }

527 }

528

529 if (dp->dccps_hc_rx_insert_options) {

530 if (ccid_hc_rx_insert_options(dp->dccps_hc_rx_ccid, sk, skb))

531 return -1;

532 dp->dccps_hc_rx_insert_options = 0;

533 }

534

535 if (dp->dccps_timestamp_echo != 0 &&

536 dccp_insert_option_timestamp_echo(dp, NULL, skb))

537 return -1;

538

539 dccp_insert_option_padding(skb);

540 return 0;

541 }

542

543 int dccp_insert_options_rsk(struct dccp_request_sock *dreq, struct sk_buff *skb)

544 {

545 DCCP_SKB_CB(skb)->dccpd_opt_len = 0;

546

547 if (dccp_feat_insert_opts(NULL, dreq, skb))

548 return -1;

549

550 /* Obtain RTT sample from Response/Ack exchange (used by TFRC). */

551 if (dccp_insert_option_timestamp(skb))

552 return -1;

553

554 if (dreq->dreq_timestamp_echo != 0 &&

555 dccp_insert_option_timestamp_echo(NULL, dreq, skb))

556 return -1;

557

558 dccp_insert_option_padding(skb);

559 return 0;

560 }