4 * An implementation of the DCCP protocol
5 * Andrea Bittau <a.bittau@cs.ucl.ac.uk>
9 * o Feature negotiation is coordinated with connection setup (as in TCP), wild
10 * changes of parameters of an established connection are not supported.
11 * o All currently known SP features have 1-byte quantities. If in the future
12 * extensions of RFCs 4340..42 define features with item lengths larger than
13 * one byte, a feature-specific extension of the code will be required.
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version
18 * 2 of the License, or (at your option) any later version.
21 #include <linux/module.h>
26 #define DCCP_FEAT_SP_NOAGREE (-123)
29 u8 feat_num; /* DCCPF_xxx */
30 enum dccp_feat_type rxtx; /* RX or TX */
31 enum dccp_feat_type reconciliation; /* SP or NN */
32 u8 default_value; /* as in 6.4 */
34 * Lookup table for location and type of features (from RFC 4340/4342)
35 * +--------------------------+----+-----+----+----+---------+-----------+
36 * | Feature | Location | Reconc. | Initial | Section |
37 * | | RX | TX | SP | NN | Value | Reference |
38 * +--------------------------+----+-----+----+----+---------+-----------+
39 * | DCCPF_CCID | | X | X | | 2 | 10 |
40 * | DCCPF_SHORT_SEQNOS | | X | X | | 0 | 7.6.1 |
41 * | DCCPF_SEQUENCE_WINDOW | | X | | X | 100 | 7.5.2 |
42 * | DCCPF_ECN_INCAPABLE | X | | X | | 0 | 12.1 |
43 * | DCCPF_ACK_RATIO | | X | | X | 2 | 11.3 |
44 * | DCCPF_SEND_ACK_VECTOR | X | | X | | 0 | 11.5 |
45 * | DCCPF_SEND_NDP_COUNT | | X | X | | 0 | 7.7.2 |
46 * | DCCPF_MIN_CSUM_COVER | X | | X | | 0 | 9.2.1 |
47 * | DCCPF_DATA_CHECKSUM | X | | X | | 0 | 9.3.1 |
48 * | DCCPF_SEND_LEV_RATE | X | | X | | 0 | 4342/8.4 |
49 * +--------------------------+----+-----+----+----+---------+-----------+
51 } dccp_feat_table[] = {
52 { DCCPF_CCID, FEAT_AT_TX, FEAT_SP, 2 },
53 { DCCPF_SHORT_SEQNOS, FEAT_AT_TX, FEAT_SP, 0 },
54 { DCCPF_SEQUENCE_WINDOW, FEAT_AT_TX, FEAT_NN, 100 },
55 { DCCPF_ECN_INCAPABLE, FEAT_AT_RX, FEAT_SP, 0 },
56 { DCCPF_ACK_RATIO, FEAT_AT_TX, FEAT_NN, 2 },
57 { DCCPF_SEND_ACK_VECTOR, FEAT_AT_RX, FEAT_SP, 0 },
58 { DCCPF_SEND_NDP_COUNT, FEAT_AT_TX, FEAT_SP, 0 },
59 { DCCPF_MIN_CSUM_COVER, FEAT_AT_RX, FEAT_SP, 0 },
60 { DCCPF_DATA_CHECKSUM, FEAT_AT_RX, FEAT_SP, 0 },
61 { DCCPF_SEND_LEV_RATE, FEAT_AT_RX, FEAT_SP, 0 },
63 #define DCCP_FEAT_SUPPORTED_MAX ARRAY_SIZE(dccp_feat_table)
66 * dccp_feat_index - Hash function to map feature number into array position
67 * Returns consecutive array index or -1 if the feature is not understood.
69 static int dccp_feat_index(u8 feat_num)
71 /* The first 9 entries are occupied by the types from RFC 4340, 6.4 */
72 if (feat_num > DCCPF_RESERVED && feat_num <= DCCPF_DATA_CHECKSUM)
76 * Other features: add cases for new feature types here after adding
77 * them to the above table.
80 case DCCPF_SEND_LEV_RATE:
81 return DCCP_FEAT_SUPPORTED_MAX - 1;
86 static u8 dccp_feat_type(u8 feat_num)
88 int idx = dccp_feat_index(feat_num);
92 return dccp_feat_table[idx].reconciliation;
95 static int dccp_feat_default_value(u8 feat_num)
97 int idx = dccp_feat_index(feat_num);
99 * There are no default values for unknown features, so encountering a
100 * negative index here indicates a serious problem somewhere else.
102 DCCP_BUG_ON(idx < 0);
104 return idx < 0 ? 0 : dccp_feat_table[idx].default_value;
107 /* copy constructor, fval must not already contain allocated memory */
108 static int dccp_feat_clone_sp_val(dccp_feat_val *fval, u8 const *val, u8 len)
111 if (fval->sp.len > 0) {
112 fval->sp.vec = kmemdup(val, len, gfp_any());
113 if (fval->sp.vec == NULL) {
121 static void dccp_feat_val_destructor(u8 feat_num, dccp_feat_val *val)
123 if (unlikely(val == NULL))
125 if (dccp_feat_type(feat_num) == FEAT_SP)
127 memset(val, 0, sizeof(*val));
130 static struct dccp_feat_entry *
131 dccp_feat_clone_entry(struct dccp_feat_entry const *original)
133 struct dccp_feat_entry *new;
134 u8 type = dccp_feat_type(original->feat_num);
136 if (type == FEAT_UNKNOWN)
139 new = kmemdup(original, sizeof(struct dccp_feat_entry), gfp_any());
143 if (type == FEAT_SP && dccp_feat_clone_sp_val(&new->val,
144 original->val.sp.vec,
145 original->val.sp.len)) {
152 static void dccp_feat_entry_destructor(struct dccp_feat_entry *entry)
155 dccp_feat_val_destructor(entry->feat_num, &entry->val);
161 * List management functions
163 * Feature negotiation lists rely on and maintain the following invariants:
164 * - each feat_num in the list is known, i.e. we know its type and default value
165 * - each feat_num/is_local combination is unique (old entries are overwritten)
166 * - SP values are always freshly allocated
167 * - list is sorted in increasing order of feature number (faster lookup)
171 * dccp_feat_entry_new - Central list update routine (called by all others)
172 * @head: list to add to
173 * @feat: feature number
174 * @local: whether the local (1) or remote feature with number @feat is meant
175 * This is the only constructor and serves to ensure the above invariants.
177 static struct dccp_feat_entry *
178 dccp_feat_entry_new(struct list_head *head, u8 feat, bool local)
180 struct dccp_feat_entry *entry;
182 list_for_each_entry(entry, head, node)
183 if (entry->feat_num == feat && entry->is_local == local) {
184 dccp_feat_val_destructor(entry->feat_num, &entry->val);
186 } else if (entry->feat_num > feat) {
191 entry = kmalloc(sizeof(*entry), gfp_any());
193 entry->feat_num = feat;
194 entry->is_local = local;
195 list_add_tail(&entry->node, head);
201 * dccp_feat_push_change - Add/overwrite a Change option in the list
202 * @fn_list: feature-negotiation list to update
203 * @feat: one of %dccp_feature_numbers
204 * @local: whether local (1) or remote (0) @feat_num is meant
205 * @needs_mandatory: whether to use Mandatory feature negotiation options
206 * @fval: pointer to NN/SP value to be inserted (will be copied)
208 static int dccp_feat_push_change(struct list_head *fn_list, u8 feat, u8 local,
209 u8 mandatory, dccp_feat_val *fval)
211 struct dccp_feat_entry *new = dccp_feat_entry_new(fn_list, feat, local);
216 new->feat_num = feat;
217 new->is_local = local;
218 new->state = FEAT_INITIALISING;
219 new->needs_confirm = 0;
220 new->empty_confirm = 0;
222 new->needs_mandatory = mandatory;
227 static inline void dccp_feat_list_pop(struct dccp_feat_entry *entry)
229 list_del(&entry->node);
230 dccp_feat_entry_destructor(entry);
233 void dccp_feat_list_purge(struct list_head *fn_list)
235 struct dccp_feat_entry *entry, *next;
237 list_for_each_entry_safe(entry, next, fn_list, node)
238 dccp_feat_entry_destructor(entry);
239 INIT_LIST_HEAD(fn_list);
241 EXPORT_SYMBOL_GPL(dccp_feat_list_purge);
243 /* generate @to as full clone of @from - @to must not contain any nodes */
244 int dccp_feat_clone_list(struct list_head const *from, struct list_head *to)
246 struct dccp_feat_entry *entry, *new;
249 list_for_each_entry(entry, from, node) {
250 new = dccp_feat_clone_entry(entry);
253 list_add_tail(&new->node, to);
258 dccp_feat_list_purge(to);
262 static u8 dccp_feat_is_valid_nn_val(u8 feat_num, u64 val)
265 case DCCPF_ACK_RATIO:
266 return val <= DCCPF_ACK_RATIO_MAX;
267 case DCCPF_SEQUENCE_WINDOW:
268 return val >= DCCPF_SEQ_WMIN && val <= DCCPF_SEQ_WMAX;
270 return 0; /* feature unknown - so we can't tell */
273 /* check that SP values are within the ranges defined in RFC 4340 */
274 static u8 dccp_feat_is_valid_sp_val(u8 feat_num, u8 val)
278 return val == DCCPC_CCID2 || val == DCCPC_CCID3;
279 /* Type-check Boolean feature values: */
280 case DCCPF_SHORT_SEQNOS:
281 case DCCPF_ECN_INCAPABLE:
282 case DCCPF_SEND_ACK_VECTOR:
283 case DCCPF_SEND_NDP_COUNT:
284 case DCCPF_DATA_CHECKSUM:
285 case DCCPF_SEND_LEV_RATE:
287 case DCCPF_MIN_CSUM_COVER:
290 return 0; /* feature unknown */
293 static u8 dccp_feat_sp_list_ok(u8 feat_num, u8 const *sp_list, u8 sp_len)
295 if (sp_list == NULL || sp_len < 1)
298 if (!dccp_feat_is_valid_sp_val(feat_num, *sp_list++))
304 * __feat_register_nn - Register new NN value on socket
305 * @fn: feature-negotiation list to register with
306 * @feat: an NN feature from %dccp_feature_numbers
307 * @mandatory: use Mandatory option if 1
308 * @nn_val: value to register (restricted to 4 bytes)
309 * Note that NN features are local by definition (RFC 4340, 6.3.2).
311 static int __feat_register_nn(struct list_head *fn, u8 feat,
312 u8 mandatory, u64 nn_val)
314 dccp_feat_val fval = { .nn = nn_val };
316 if (dccp_feat_type(feat) != FEAT_NN ||
317 !dccp_feat_is_valid_nn_val(feat, nn_val))
320 /* Don't bother with default values, they will be activated anyway. */
321 if (nn_val - (u64)dccp_feat_default_value(feat) == 0)
324 return dccp_feat_push_change(fn, feat, 1, mandatory, &fval);
328 * __feat_register_sp - Register new SP value/list on socket
329 * @fn: feature-negotiation list to register with
330 * @feat: an SP feature from %dccp_feature_numbers
331 * @is_local: whether the local (1) or the remote (0) @feat is meant
332 * @mandatory: use Mandatory option if 1
333 * @sp_val: SP value followed by optional preference list
334 * @sp_len: length of @sp_val in bytes
336 static int __feat_register_sp(struct list_head *fn, u8 feat, u8 is_local,
337 u8 mandatory, u8 const *sp_val, u8 sp_len)
341 if (dccp_feat_type(feat) != FEAT_SP ||
342 !dccp_feat_sp_list_ok(feat, sp_val, sp_len))
345 if (dccp_feat_clone_sp_val(&fval, sp_val, sp_len))
348 return dccp_feat_push_change(fn, feat, is_local, mandatory, &fval);
351 int dccp_feat_change(struct dccp_minisock *dmsk, u8 type, u8 feature,
352 u8 *val, u8 len, gfp_t gfp)
354 struct dccp_opt_pend *opt;
356 dccp_feat_debug(type, feature, *val);
359 DCCP_WARN("invalid length %d\n", len);
362 /* XXX add further sanity checks */
364 /* check if that feature is already being negotiated */
365 list_for_each_entry(opt, &dmsk->dccpms_pending, dccpop_node) {
366 /* ok we found a negotiation for this option already */
367 if (opt->dccpop_feat == feature && opt->dccpop_type == type) {
368 dccp_pr_debug("Replacing old\n");
370 BUG_ON(opt->dccpop_val == NULL);
371 kfree(opt->dccpop_val);
372 opt->dccpop_val = val;
373 opt->dccpop_len = len;
374 opt->dccpop_conf = 0;
379 /* negotiation for a new feature */
380 opt = kmalloc(sizeof(*opt), gfp);
384 opt->dccpop_type = type;
385 opt->dccpop_feat = feature;
386 opt->dccpop_len = len;
387 opt->dccpop_val = val;
388 opt->dccpop_conf = 0;
389 opt->dccpop_sc = NULL;
391 BUG_ON(opt->dccpop_val == NULL);
393 list_add_tail(&opt->dccpop_node, &dmsk->dccpms_pending);
397 EXPORT_SYMBOL_GPL(dccp_feat_change);
399 static int dccp_feat_update_ccid(struct sock *sk, u8 type, u8 new_ccid_nr)
401 struct dccp_sock *dp = dccp_sk(sk);
402 struct dccp_minisock *dmsk = dccp_msk(sk);
403 /* figure out if we are changing our CCID or the peer's */
404 const int rx = type == DCCPO_CHANGE_R;
405 const u8 ccid_nr = rx ? dmsk->dccpms_rx_ccid : dmsk->dccpms_tx_ccid;
406 struct ccid *new_ccid;
408 /* Check if nothing is being changed. */
409 if (ccid_nr == new_ccid_nr)
412 new_ccid = ccid_new(new_ccid_nr, sk, rx, GFP_ATOMIC);
413 if (new_ccid == NULL)
417 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
418 dp->dccps_hc_rx_ccid = new_ccid;
419 dmsk->dccpms_rx_ccid = new_ccid_nr;
421 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
422 dp->dccps_hc_tx_ccid = new_ccid;
423 dmsk->dccpms_tx_ccid = new_ccid_nr;
429 static int dccp_feat_update(struct sock *sk, u8 type, u8 feat, u8 val)
431 dccp_feat_debug(type, feat, val);
435 return dccp_feat_update_ccid(sk, type, val);
437 dccp_pr_debug("UNIMPLEMENTED: %s(%d, ...)\n",
438 dccp_feat_typename(type), feat);
444 static int dccp_feat_reconcile(struct sock *sk, struct dccp_opt_pend *opt,
447 struct dccp_sock *dp = dccp_sk(sk);
448 u8 *spref, slen, *res = NULL;
449 int i, j, rc, agree = 1;
451 BUG_ON(rpref == NULL);
453 /* check if we are the black sheep */
454 if (dp->dccps_role == DCCP_ROLE_CLIENT) {
457 rpref = opt->dccpop_val;
458 rlen = opt->dccpop_len;
460 spref = opt->dccpop_val;
461 slen = opt->dccpop_len;
464 * Now we have server preference list in spref and client preference in
467 BUG_ON(spref == NULL);
468 BUG_ON(rpref == NULL);
470 /* FIXME sanity check vals */
472 /* Are values in any order? XXX Lame "algorithm" here */
473 for (i = 0; i < slen; i++) {
474 for (j = 0; j < rlen; j++) {
475 if (spref[i] == rpref[j]) {
484 /* we didn't agree on anything */
486 /* confirm previous value */
487 switch (opt->dccpop_feat) {
489 /* XXX did i get this right? =P */
490 if (opt->dccpop_type == DCCPO_CHANGE_L)
491 res = &dccp_msk(sk)->dccpms_tx_ccid;
493 res = &dccp_msk(sk)->dccpms_rx_ccid;
497 DCCP_BUG("Fell through, feat=%d", opt->dccpop_feat);
498 /* XXX implement res */
502 dccp_pr_debug("Don't agree... reconfirming %d\n", *res);
503 agree = 0; /* this is used for mandatory options... */
506 /* need to put result and our preference list */
507 rlen = 1 + opt->dccpop_len;
508 rpref = kmalloc(rlen, GFP_ATOMIC);
513 memcpy(&rpref[1], opt->dccpop_val, opt->dccpop_len);
515 /* put it in the "confirm queue" */
516 if (opt->dccpop_sc == NULL) {
517 opt->dccpop_sc = kmalloc(sizeof(*opt->dccpop_sc), GFP_ATOMIC);
518 if (opt->dccpop_sc == NULL) {
523 /* recycle the confirm slot */
524 BUG_ON(opt->dccpop_sc->dccpoc_val == NULL);
525 kfree(opt->dccpop_sc->dccpoc_val);
526 dccp_pr_debug("recycling confirm slot\n");
528 memset(opt->dccpop_sc, 0, sizeof(*opt->dccpop_sc));
530 opt->dccpop_sc->dccpoc_val = rpref;
531 opt->dccpop_sc->dccpoc_len = rlen;
533 /* update the option on our side [we are about to send the confirm] */
534 rc = dccp_feat_update(sk, opt->dccpop_type, opt->dccpop_feat, *res);
536 kfree(opt->dccpop_sc->dccpoc_val);
537 kfree(opt->dccpop_sc);
538 opt->dccpop_sc = NULL;
542 dccp_pr_debug("Will confirm %d\n", *rpref);
544 /* say we want to change to X but we just got a confirm X, suppress our
547 if (!opt->dccpop_conf) {
548 if (*opt->dccpop_val == *res)
549 opt->dccpop_conf = 1;
550 dccp_pr_debug("won't ask for change of same feature\n");
553 return agree ? 0 : DCCP_FEAT_SP_NOAGREE; /* used for mandatory opts */
556 static int dccp_feat_sp(struct sock *sk, u8 type, u8 feature, u8 *val, u8 len)
558 struct dccp_minisock *dmsk = dccp_msk(sk);
559 struct dccp_opt_pend *opt;
564 * We received a CHANGE. We gotta match it against our own preference
565 * list. If we got a CHANGE_R it means it's a change for us, so we need
566 * to compare our CHANGE_L list.
568 if (type == DCCPO_CHANGE_L)
573 /* find our preference list for this feature */
574 list_for_each_entry(opt, &dmsk->dccpms_pending, dccpop_node) {
575 if (opt->dccpop_type != t || opt->dccpop_feat != feature)
578 /* find the winner from the two preference lists */
579 rc = dccp_feat_reconcile(sk, opt, val, len);
583 /* We didn't deal with the change. This can happen if we have no
584 * preference list for the feature. In fact, it just shouldn't
585 * happen---if we understand a feature, we should have a preference list
586 * with at least the default value.
593 static int dccp_feat_nn(struct sock *sk, u8 type, u8 feature, u8 *val, u8 len)
595 struct dccp_opt_pend *opt;
596 struct dccp_minisock *dmsk = dccp_msk(sk);
600 /* NN features must be Change L (sec. 6.3.2) */
601 if (type != DCCPO_CHANGE_L) {
602 dccp_pr_debug("received %s for NN feature %d\n",
603 dccp_feat_typename(type), feature);
607 /* XXX sanity check opt val */
609 /* copy option so we can confirm it */
610 opt = kzalloc(sizeof(*opt), GFP_ATOMIC);
614 copy = kmemdup(val, len, GFP_ATOMIC);
620 opt->dccpop_type = DCCPO_CONFIRM_R; /* NN can only confirm R */
621 opt->dccpop_feat = feature;
622 opt->dccpop_val = copy;
623 opt->dccpop_len = len;
626 rc = dccp_feat_update(sk, type, feature, *val);
628 kfree(opt->dccpop_val);
633 dccp_feat_debug(type, feature, *copy);
635 list_add_tail(&opt->dccpop_node, &dmsk->dccpms_conf);
640 static void dccp_feat_empty_confirm(struct dccp_minisock *dmsk,
643 /* XXX check if other confirms for that are queued and recycle slot */
644 struct dccp_opt_pend *opt = kzalloc(sizeof(*opt), GFP_ATOMIC);
647 /* XXX what do we do? Ignoring should be fine. It's a change
655 opt->dccpop_type = DCCPO_CONFIRM_R;
658 opt->dccpop_type = DCCPO_CONFIRM_L;
661 DCCP_WARN("invalid type %d\n", type);
665 opt->dccpop_feat = feature;
666 opt->dccpop_val = NULL;
670 dccp_pr_debug("Empty %s(%d)\n", dccp_feat_typename(type), feature);
672 list_add_tail(&opt->dccpop_node, &dmsk->dccpms_conf);
675 static void dccp_feat_flush_confirm(struct sock *sk)
677 struct dccp_minisock *dmsk = dccp_msk(sk);
678 /* Check if there is anything to confirm in the first place */
679 int yes = !list_empty(&dmsk->dccpms_conf);
682 struct dccp_opt_pend *opt;
684 list_for_each_entry(opt, &dmsk->dccpms_pending, dccpop_node) {
685 if (opt->dccpop_conf) {
695 /* OK there is something to confirm... */
696 /* XXX check if packet is in flight? Send delayed ack?? */
697 if (sk->sk_state == DCCP_OPEN)
701 int dccp_feat_change_recv(struct sock *sk, u8 type, u8 feature, u8 *val, u8 len)
705 /* Ignore Change requests other than during connection setup */
706 if (sk->sk_state != DCCP_LISTEN && sk->sk_state != DCCP_REQUESTING)
708 dccp_feat_debug(type, feature, *val);
710 /* figure out if it's SP or NN feature */
712 /* deal with SP features */
714 rc = dccp_feat_sp(sk, type, feature, val, len);
717 /* deal with NN features */
718 case DCCPF_ACK_RATIO:
719 rc = dccp_feat_nn(sk, type, feature, val, len);
722 /* XXX implement other features */
724 dccp_pr_debug("UNIMPLEMENTED: not handling %s(%d, ...)\n",
725 dccp_feat_typename(type), feature);
730 /* check if there were problems changing features */
732 /* If we don't agree on SP, we sent a confirm for old value.
733 * However we propagate rc to caller in case option was
736 if (rc != DCCP_FEAT_SP_NOAGREE)
737 dccp_feat_empty_confirm(dccp_msk(sk), type, feature);
740 /* generate the confirm [if required] */
741 dccp_feat_flush_confirm(sk);
746 EXPORT_SYMBOL_GPL(dccp_feat_change_recv);
748 int dccp_feat_confirm_recv(struct sock *sk, u8 type, u8 feature,
752 struct dccp_opt_pend *opt;
753 struct dccp_minisock *dmsk = dccp_msk(sk);
755 int all_confirmed = 1;
757 /* Ignore Confirm options other than during connection setup */
758 if (sk->sk_state != DCCP_LISTEN && sk->sk_state != DCCP_REQUESTING)
760 dccp_feat_debug(type, feature, *val);
762 /* locate our change request */
764 case DCCPO_CONFIRM_L: t = DCCPO_CHANGE_R; break;
765 case DCCPO_CONFIRM_R: t = DCCPO_CHANGE_L; break;
766 default: DCCP_WARN("invalid type %d\n", type);
770 /* XXX sanity check feature value */
772 list_for_each_entry(opt, &dmsk->dccpms_pending, dccpop_node) {
773 if (!opt->dccpop_conf && opt->dccpop_type == t &&
774 opt->dccpop_feat == feature) {
776 dccp_pr_debug("feature %d found\n", opt->dccpop_feat);
778 /* XXX do sanity check */
780 opt->dccpop_conf = 1;
782 /* We got a confirmation---change the option */
783 dccp_feat_update(sk, opt->dccpop_type,
784 opt->dccpop_feat, *val);
786 /* XXX check the return value of dccp_feat_update */
790 if (!opt->dccpop_conf)
795 dccp_pr_debug("%s(%d, ...) never requested\n",
796 dccp_feat_typename(type), feature);
800 EXPORT_SYMBOL_GPL(dccp_feat_confirm_recv);
802 void dccp_feat_clean(struct dccp_minisock *dmsk)
804 struct dccp_opt_pend *opt, *next;
806 list_for_each_entry_safe(opt, next, &dmsk->dccpms_pending,
808 BUG_ON(opt->dccpop_val == NULL);
809 kfree(opt->dccpop_val);
811 if (opt->dccpop_sc != NULL) {
812 BUG_ON(opt->dccpop_sc->dccpoc_val == NULL);
813 kfree(opt->dccpop_sc->dccpoc_val);
814 kfree(opt->dccpop_sc);
819 INIT_LIST_HEAD(&dmsk->dccpms_pending);
821 list_for_each_entry_safe(opt, next, &dmsk->dccpms_conf, dccpop_node) {
823 if (opt->dccpop_val != NULL)
824 kfree(opt->dccpop_val);
827 INIT_LIST_HEAD(&dmsk->dccpms_conf);
830 EXPORT_SYMBOL_GPL(dccp_feat_clean);
832 /* this is to be called only when a listening sock creates its child. It is
833 * assumed by the function---the confirm is not duplicated, but rather it is
836 int dccp_feat_clone(struct sock *oldsk, struct sock *newsk)
838 struct dccp_minisock *olddmsk = dccp_msk(oldsk);
839 struct dccp_minisock *newdmsk = dccp_msk(newsk);
840 struct dccp_opt_pend *opt;
843 INIT_LIST_HEAD(&newdmsk->dccpms_pending);
844 INIT_LIST_HEAD(&newdmsk->dccpms_conf);
846 list_for_each_entry(opt, &olddmsk->dccpms_pending, dccpop_node) {
847 struct dccp_opt_pend *newopt;
848 /* copy the value of the option */
849 u8 *val = kmemdup(opt->dccpop_val, opt->dccpop_len, GFP_ATOMIC);
854 newopt = kmemdup(opt, sizeof(*newopt), GFP_ATOMIC);
855 if (newopt == NULL) {
860 /* insert the option */
861 newopt->dccpop_val = val;
862 list_add_tail(&newopt->dccpop_node, &newdmsk->dccpms_pending);
864 /* XXX what happens with backlogs and multiple connections at
867 /* the master socket no longer needs to worry about confirms */
868 opt->dccpop_sc = NULL; /* it's not a memleak---new socket has it */
870 /* reset state for a new socket */
871 opt->dccpop_conf = 0;
874 /* XXX not doing anything about the conf queue */
880 dccp_feat_clean(newdmsk);
885 EXPORT_SYMBOL_GPL(dccp_feat_clone);
887 int dccp_feat_init(struct sock *sk)
889 struct dccp_sock *dp = dccp_sk(sk);
890 struct dccp_minisock *dmsk = dccp_msk(sk);
893 INIT_LIST_HEAD(&dmsk->dccpms_pending); /* XXX no longer used */
894 INIT_LIST_HEAD(&dmsk->dccpms_conf); /* XXX no longer used */
897 rc = __feat_register_sp(&dp->dccps_featneg, DCCPF_CCID, 1, 0,
898 &dmsk->dccpms_tx_ccid, 1);
903 rc = __feat_register_sp(&dp->dccps_featneg, DCCPF_CCID, 0, 0,
904 &dmsk->dccpms_rx_ccid, 1);
909 rc = __feat_register_nn(&dp->dccps_featneg, DCCPF_ACK_RATIO, 0,
910 dmsk->dccpms_ack_ratio);
915 EXPORT_SYMBOL_GPL(dccp_feat_init);
917 #ifdef CONFIG_IP_DCCP_DEBUG
918 const char *dccp_feat_typename(const u8 type)
921 case DCCPO_CHANGE_L: return("ChangeL");
922 case DCCPO_CONFIRM_L: return("ConfirmL");
923 case DCCPO_CHANGE_R: return("ChangeR");
924 case DCCPO_CONFIRM_R: return("ConfirmR");
925 /* the following case must not appear in feature negotation */
926 default: dccp_pr_debug("unknown type %d [BUG!]\n", type);
931 EXPORT_SYMBOL_GPL(dccp_feat_typename);
933 const char *dccp_feat_name(const u8 feat)
935 static const char *feature_names[] = {
936 [DCCPF_RESERVED] = "Reserved",
937 [DCCPF_CCID] = "CCID",
938 [DCCPF_SHORT_SEQNOS] = "Allow Short Seqnos",
939 [DCCPF_SEQUENCE_WINDOW] = "Sequence Window",
940 [DCCPF_ECN_INCAPABLE] = "ECN Incapable",
941 [DCCPF_ACK_RATIO] = "Ack Ratio",
942 [DCCPF_SEND_ACK_VECTOR] = "Send ACK Vector",
943 [DCCPF_SEND_NDP_COUNT] = "Send NDP Count",
944 [DCCPF_MIN_CSUM_COVER] = "Min. Csum Coverage",
945 [DCCPF_DATA_CHECKSUM] = "Send Data Checksum",
947 if (feat > DCCPF_DATA_CHECKSUM && feat < DCCPF_MIN_CCID_SPECIFIC)
948 return feature_names[DCCPF_RESERVED];
950 if (feat == DCCPF_SEND_LEV_RATE)
951 return "Send Loss Event Rate";
952 if (feat >= DCCPF_MIN_CCID_SPECIFIC)
953 return "CCID-specific";
955 return feature_names[feat];
958 EXPORT_SYMBOL_GPL(dccp_feat_name);
959 #endif /* CONFIG_IP_DCCP_DEBUG */