1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/module.h>
14
15#include "ccid.h"
16#include "feat.h"
17
18#define DCCP_FEAT_SP_NOAGREE (-123)
19
20int dccp_feat_change(struct dccp_minisock *dmsk, u8 type, u8 feature,
21 u8 *val, u8 len, gfp_t gfp)
22{
23 struct dccp_opt_pend *opt;
24
25 dccp_feat_debug(type, feature, *val);
26
27 if (!dccp_feat_is_valid_type(type)) {
28 DCCP_WARN("option type %d invalid in negotiation\n", type);
29 return 1;
30 }
31 if (!dccp_feat_is_valid_length(type, feature, len)) {
32 DCCP_WARN("invalid length %d\n", len);
33 return 1;
34 }
35
36
37
38 list_for_each_entry(opt, &dmsk->dccpms_pending, dccpop_node) {
39
40 if (opt->dccpop_feat == feature && opt->dccpop_type == type) {
41 dccp_pr_debug("Replacing old\n");
42
43 BUG_ON(opt->dccpop_val == NULL);
44 kfree(opt->dccpop_val);
45 opt->dccpop_val = val;
46 opt->dccpop_len = len;
47 opt->dccpop_conf = 0;
48 return 0;
49 }
50 }
51
52
53 opt = kmalloc(sizeof(*opt), gfp);
54 if (opt == NULL)
55 return -ENOMEM;
56
57 opt->dccpop_type = type;
58 opt->dccpop_feat = feature;
59 opt->dccpop_len = len;
60 opt->dccpop_val = val;
61 opt->dccpop_conf = 0;
62 opt->dccpop_sc = NULL;
63
64 BUG_ON(opt->dccpop_val == NULL);
65
66 list_add_tail(&opt->dccpop_node, &dmsk->dccpms_pending);
67 return 0;
68}
69
70EXPORT_SYMBOL_GPL(dccp_feat_change);
71
72static int dccp_feat_update_ccid(struct sock *sk, u8 type, u8 new_ccid_nr)
73{
74 struct dccp_sock *dp = dccp_sk(sk);
75 struct dccp_minisock *dmsk = dccp_msk(sk);
76
77 const int rx = type == DCCPO_CHANGE_R;
78 const u8 ccid_nr = rx ? dmsk->dccpms_rx_ccid : dmsk->dccpms_tx_ccid;
79 struct ccid *new_ccid;
80
81
82 if (ccid_nr == new_ccid_nr)
83 return 0;
84
85 new_ccid = ccid_new(new_ccid_nr, sk, rx, GFP_ATOMIC);
86 if (new_ccid == NULL)
87 return -ENOMEM;
88
89 if (rx) {
90 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
91 dp->dccps_hc_rx_ccid = new_ccid;
92 dmsk->dccpms_rx_ccid = new_ccid_nr;
93 } else {
94 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
95 dp->dccps_hc_tx_ccid = new_ccid;
96 dmsk->dccpms_tx_ccid = new_ccid_nr;
97 }
98
99 return 0;
100}
101
102
103static int dccp_feat_update(struct sock *sk, u8 type, u8 feat, u8 val)
104{
105 dccp_feat_debug(type, feat, val);
106
107 switch (feat) {
108 case DCCPF_CCID:
109 return dccp_feat_update_ccid(sk, type, val);
110 default:
111 dccp_pr_debug("UNIMPLEMENTED: %s(%d, ...)\n",
112 dccp_feat_typename(type), feat);
113 break;
114 }
115 return 0;
116}
117
118static int dccp_feat_reconcile(struct sock *sk, struct dccp_opt_pend *opt,
119 u8 *rpref, u8 rlen)
120{
121 struct dccp_sock *dp = dccp_sk(sk);
122 u8 *spref, slen, *res = NULL;
123 int i, j, rc, agree = 1;
124
125 BUG_ON(rpref == NULL);
126
127
128 if (dp->dccps_role == DCCP_ROLE_CLIENT) {
129 spref = rpref;
130 slen = rlen;
131 rpref = opt->dccpop_val;
132 rlen = opt->dccpop_len;
133 } else {
134 spref = opt->dccpop_val;
135 slen = opt->dccpop_len;
136 }
137
138
139
140
141 BUG_ON(spref == NULL);
142 BUG_ON(rpref == NULL);
143
144
145
146
147
148 for (i = 0; i < slen; i++) {
149 for (j = 0; j < rlen; j++) {
150 if (spref[i] == rpref[j]) {
151 res = &spref[i];
152 break;
153 }
154 }
155 if (res)
156 break;
157 }
158
159
160 if (res == NULL) {
161
162 switch (opt->dccpop_feat) {
163 case DCCPF_CCID:
164
165 if (opt->dccpop_type == DCCPO_CHANGE_L)
166 res = &dccp_msk(sk)->dccpms_tx_ccid;
167 else
168 res = &dccp_msk(sk)->dccpms_rx_ccid;
169 break;
170
171 default:
172 DCCP_BUG("Fell through, feat=%d", opt->dccpop_feat);
173
174 return -EFAULT;
175 }
176
177 dccp_pr_debug("Don't agree... reconfirming %d\n", *res);
178 agree = 0;
179 }
180
181
182
183 rlen = 1 + opt->dccpop_len;
184 rpref = kmalloc(rlen, GFP_ATOMIC);
185 if (rpref == NULL)
186 return -ENOMEM;
187
188 *rpref = *res;
189 memcpy(&rpref[1], opt->dccpop_val, opt->dccpop_len);
190
191
192 if (opt->dccpop_sc == NULL) {
193 opt->dccpop_sc = kmalloc(sizeof(*opt->dccpop_sc), GFP_ATOMIC);
194 if (opt->dccpop_sc == NULL) {
195 kfree(rpref);
196 return -ENOMEM;
197 }
198 } else {
199
200 BUG_ON(opt->dccpop_sc->dccpoc_val == NULL);
201 kfree(opt->dccpop_sc->dccpoc_val);
202 dccp_pr_debug("recycling confirm slot\n");
203 }
204 memset(opt->dccpop_sc, 0, sizeof(*opt->dccpop_sc));
205
206 opt->dccpop_sc->dccpoc_val = rpref;
207 opt->dccpop_sc->dccpoc_len = rlen;
208
209
210 rc = dccp_feat_update(sk, opt->dccpop_type, opt->dccpop_feat, *res);
211 if (rc) {
212 kfree(opt->dccpop_sc->dccpoc_val);
213 kfree(opt->dccpop_sc);
214 opt->dccpop_sc = NULL;
215 return rc;
216 }
217
218 dccp_pr_debug("Will confirm %d\n", *rpref);
219
220
221
222
223 if (!opt->dccpop_conf) {
224 if (*opt->dccpop_val == *res)
225 opt->dccpop_conf = 1;
226 dccp_pr_debug("won't ask for change of same feature\n");
227 }
228
229 return agree ? 0 : DCCP_FEAT_SP_NOAGREE;
230}
231
232static int dccp_feat_sp(struct sock *sk, u8 type, u8 feature, u8 *val, u8 len)
233{
234 struct dccp_minisock *dmsk = dccp_msk(sk);
235 struct dccp_opt_pend *opt;
236 int rc = 1;
237 u8 t;
238
239
240
241
242
243
244 if (type == DCCPO_CHANGE_L)
245 t = DCCPO_CHANGE_R;
246 else
247 t = DCCPO_CHANGE_L;
248
249
250 list_for_each_entry(opt, &dmsk->dccpms_pending, dccpop_node) {
251 if (opt->dccpop_type != t || opt->dccpop_feat != feature)
252 continue;
253
254
255 rc = dccp_feat_reconcile(sk, opt, val, len);
256 break;
257 }
258
259
260
261
262
263
264 BUG_ON(rc == 1);
265
266 return rc;
267}
268
269static int dccp_feat_nn(struct sock *sk, u8 type, u8 feature, u8 *val, u8 len)
270{
271 struct dccp_opt_pend *opt;
272 struct dccp_minisock *dmsk = dccp_msk(sk);
273 u8 *copy;
274 int rc;
275
276
277 if (type != DCCPO_CHANGE_L) {
278 dccp_pr_debug("received %s for NN feature %d\n",
279 dccp_feat_typename(type), feature);
280 return -EFAULT;
281 }
282
283
284
285
286 opt = kzalloc(sizeof(*opt), GFP_ATOMIC);
287 if (opt == NULL)
288 return -ENOMEM;
289
290 copy = kmemdup(val, len, GFP_ATOMIC);
291 if (copy == NULL) {
292 kfree(opt);
293 return -ENOMEM;
294 }
295
296 opt->dccpop_type = DCCPO_CONFIRM_R;
297 opt->dccpop_feat = feature;
298 opt->dccpop_val = copy;
299 opt->dccpop_len = len;
300
301
302 rc = dccp_feat_update(sk, type, feature, *val);
303 if (rc) {
304 kfree(opt->dccpop_val);
305 kfree(opt);
306 return rc;
307 }
308
309 dccp_feat_debug(type, feature, *copy);
310
311 list_add_tail(&opt->dccpop_node, &dmsk->dccpms_conf);
312
313 return 0;
314}
315
316static void dccp_feat_empty_confirm(struct dccp_minisock *dmsk,
317 u8 type, u8 feature)
318{
319
320 struct dccp_opt_pend *opt = kzalloc(sizeof(*opt), GFP_ATOMIC);
321
322 if (opt == NULL) {
323
324
325
326 return;
327 }
328
329 switch (type) {
330 case DCCPO_CHANGE_L:
331 opt->dccpop_type = DCCPO_CONFIRM_R;
332 break;
333 case DCCPO_CHANGE_R:
334 opt->dccpop_type = DCCPO_CONFIRM_L;
335 break;
336 default:
337 DCCP_WARN("invalid type %d\n", type);
338 kfree(opt);
339 return;
340 }
341 opt->dccpop_feat = feature;
342 opt->dccpop_val = NULL;
343 opt->dccpop_len = 0;
344
345
346 dccp_pr_debug("Empty %s(%d)\n", dccp_feat_typename(type), feature);
347
348 list_add_tail(&opt->dccpop_node, &dmsk->dccpms_conf);
349}
350
351static void dccp_feat_flush_confirm(struct sock *sk)
352{
353 struct dccp_minisock *dmsk = dccp_msk(sk);
354
355 int yes = !list_empty(&dmsk->dccpms_conf);
356
357 if (!yes) {
358 struct dccp_opt_pend *opt;
359
360 list_for_each_entry(opt, &dmsk->dccpms_pending, dccpop_node) {
361 if (opt->dccpop_conf) {
362 yes = 1;
363 break;
364 }
365 }
366 }
367
368 if (!yes)
369 return;
370
371
372
373 if (sk->sk_state == DCCP_OPEN)
374 dccp_send_ack(sk);
375}
376
377int dccp_feat_change_recv(struct sock *sk, u8 type, u8 feature, u8 *val, u8 len)
378{
379 int rc;
380
381 dccp_feat_debug(type, feature, *val);
382
383
384 switch (feature) {
385
386 case DCCPF_CCID:
387 rc = dccp_feat_sp(sk, type, feature, val, len);
388 break;
389
390
391 case DCCPF_ACK_RATIO:
392 rc = dccp_feat_nn(sk, type, feature, val, len);
393 break;
394
395
396 default:
397 dccp_pr_debug("UNIMPLEMENTED: not handling %s(%d, ...)\n",
398 dccp_feat_typename(type), feature);
399 rc = -EFAULT;
400 break;
401 }
402
403
404 if (rc) {
405
406
407
408
409 if (rc != DCCP_FEAT_SP_NOAGREE)
410 dccp_feat_empty_confirm(dccp_msk(sk), type, feature);
411 }
412
413
414 dccp_feat_flush_confirm(sk);
415
416 return rc;
417}
418
419EXPORT_SYMBOL_GPL(dccp_feat_change_recv);
420
421int dccp_feat_confirm_recv(struct sock *sk, u8 type, u8 feature,
422 u8 *val, u8 len)
423{
424 u8 t;
425 struct dccp_opt_pend *opt;
426 struct dccp_minisock *dmsk = dccp_msk(sk);
427 int found = 0;
428 int all_confirmed = 1;
429
430 dccp_feat_debug(type, feature, *val);
431
432
433 switch (type) {
434 case DCCPO_CONFIRM_L: t = DCCPO_CHANGE_R; break;
435 case DCCPO_CONFIRM_R: t = DCCPO_CHANGE_L; break;
436 default: DCCP_WARN("invalid type %d\n", type);
437 return 1;
438
439 }
440
441
442 list_for_each_entry(opt, &dmsk->dccpms_pending, dccpop_node) {
443 if (!opt->dccpop_conf && opt->dccpop_type == t &&
444 opt->dccpop_feat == feature) {
445 found = 1;
446 dccp_pr_debug("feature %d found\n", opt->dccpop_feat);
447
448
449
450 opt->dccpop_conf = 1;
451
452
453 dccp_feat_update(sk, opt->dccpop_type,
454 opt->dccpop_feat, *val);
455
456
457 break;
458 }
459
460 if (!opt->dccpop_conf)
461 all_confirmed = 0;
462 }
463
464
465
466
467
468
469
470 if (all_confirmed) {
471 dccp_pr_debug("clear feat negotiation timer %p\n", sk);
472 inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
473 }
474
475 if (!found)
476 dccp_pr_debug("%s(%d, ...) never requested\n",
477 dccp_feat_typename(type), feature);
478 return 0;
479}
480
481EXPORT_SYMBOL_GPL(dccp_feat_confirm_recv);
482
483void dccp_feat_clean(struct dccp_minisock *dmsk)
484{
485 struct dccp_opt_pend *opt, *next;
486
487 list_for_each_entry_safe(opt, next, &dmsk->dccpms_pending,
488 dccpop_node) {
489 BUG_ON(opt->dccpop_val == NULL);
490 kfree(opt->dccpop_val);
491
492 if (opt->dccpop_sc != NULL) {
493 BUG_ON(opt->dccpop_sc->dccpoc_val == NULL);
494 kfree(opt->dccpop_sc->dccpoc_val);
495 kfree(opt->dccpop_sc);
496 }
497
498 kfree(opt);
499 }
500 INIT_LIST_HEAD(&dmsk->dccpms_pending);
501
502 list_for_each_entry_safe(opt, next, &dmsk->dccpms_conf, dccpop_node) {
503 BUG_ON(opt == NULL);
504 if (opt->dccpop_val != NULL)
505 kfree(opt->dccpop_val);
506 kfree(opt);
507 }
508 INIT_LIST_HEAD(&dmsk->dccpms_conf);
509}
510
511EXPORT_SYMBOL_GPL(dccp_feat_clean);
512
513
514
515
516
517int dccp_feat_clone(struct sock *oldsk, struct sock *newsk)
518{
519 struct dccp_minisock *olddmsk = dccp_msk(oldsk);
520 struct dccp_minisock *newdmsk = dccp_msk(newsk);
521 struct dccp_opt_pend *opt;
522 int rc = 0;
523
524 INIT_LIST_HEAD(&newdmsk->dccpms_pending);
525 INIT_LIST_HEAD(&newdmsk->dccpms_conf);
526
527 list_for_each_entry(opt, &olddmsk->dccpms_pending, dccpop_node) {
528 struct dccp_opt_pend *newopt;
529
530 u8 *val = kmemdup(opt->dccpop_val, opt->dccpop_len, GFP_ATOMIC);
531
532 if (val == NULL)
533 goto out_clean;
534
535 newopt = kmemdup(opt, sizeof(*newopt), GFP_ATOMIC);
536 if (newopt == NULL) {
537 kfree(val);
538 goto out_clean;
539 }
540
541
542 newopt->dccpop_val = val;
543 list_add_tail(&newopt->dccpop_node, &newdmsk->dccpms_pending);
544
545
546
547
548
549 opt->dccpop_sc = NULL;
550
551
552 opt->dccpop_conf = 0;
553 }
554
555
556
557out:
558 return rc;
559
560out_clean:
561 dccp_feat_clean(newdmsk);
562 rc = -ENOMEM;
563 goto out;
564}
565
566EXPORT_SYMBOL_GPL(dccp_feat_clone);
567
568static int __dccp_feat_init(struct dccp_minisock *dmsk, u8 type, u8 feat,
569 u8 *val, u8 len)
570{
571 int rc = -ENOMEM;
572 u8 *copy = kmemdup(val, len, GFP_KERNEL);
573
574 if (copy != NULL) {
575 rc = dccp_feat_change(dmsk, type, feat, copy, len, GFP_KERNEL);
576 if (rc)
577 kfree(copy);
578 }
579 return rc;
580}
581
582int dccp_feat_init(struct dccp_minisock *dmsk)
583{
584 int rc;
585
586 INIT_LIST_HEAD(&dmsk->dccpms_pending);
587 INIT_LIST_HEAD(&dmsk->dccpms_conf);
588
589
590 rc = __dccp_feat_init(dmsk, DCCPO_CHANGE_L, DCCPF_CCID,
591 &dmsk->dccpms_tx_ccid, 1);
592 if (rc)
593 goto out;
594
595
596 rc = __dccp_feat_init(dmsk, DCCPO_CHANGE_R, DCCPF_CCID,
597 &dmsk->dccpms_rx_ccid, 1);
598 if (rc)
599 goto out;
600
601
602 rc = __dccp_feat_init(dmsk, DCCPO_CHANGE_L, DCCPF_ACK_RATIO,
603 &dmsk->dccpms_ack_ratio, 1);
604out:
605 return rc;
606}
607
608EXPORT_SYMBOL_GPL(dccp_feat_init);
609
610#ifdef CONFIG_IP_DCCP_DEBUG
611const char *dccp_feat_typename(const u8 type)
612{
613 switch(type) {
614 case DCCPO_CHANGE_L: return("ChangeL");
615 case DCCPO_CONFIRM_L: return("ConfirmL");
616 case DCCPO_CHANGE_R: return("ChangeR");
617 case DCCPO_CONFIRM_R: return("ConfirmR");
618
619 default: dccp_pr_debug("unknown type %d [BUG!]\n", type);
620 }
621 return NULL;
622}
623
624EXPORT_SYMBOL_GPL(dccp_feat_typename);
625
626const char *dccp_feat_name(const u8 feat)
627{
628 static const char *feature_names[] = {
629 [DCCPF_RESERVED] = "Reserved",
630 [DCCPF_CCID] = "CCID",
631 [DCCPF_SHORT_SEQNOS] = "Allow Short Seqnos",
632 [DCCPF_SEQUENCE_WINDOW] = "Sequence Window",
633 [DCCPF_ECN_INCAPABLE] = "ECN Incapable",
634 [DCCPF_ACK_RATIO] = "Ack Ratio",
635 [DCCPF_SEND_ACK_VECTOR] = "Send ACK Vector",
636 [DCCPF_SEND_NDP_COUNT] = "Send NDP Count",
637 [DCCPF_MIN_CSUM_COVER] = "Min. Csum Coverage",
638 [DCCPF_DATA_CHECKSUM] = "Send Data Checksum",
639 };
640 if (feat >= DCCPF_MIN_CCID_SPECIFIC)
641 return "CCID-specific";
642
643 if (dccp_feat_is_reserved(feat))
644 return feature_names[DCCPF_RESERVED];
645
646 return feature_names[feat];
647}
648
649EXPORT_SYMBOL_GPL(dccp_feat_name);
650#endif
651