Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
feat.c
Go to the documentation of this file.
1 /*
2  * net/dccp/feat.c
3  *
4  * Feature negotiation for the DCCP protocol (RFC 4340, section 6)
5  *
6  * Copyright (c) 2008 Gerrit Renker <[email protected]>
7  * Rewrote from scratch, some bits from earlier code by
8  * Copyright (c) 2005 Andrea Bittau <[email protected]>
9  *
10  *
11  * ASSUMPTIONS
12  * -----------
13  * o Feature negotiation is coordinated with connection setup (as in TCP), wild
14  * changes of parameters of an established connection are not supported.
15  * o Changing non-negotiable (NN) values is supported in state OPEN/PARTOPEN.
16  * o All currently known SP features have 1-byte quantities. If in the future
17  * extensions of RFCs 4340..42 define features with item lengths larger than
18  * one byte, a feature-specific extension of the code will be required.
19  *
20  * This program is free software; you can redistribute it and/or
21  * modify it under the terms of the GNU General Public License
22  * as published by the Free Software Foundation; either version
23  * 2 of the License, or (at your option) any later version.
24  */
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include "ccid.h"
28 #include "feat.h"
29 
30 /* feature-specific sysctls - initialised to the defaults from RFC 4340, 6.4 */
34 
35 /*
36  * Feature activation handlers.
37  *
38  * These all use an u64 argument, to provide enough room for NN/SP features. At
39  * this stage the negotiated values have been checked to be within their range.
40  */
41 static int dccp_hdlr_ccid(struct sock *sk, u64 ccid, bool rx)
42 {
43  struct dccp_sock *dp = dccp_sk(sk);
44  struct ccid *new_ccid = ccid_new(ccid, sk, rx);
45 
46  if (new_ccid == NULL)
47  return -ENOMEM;
48 
49  if (rx) {
51  dp->dccps_hc_rx_ccid = new_ccid;
52  } else {
54  dp->dccps_hc_tx_ccid = new_ccid;
55  }
56  return 0;
57 }
58 
59 static int dccp_hdlr_seq_win(struct sock *sk, u64 seq_win, bool rx)
60 {
61  struct dccp_sock *dp = dccp_sk(sk);
62 
63  if (rx) {
64  dp->dccps_r_seq_win = seq_win;
65  /* propagate changes to update SWL/SWH */
66  dccp_update_gsr(sk, dp->dccps_gsr);
67  } else {
68  dp->dccps_l_seq_win = seq_win;
69  /* propagate changes to update AWL */
70  dccp_update_gss(sk, dp->dccps_gss);
71  }
72  return 0;
73 }
74 
75 static int dccp_hdlr_ack_ratio(struct sock *sk, u64 ratio, bool rx)
76 {
77  if (rx)
78  dccp_sk(sk)->dccps_r_ack_ratio = ratio;
79  else
80  dccp_sk(sk)->dccps_l_ack_ratio = ratio;
81  return 0;
82 }
83 
84 static int dccp_hdlr_ackvec(struct sock *sk, u64 enable, bool rx)
85 {
86  struct dccp_sock *dp = dccp_sk(sk);
87 
88  if (rx) {
89  if (enable && dp->dccps_hc_rx_ackvec == NULL) {
90  dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(gfp_any());
91  if (dp->dccps_hc_rx_ackvec == NULL)
92  return -ENOMEM;
93  } else if (!enable) {
96  }
97  }
98  return 0;
99 }
100 
101 static int dccp_hdlr_ndp(struct sock *sk, u64 enable, bool rx)
102 {
103  if (!rx)
104  dccp_sk(sk)->dccps_send_ndp_count = (enable > 0);
105  return 0;
106 }
107 
108 /*
109  * Minimum Checksum Coverage is located at the RX side (9.2.1). This means that
110  * `rx' holds when the sending peer informs about his partial coverage via a
111  * ChangeR() option. In the other case, we are the sender and the receiver
112  * announces its coverage via ChangeL() options. The policy here is to honour
113  * such communication by enabling the corresponding partial coverage - but only
114  * if it has not been set manually before; the warning here means that all
115  * packets will be dropped.
116  */
117 static int dccp_hdlr_min_cscov(struct sock *sk, u64 cscov, bool rx)
118 {
119  struct dccp_sock *dp = dccp_sk(sk);
120 
121  if (rx)
122  dp->dccps_pcrlen = cscov;
123  else {
124  if (dp->dccps_pcslen == 0)
125  dp->dccps_pcslen = cscov;
126  else if (cscov > dp->dccps_pcslen)
127  DCCP_WARN("CsCov %u too small, peer requires >= %u\n",
128  dp->dccps_pcslen, (u8)cscov);
129  }
130  return 0;
131 }
132 
133 static const struct {
134  u8 feat_num; /* DCCPF_xxx */
135  enum dccp_feat_type rxtx; /* RX or TX */
136  enum dccp_feat_type reconciliation; /* SP or NN */
137  u8 default_value; /* as in 6.4 */
138  int (*activation_hdlr)(struct sock *sk, u64 val, bool rx);
139 /*
140  * Lookup table for location and type of features (from RFC 4340/4342)
141  * +--------------------------+----+-----+----+----+---------+-----------+
142  * | Feature | Location | Reconc. | Initial | Section |
143  * | | RX | TX | SP | NN | Value | Reference |
144  * +--------------------------+----+-----+----+----+---------+-----------+
145  * | DCCPF_CCID | | X | X | | 2 | 10 |
146  * | DCCPF_SHORT_SEQNOS | | X | X | | 0 | 7.6.1 |
147  * | DCCPF_SEQUENCE_WINDOW | | X | | X | 100 | 7.5.2 |
148  * | DCCPF_ECN_INCAPABLE | X | | X | | 0 | 12.1 |
149  * | DCCPF_ACK_RATIO | | X | | X | 2 | 11.3 |
150  * | DCCPF_SEND_ACK_VECTOR | X | | X | | 0 | 11.5 |
151  * | DCCPF_SEND_NDP_COUNT | | X | X | | 0 | 7.7.2 |
152  * | DCCPF_MIN_CSUM_COVER | X | | X | | 0 | 9.2.1 |
153  * | DCCPF_DATA_CHECKSUM | X | | X | | 0 | 9.3.1 |
154  * | DCCPF_SEND_LEV_RATE | X | | X | | 0 | 4342/8.4 |
155  * +--------------------------+----+-----+----+----+---------+-----------+
156  */
157 } dccp_feat_table[] = {
158  { DCCPF_CCID, FEAT_AT_TX, FEAT_SP, 2, dccp_hdlr_ccid },
160  { DCCPF_SEQUENCE_WINDOW, FEAT_AT_TX, FEAT_NN, 100, dccp_hdlr_seq_win },
162  { DCCPF_ACK_RATIO, FEAT_AT_TX, FEAT_NN, 2, dccp_hdlr_ack_ratio},
163  { DCCPF_SEND_ACK_VECTOR, FEAT_AT_RX, FEAT_SP, 0, dccp_hdlr_ackvec },
164  { DCCPF_SEND_NDP_COUNT, FEAT_AT_TX, FEAT_SP, 0, dccp_hdlr_ndp },
165  { DCCPF_MIN_CSUM_COVER, FEAT_AT_RX, FEAT_SP, 0, dccp_hdlr_min_cscov},
168 };
169 #define DCCP_FEAT_SUPPORTED_MAX ARRAY_SIZE(dccp_feat_table)
170 
175 static int dccp_feat_index(u8 feat_num)
176 {
177  /* The first 9 entries are occupied by the types from RFC 4340, 6.4 */
178  if (feat_num > DCCPF_RESERVED && feat_num <= DCCPF_DATA_CHECKSUM)
179  return feat_num - 1;
180 
181  /*
182  * Other features: add cases for new feature types here after adding
183  * them to the above table.
184  */
185  switch (feat_num) {
186  case DCCPF_SEND_LEV_RATE:
187  return DCCP_FEAT_SUPPORTED_MAX - 1;
188  }
189  return -1;
190 }
191 
193 {
194  int idx = dccp_feat_index(feat_num);
195 
196  if (idx < 0)
197  return FEAT_UNKNOWN;
198  return dccp_feat_table[idx].reconciliation;
199 }
200 
201 static int dccp_feat_default_value(u8 feat_num)
202 {
203  int idx = dccp_feat_index(feat_num);
204  /*
205  * There are no default values for unknown features, so encountering a
206  * negative index here indicates a serious problem somewhere else.
207  */
208  DCCP_BUG_ON(idx < 0);
209 
210  return idx < 0 ? 0 : dccp_feat_table[idx].default_value;
211 }
212 
213 /*
214  * Debugging and verbose-printing section
215  */
216 static const char *dccp_feat_fname(const u8 feat)
217 {
218  static const char *const feature_names[] = {
219  [DCCPF_RESERVED] = "Reserved",
220  [DCCPF_CCID] = "CCID",
221  [DCCPF_SHORT_SEQNOS] = "Allow Short Seqnos",
222  [DCCPF_SEQUENCE_WINDOW] = "Sequence Window",
223  [DCCPF_ECN_INCAPABLE] = "ECN Incapable",
224  [DCCPF_ACK_RATIO] = "Ack Ratio",
225  [DCCPF_SEND_ACK_VECTOR] = "Send ACK Vector",
226  [DCCPF_SEND_NDP_COUNT] = "Send NDP Count",
227  [DCCPF_MIN_CSUM_COVER] = "Min. Csum Coverage",
228  [DCCPF_DATA_CHECKSUM] = "Send Data Checksum",
229  };
230  if (feat > DCCPF_DATA_CHECKSUM && feat < DCCPF_MIN_CCID_SPECIFIC)
231  return feature_names[DCCPF_RESERVED];
232 
233  if (feat == DCCPF_SEND_LEV_RATE)
234  return "Send Loss Event Rate";
235  if (feat >= DCCPF_MIN_CCID_SPECIFIC)
236  return "CCID-specific";
237 
238  return feature_names[feat];
239 }
240 
241 static const char *const dccp_feat_sname[] = {
242  "DEFAULT", "INITIALISING", "CHANGING", "UNSTABLE", "STABLE",
243 };
244 
245 #ifdef CONFIG_IP_DCCP_DEBUG
246 static const char *dccp_feat_oname(const u8 opt)
247 {
248  switch (opt) {
249  case DCCPO_CHANGE_L: return "Change_L";
250  case DCCPO_CONFIRM_L: return "Confirm_L";
251  case DCCPO_CHANGE_R: return "Change_R";
252  case DCCPO_CONFIRM_R: return "Confirm_R";
253  }
254  return NULL;
255 }
256 
257 static void dccp_feat_printval(u8 feat_num, dccp_feat_val const *val)
258 {
259  u8 i, type = dccp_feat_type(feat_num);
260 
261  if (val == NULL || (type == FEAT_SP && val->sp.vec == NULL))
262  dccp_pr_debug_cat("(NULL)");
263  else if (type == FEAT_SP)
264  for (i = 0; i < val->sp.len; i++)
265  dccp_pr_debug_cat("%s%u", i ? " " : "", val->sp.vec[i]);
266  else if (type == FEAT_NN)
267  dccp_pr_debug_cat("%llu", (unsigned long long)val->nn);
268  else
269  dccp_pr_debug_cat("unknown type %u", type);
270 }
271 
272 static void dccp_feat_printvals(u8 feat_num, u8 *list, u8 len)
273 {
274  u8 type = dccp_feat_type(feat_num);
275  dccp_feat_val fval = { .sp.vec = list, .sp.len = len };
276 
277  if (type == FEAT_NN)
278  fval.nn = dccp_decode_value_var(list, len);
279  dccp_feat_printval(feat_num, &fval);
280 }
281 
282 static void dccp_feat_print_entry(struct dccp_feat_entry const *entry)
283 {
284  dccp_debug(" * %s %s = ", entry->is_local ? "local" : "remote",
285  dccp_feat_fname(entry->feat_num));
286  dccp_feat_printval(entry->feat_num, &entry->val);
287  dccp_pr_debug_cat(", state=%s %s\n", dccp_feat_sname[entry->state],
288  entry->needs_confirm ? "(Confirm pending)" : "");
289 }
290 
291 #define dccp_feat_print_opt(opt, feat, val, len, mandatory) do { \
292  dccp_pr_debug("%s(%s, ", dccp_feat_oname(opt), dccp_feat_fname(feat));\
293  dccp_feat_printvals(feat, val, len); \
294  dccp_pr_debug_cat(") %s\n", mandatory ? "!" : ""); } while (0)
295 
296 #define dccp_feat_print_fnlist(fn_list) { \
297  const struct dccp_feat_entry *___entry; \
298  \
299  dccp_pr_debug("List Dump:\n"); \
300  list_for_each_entry(___entry, fn_list, node) \
301  dccp_feat_print_entry(___entry); \
302 }
303 #else /* ! CONFIG_IP_DCCP_DEBUG */
304 #define dccp_feat_print_opt(opt, feat, val, len, mandatory)
305 #define dccp_feat_print_fnlist(fn_list)
306 #endif
307 
308 static int __dccp_feat_activate(struct sock *sk, const int idx,
309  const bool is_local, dccp_feat_val const *fval)
310 {
311  bool rx;
312  u64 val;
313 
314  if (idx < 0 || idx >= DCCP_FEAT_SUPPORTED_MAX)
315  return -1;
316  if (dccp_feat_table[idx].activation_hdlr == NULL)
317  return 0;
318 
319  if (fval == NULL) {
320  val = dccp_feat_table[idx].default_value;
321  } else if (dccp_feat_table[idx].reconciliation == FEAT_SP) {
322  if (fval->sp.vec == NULL) {
323  /*
324  * This can happen when an empty Confirm is sent
325  * for an SP (i.e. known) feature. In this case
326  * we would be using the default anyway.
327  */
328  DCCP_CRIT("Feature #%d undefined: using default", idx);
329  val = dccp_feat_table[idx].default_value;
330  } else {
331  val = fval->sp.vec[0];
332  }
333  } else {
334  val = fval->nn;
335  }
336 
337  /* Location is RX if this is a local-RX or remote-TX feature */
338  rx = (is_local == (dccp_feat_table[idx].rxtx == FEAT_AT_RX));
339 
340  dccp_debug(" -> activating %s %s, %sval=%llu\n", rx ? "RX" : "TX",
341  dccp_feat_fname(dccp_feat_table[idx].feat_num),
342  fval ? "" : "default ", (unsigned long long)val);
343 
344  return dccp_feat_table[idx].activation_hdlr(sk, val, rx);
345 }
346 
356 static int dccp_feat_activate(struct sock *sk, u8 feat_num, bool local,
357  dccp_feat_val const *fval)
358 {
359  return __dccp_feat_activate(sk, dccp_feat_index(feat_num), local, fval);
360 }
361 
362 /* Test for "Req'd" feature (RFC 4340, 6.4) */
363 static inline int dccp_feat_must_be_understood(u8 feat_num)
364 {
365  return feat_num == DCCPF_CCID || feat_num == DCCPF_SHORT_SEQNOS ||
366  feat_num == DCCPF_SEQUENCE_WINDOW;
367 }
368 
369 /* copy constructor, fval must not already contain allocated memory */
370 static int dccp_feat_clone_sp_val(dccp_feat_val *fval, u8 const *val, u8 len)
371 {
372  fval->sp.len = len;
373  if (fval->sp.len > 0) {
374  fval->sp.vec = kmemdup(val, len, gfp_any());
375  if (fval->sp.vec == NULL) {
376  fval->sp.len = 0;
377  return -ENOBUFS;
378  }
379  }
380  return 0;
381 }
382 
383 static void dccp_feat_val_destructor(u8 feat_num, dccp_feat_val *val)
384 {
385  if (unlikely(val == NULL))
386  return;
387  if (dccp_feat_type(feat_num) == FEAT_SP)
388  kfree(val->sp.vec);
389  memset(val, 0, sizeof(*val));
390 }
391 
392 static struct dccp_feat_entry *
393  dccp_feat_clone_entry(struct dccp_feat_entry const *original)
394 {
395  struct dccp_feat_entry *new;
396  u8 type = dccp_feat_type(original->feat_num);
397 
398  if (type == FEAT_UNKNOWN)
399  return NULL;
400 
401  new = kmemdup(original, sizeof(struct dccp_feat_entry), gfp_any());
402  if (new == NULL)
403  return NULL;
404 
405  if (type == FEAT_SP && dccp_feat_clone_sp_val(&new->val,
406  original->val.sp.vec,
407  original->val.sp.len)) {
408  kfree(new);
409  return NULL;
410  }
411  return new;
412 }
413 
414 static void dccp_feat_entry_destructor(struct dccp_feat_entry *entry)
415 {
416  if (entry != NULL) {
417  dccp_feat_val_destructor(entry->feat_num, &entry->val);
418  kfree(entry);
419  }
420 }
421 
422 /*
423  * List management functions
424  *
425  * Feature negotiation lists rely on and maintain the following invariants:
426  * - each feat_num in the list is known, i.e. we know its type and default value
427  * - each feat_num/is_local combination is unique (old entries are overwritten)
428  * - SP values are always freshly allocated
429  * - list is sorted in increasing order of feature number (faster lookup)
430  */
431 static struct dccp_feat_entry *dccp_feat_list_lookup(struct list_head *fn_list,
432  u8 feat_num, bool is_local)
433 {
434  struct dccp_feat_entry *entry;
435 
436  list_for_each_entry(entry, fn_list, node) {
437  if (entry->feat_num == feat_num && entry->is_local == is_local)
438  return entry;
439  else if (entry->feat_num > feat_num)
440  break;
441  }
442  return NULL;
443 }
444 
453 static struct dccp_feat_entry *
454  dccp_feat_entry_new(struct list_head *head, u8 feat, bool local)
455 {
456  struct dccp_feat_entry *entry;
457 
458  list_for_each_entry(entry, head, node)
459  if (entry->feat_num == feat && entry->is_local == local) {
460  dccp_feat_val_destructor(entry->feat_num, &entry->val);
461  return entry;
462  } else if (entry->feat_num > feat) {
463  head = &entry->node;
464  break;
465  }
466 
467  entry = kmalloc(sizeof(*entry), gfp_any());
468  if (entry != NULL) {
469  entry->feat_num = feat;
470  entry->is_local = local;
471  list_add_tail(&entry->node, head);
472  }
473  return entry;
474 }
475 
484 static int dccp_feat_push_change(struct list_head *fn_list, u8 feat, u8 local,
485  u8 mandatory, dccp_feat_val *fval)
486 {
487  struct dccp_feat_entry *new = dccp_feat_entry_new(fn_list, feat, local);
488 
489  if (new == NULL)
490  return -ENOMEM;
491 
492  new->feat_num = feat;
493  new->is_local = local;
494  new->state = FEAT_INITIALISING;
495  new->needs_confirm = false;
496  new->empty_confirm = false;
497  new->val = *fval;
498  new->needs_mandatory = mandatory;
499 
500  return 0;
501 }
502 
512 static int dccp_feat_push_confirm(struct list_head *fn_list, u8 feat, u8 local,
513  dccp_feat_val *fval)
514 {
515  struct dccp_feat_entry *new = dccp_feat_entry_new(fn_list, feat, local);
516 
517  if (new == NULL)
519 
520  new->feat_num = feat;
521  new->is_local = local;
522  new->state = FEAT_STABLE; /* transition in 6.6.2 */
523  new->needs_confirm = true;
524  new->empty_confirm = (fval == NULL);
525  new->val.nn = 0; /* zeroes the whole structure */
526  if (!new->empty_confirm)
527  new->val = *fval;
528  new->needs_mandatory = false;
529 
530  return 0;
531 }
532 
533 static int dccp_push_empty_confirm(struct list_head *fn_list, u8 feat, u8 local)
534 {
535  return dccp_feat_push_confirm(fn_list, feat, local, NULL);
536 }
537 
538 static inline void dccp_feat_list_pop(struct dccp_feat_entry *entry)
539 {
540  list_del(&entry->node);
541  dccp_feat_entry_destructor(entry);
542 }
543 
544 void dccp_feat_list_purge(struct list_head *fn_list)
545 {
546  struct dccp_feat_entry *entry, *next;
547 
548  list_for_each_entry_safe(entry, next, fn_list, node)
549  dccp_feat_entry_destructor(entry);
550  INIT_LIST_HEAD(fn_list);
551 }
553 
554 /* generate @to as full clone of @from - @to must not contain any nodes */
555 int dccp_feat_clone_list(struct list_head const *from, struct list_head *to)
556 {
557  struct dccp_feat_entry *entry, *new;
558 
559  INIT_LIST_HEAD(to);
560  list_for_each_entry(entry, from, node) {
561  new = dccp_feat_clone_entry(entry);
562  if (new == NULL)
563  goto cloning_failed;
564  list_add_tail(&new->node, to);
565  }
566  return 0;
567 
568 cloning_failed:
570  return -ENOMEM;
571 }
572 
578 static u8 dccp_feat_valid_nn_length(u8 feat_num)
579 {
580  if (feat_num == DCCPF_ACK_RATIO) /* RFC 4340, 11.3 and 6.6.8 */
581  return 2;
582  if (feat_num == DCCPF_SEQUENCE_WINDOW) /* RFC 4340, 7.5.2 and 6.5 */
583  return 6;
584  return 0;
585 }
586 
587 static u8 dccp_feat_is_valid_nn_val(u8 feat_num, u64 val)
588 {
589  switch (feat_num) {
590  case DCCPF_ACK_RATIO:
591  return val <= DCCPF_ACK_RATIO_MAX;
593  return val >= DCCPF_SEQ_WMIN && val <= DCCPF_SEQ_WMAX;
594  }
595  return 0; /* feature unknown - so we can't tell */
596 }
597 
598 /* check that SP values are within the ranges defined in RFC 4340 */
599 static u8 dccp_feat_is_valid_sp_val(u8 feat_num, u8 val)
600 {
601  switch (feat_num) {
602  case DCCPF_CCID:
603  return val == DCCPC_CCID2 || val == DCCPC_CCID3;
604  /* Type-check Boolean feature values: */
605  case DCCPF_SHORT_SEQNOS:
606  case DCCPF_ECN_INCAPABLE:
609  case DCCPF_DATA_CHECKSUM:
610  case DCCPF_SEND_LEV_RATE:
611  return val < 2;
613  return val < 16;
614  }
615  return 0; /* feature unknown */
616 }
617 
618 static u8 dccp_feat_sp_list_ok(u8 feat_num, u8 const *sp_list, u8 sp_len)
619 {
620  if (sp_list == NULL || sp_len < 1)
621  return 0;
622  while (sp_len--)
623  if (!dccp_feat_is_valid_sp_val(feat_num, *sp_list++))
624  return 0;
625  return 1;
626 }
627 
634 int dccp_feat_insert_opts(struct dccp_sock *dp, struct dccp_request_sock *dreq,
635  struct sk_buff *skb)
636 {
637  struct list_head *fn = dreq ? &dreq->dreq_featneg : &dp->dccps_featneg;
638  struct dccp_feat_entry *pos, *next;
639  u8 opt, type, len, *ptr, nn_in_nbo[DCCP_OPTVAL_MAXLEN];
640  bool rpt;
641 
642  /* put entries into @skb in the order they appear in the list */
643  list_for_each_entry_safe_reverse(pos, next, fn, node) {
644  opt = dccp_feat_genopt(pos);
645  type = dccp_feat_type(pos->feat_num);
646  rpt = false;
647 
648  if (pos->empty_confirm) {
649  len = 0;
650  ptr = NULL;
651  } else {
652  if (type == FEAT_SP) {
653  len = pos->val.sp.len;
654  ptr = pos->val.sp.vec;
655  rpt = pos->needs_confirm;
656  } else if (type == FEAT_NN) {
657  len = dccp_feat_valid_nn_length(pos->feat_num);
658  ptr = nn_in_nbo;
659  dccp_encode_value_var(pos->val.nn, ptr, len);
660  } else {
661  DCCP_BUG("unknown feature %u", pos->feat_num);
662  return -1;
663  }
664  }
665  dccp_feat_print_opt(opt, pos->feat_num, ptr, len, 0);
666 
667  if (dccp_insert_fn_opt(skb, opt, pos->feat_num, ptr, len, rpt))
668  return -1;
670  return -1;
671 
672  if (skb->sk->sk_state == DCCP_OPEN &&
673  (opt == DCCPO_CONFIRM_R || opt == DCCPO_CONFIRM_L)) {
674  /*
675  * Confirms don't get retransmitted (6.6.3) once the
676  * connection is in state OPEN
677  */
678  dccp_feat_list_pop(pos);
679  } else {
680  /*
681  * Enter CHANGING after transmitting the Change
682  * option (6.6.2).
683  */
684  if (pos->state == FEAT_INITIALISING)
685  pos->state = FEAT_CHANGING;
686  }
687  }
688  return 0;
689 }
690 
700 static int __feat_register_nn(struct list_head *fn, u8 feat,
701  u8 mandatory, u64 nn_val)
702 {
703  dccp_feat_val fval = { .nn = nn_val };
704 
705  if (dccp_feat_type(feat) != FEAT_NN ||
706  !dccp_feat_is_valid_nn_val(feat, nn_val))
707  return -EINVAL;
708 
709  /* Don't bother with default values, they will be activated anyway. */
710  if (nn_val - (u64)dccp_feat_default_value(feat) == 0)
711  return 0;
712 
713  return dccp_feat_push_change(fn, feat, 1, mandatory, &fval);
714 }
715 
725 static int __feat_register_sp(struct list_head *fn, u8 feat, u8 is_local,
726  u8 mandatory, u8 const *sp_val, u8 sp_len)
727 {
728  dccp_feat_val fval;
729 
730  if (dccp_feat_type(feat) != FEAT_SP ||
731  !dccp_feat_sp_list_ok(feat, sp_val, sp_len))
732  return -EINVAL;
733 
734  /* Avoid negotiating alien CCIDs by only advertising supported ones */
735  if (feat == DCCPF_CCID && !ccid_support_check(sp_val, sp_len))
736  return -EOPNOTSUPP;
737 
738  if (dccp_feat_clone_sp_val(&fval, sp_val, sp_len))
739  return -ENOMEM;
740 
741  return dccp_feat_push_change(fn, feat, is_local, mandatory, &fval);
742 }
743 
752 int dccp_feat_register_sp(struct sock *sk, u8 feat, u8 is_local,
753  u8 const *list, u8 len)
754 { /* any changes must be registered before establishing the connection */
755  if (sk->sk_state != DCCP_CLOSED)
756  return -EISCONN;
757  if (dccp_feat_type(feat) != FEAT_SP)
758  return -EINVAL;
759  return __feat_register_sp(&dccp_sk(sk)->dccps_featneg, feat, is_local,
760  0, list, len);
761 }
762 
771 u64 dccp_feat_nn_get(struct sock *sk, u8 feat)
772 {
773  if (dccp_feat_type(feat) == FEAT_NN) {
774  struct dccp_sock *dp = dccp_sk(sk);
775  struct dccp_feat_entry *entry;
776 
777  entry = dccp_feat_list_lookup(&dp->dccps_featneg, feat, 1);
778  if (entry != NULL)
779  return entry->val.nn;
780 
781  switch (feat) {
782  case DCCPF_ACK_RATIO:
783  return dp->dccps_l_ack_ratio;
785  return dp->dccps_l_seq_win;
786  }
787  }
788  DCCP_BUG("attempt to look up unsupported feature %u", feat);
789  return 0;
790 }
792 
801 int dccp_feat_signal_nn_change(struct sock *sk, u8 feat, u64 nn_val)
802 {
803  struct list_head *fn = &dccp_sk(sk)->dccps_featneg;
804  dccp_feat_val fval = { .nn = nn_val };
805  struct dccp_feat_entry *entry;
806 
807  if (sk->sk_state != DCCP_OPEN && sk->sk_state != DCCP_PARTOPEN)
808  return 0;
809 
810  if (dccp_feat_type(feat) != FEAT_NN ||
811  !dccp_feat_is_valid_nn_val(feat, nn_val))
812  return -EINVAL;
813 
814  if (nn_val == dccp_feat_nn_get(sk, feat))
815  return 0; /* already set or negotiation under way */
816 
817  entry = dccp_feat_list_lookup(fn, feat, 1);
818  if (entry != NULL) {
819  dccp_pr_debug("Clobbering existing NN entry %llu -> %llu\n",
820  (unsigned long long)entry->val.nn,
821  (unsigned long long)nn_val);
822  dccp_feat_list_pop(entry);
823  }
824 
825  inet_csk_schedule_ack(sk);
826  return dccp_feat_push_change(fn, feat, 1, 0, &fval);
827 }
829 
830 /*
831  * Tracking features whose value depend on the choice of CCID
832  *
833  * This is designed with an extension in mind so that a list walk could be done
834  * before activating any features. However, the existing framework was found to
835  * work satisfactorily up until now, the automatic verification is left open.
836  * When adding new CCIDs, add a corresponding dependency table here.
837  */
838 static const struct ccid_dependency *dccp_feat_ccid_deps(u8 ccid, bool is_local)
839 {
840  static const struct ccid_dependency ccid2_dependencies[2][2] = {
841  /*
842  * CCID2 mandates Ack Vectors (RFC 4341, 4.): as CCID is a TX
843  * feature and Send Ack Vector is an RX feature, `is_local'
844  * needs to be reversed.
845  */
846  { /* Dependencies of the receiver-side (remote) CCID2 */
847  {
849  .is_local = true,
850  .is_mandatory = true,
851  .val = 1
852  },
853  { 0, 0, 0, 0 }
854  },
855  { /* Dependencies of the sender-side (local) CCID2 */
856  {
857  .dependent_feat = DCCPF_SEND_ACK_VECTOR,
858  .is_local = false,
859  .is_mandatory = true,
860  .val = 1
861  },
862  { 0, 0, 0, 0 }
863  }
864  };
865  static const struct ccid_dependency ccid3_dependencies[2][5] = {
866  { /*
867  * Dependencies of the receiver-side CCID3
868  */
869  { /* locally disable Ack Vectors */
871  .is_local = true,
872  .is_mandatory = false,
873  .val = 0
874  },
875  { /* see below why Send Loss Event Rate is on */
876  .dependent_feat = DCCPF_SEND_LEV_RATE,
877  .is_local = true,
878  .is_mandatory = true,
879  .val = 1
880  },
881  { /* NDP Count is needed as per RFC 4342, 6.1.1 */
882  .dependent_feat = DCCPF_SEND_NDP_COUNT,
883  .is_local = false,
884  .is_mandatory = true,
885  .val = 1
886  },
887  { 0, 0, 0, 0 },
888  },
889  { /*
890  * CCID3 at the TX side: we request that the HC-receiver
891  * will not send Ack Vectors (they will be ignored, so
892  * Mandatory is not set); we enable Send Loss Event Rate
893  * (Mandatory since the implementation does not support
894  * the Loss Intervals option of RFC 4342, 8.6).
895  * The last two options are for peer's information only.
896  */
897  {
898  .dependent_feat = DCCPF_SEND_ACK_VECTOR,
899  .is_local = false,
900  .is_mandatory = false,
901  .val = 0
902  },
903  {
904  .dependent_feat = DCCPF_SEND_LEV_RATE,
905  .is_local = false,
906  .is_mandatory = true,
907  .val = 1
908  },
909  { /* this CCID does not support Ack Ratio */
910  .dependent_feat = DCCPF_ACK_RATIO,
911  .is_local = true,
912  .is_mandatory = false,
913  .val = 0
914  },
915  { /* tell receiver we are sending NDP counts */
916  .dependent_feat = DCCPF_SEND_NDP_COUNT,
917  .is_local = true,
918  .is_mandatory = false,
919  .val = 1
920  },
921  { 0, 0, 0, 0 }
922  }
923  };
924  switch (ccid) {
925  case DCCPC_CCID2:
926  return ccid2_dependencies[is_local];
927  case DCCPC_CCID3:
928  return ccid3_dependencies[is_local];
929  default:
930  return NULL;
931  }
932 }
933 
942 static int dccp_feat_propagate_ccid(struct list_head *fn, u8 id, bool is_local)
943 {
944  const struct ccid_dependency *table = dccp_feat_ccid_deps(id, is_local);
945  int i, rc = (table == NULL);
946 
947  for (i = 0; rc == 0 && table[i].dependent_feat != DCCPF_RESERVED; i++)
948  if (dccp_feat_type(table[i].dependent_feat) == FEAT_SP)
949  rc = __feat_register_sp(fn, table[i].dependent_feat,
950  table[i].is_local,
951  table[i].is_mandatory,
952  &table[i].val, 1);
953  else
954  rc = __feat_register_nn(fn, table[i].dependent_feat,
955  table[i].is_mandatory,
956  table[i].val);
957  return rc;
958 }
959 
969 {
970  struct list_head *fn = &dp->dccps_featneg;
971  struct dccp_feat_entry *entry;
972  int i = 2, ccids[2] = { -1, -1 };
973 
974  /*
975  * Propagating CCIDs:
976  * 1) not useful to propagate CCID settings if this host advertises more
977  * than one CCID: the choice of CCID may still change - if this is
978  * the client, or if this is the server and the client sends
979  * singleton CCID values.
980  * 2) since is that propagate_ccid changes the list, we defer changing
981  * the sorted list until after the traversal.
982  */
983  list_for_each_entry(entry, fn, node)
984  if (entry->feat_num == DCCPF_CCID && entry->val.sp.len == 1)
985  ccids[entry->is_local] = entry->val.sp.vec[0];
986  while (i--)
987  if (ccids[i] > 0 && dccp_feat_propagate_ccid(fn, ccids[i], i))
988  return -1;
990  return 0;
991 }
992 
999 {
1000  struct list_head *fn = &dreq->dreq_featneg;
1001  struct dccp_feat_entry *entry;
1002  u8 is_local, ccid;
1003 
1004  for (is_local = 0; is_local <= 1; is_local++) {
1005  entry = dccp_feat_list_lookup(fn, DCCPF_CCID, is_local);
1006 
1007  if (entry != NULL && !entry->empty_confirm)
1008  ccid = entry->val.sp.vec[0];
1009  else
1010  ccid = dccp_feat_default_value(DCCPF_CCID);
1011 
1012  if (dccp_feat_propagate_ccid(fn, ccid, is_local))
1013  return -1;
1014  }
1015  return 0;
1016 }
1017 
1018 /* Select the first entry in @servlist that also occurs in @clilist (6.3.1) */
1019 static int dccp_feat_preflist_match(u8 *servlist, u8 slen, u8 *clilist, u8 clen)
1020 {
1021  u8 c, s;
1022 
1023  for (s = 0; s < slen; s++)
1024  for (c = 0; c < clen; c++)
1025  if (servlist[s] == clilist[c])
1026  return servlist[s];
1027  return -1;
1028 }
1029 
1035 static u8 dccp_feat_prefer(u8 preferred_value, u8 *array, u8 array_len)
1036 {
1037  u8 i, does_occur = 0;
1038 
1039  if (array != NULL) {
1040  for (i = 0; i < array_len; i++)
1041  if (array[i] == preferred_value) {
1042  array[i] = array[0];
1043  does_occur++;
1044  }
1045  if (does_occur)
1046  array[0] = preferred_value;
1047  }
1048  return does_occur;
1049 }
1050 
1061 static int dccp_feat_reconcile(dccp_feat_val *fv, u8 *arr, u8 len,
1062  bool is_server, bool reorder)
1063 {
1064  int rc;
1065 
1066  if (!fv->sp.vec || !arr) {
1067  DCCP_CRIT("NULL feature value or array");
1068  return 0;
1069  }
1070 
1071  if (is_server)
1072  rc = dccp_feat_preflist_match(fv->sp.vec, fv->sp.len, arr, len);
1073  else
1074  rc = dccp_feat_preflist_match(arr, len, fv->sp.vec, fv->sp.len);
1075 
1076  if (!reorder)
1077  return rc;
1078  if (rc < 0)
1079  return 0;
1080 
1081  /*
1082  * Reorder list: used for activating features and in dccp_insert_fn_opt.
1083  */
1084  return dccp_feat_prefer(rc, fv->sp.vec, fv->sp.len);
1085 }
1086 
1097 static u8 dccp_feat_change_recv(struct list_head *fn, u8 is_mandatory, u8 opt,
1098  u8 feat, u8 *val, u8 len, const bool server)
1099 {
1100  u8 defval, type = dccp_feat_type(feat);
1101  const bool local = (opt == DCCPO_CHANGE_R);
1102  struct dccp_feat_entry *entry;
1103  dccp_feat_val fval;
1104 
1105  if (len == 0 || type == FEAT_UNKNOWN) /* 6.1 and 6.6.8 */
1106  goto unknown_feature_or_value;
1107 
1108  dccp_feat_print_opt(opt, feat, val, len, is_mandatory);
1109 
1110  /*
1111  * Negotiation of NN features: Change R is invalid, so there is no
1112  * simultaneous negotiation; hence we do not look up in the list.
1113  */
1114  if (type == FEAT_NN) {
1115  if (local || len > sizeof(fval.nn))
1116  goto unknown_feature_or_value;
1117 
1118  /* 6.3.2: "The feature remote MUST accept any valid value..." */
1119  fval.nn = dccp_decode_value_var(val, len);
1120  if (!dccp_feat_is_valid_nn_val(feat, fval.nn))
1121  goto unknown_feature_or_value;
1122 
1123  return dccp_feat_push_confirm(fn, feat, local, &fval);
1124  }
1125 
1126  /*
1127  * Unidirectional/simultaneous negotiation of SP features (6.3.1)
1128  */
1129  entry = dccp_feat_list_lookup(fn, feat, local);
1130  if (entry == NULL) {
1131  /*
1132  * No particular preferences have been registered. We deal with
1133  * this situation by assuming that all valid values are equally
1134  * acceptable, and apply the following checks:
1135  * - if the peer's list is a singleton, we accept a valid value;
1136  * - if we are the server, we first try to see if the peer (the
1137  * client) advertises the default value. If yes, we use it,
1138  * otherwise we accept the preferred value;
1139  * - else if we are the client, we use the first list element.
1140  */
1141  if (dccp_feat_clone_sp_val(&fval, val, 1))
1142  return DCCP_RESET_CODE_TOO_BUSY;
1143 
1144  if (len > 1 && server) {
1145  defval = dccp_feat_default_value(feat);
1146  if (dccp_feat_preflist_match(&defval, 1, val, len) > -1)
1147  fval.sp.vec[0] = defval;
1148  } else if (!dccp_feat_is_valid_sp_val(feat, fval.sp.vec[0])) {
1149  kfree(fval.sp.vec);
1150  goto unknown_feature_or_value;
1151  }
1152 
1153  /* Treat unsupported CCIDs like invalid values */
1154  if (feat == DCCPF_CCID && !ccid_support_check(fval.sp.vec, 1)) {
1155  kfree(fval.sp.vec);
1156  goto not_valid_or_not_known;
1157  }
1158 
1159  return dccp_feat_push_confirm(fn, feat, local, &fval);
1160 
1161  } else if (entry->state == FEAT_UNSTABLE) { /* 6.6.2 */
1162  return 0;
1163  }
1164 
1165  if (dccp_feat_reconcile(&entry->val, val, len, server, true)) {
1166  entry->empty_confirm = false;
1167  } else if (is_mandatory) {
1169  } else if (entry->state == FEAT_INITIALISING) {
1170  /*
1171  * Failed simultaneous negotiation (server only): try to `save'
1172  * the connection by checking whether entry contains the default
1173  * value for @feat. If yes, send an empty Confirm to signal that
1174  * the received Change was not understood - which implies using
1175  * the default value.
1176  * If this also fails, we use Reset as the last resort.
1177  */
1178  WARN_ON(!server);
1179  defval = dccp_feat_default_value(feat);
1180  if (!dccp_feat_reconcile(&entry->val, &defval, 1, server, true))
1182  entry->empty_confirm = true;
1183  }
1184  entry->needs_confirm = true;
1185  entry->needs_mandatory = false;
1186  entry->state = FEAT_STABLE;
1187  return 0;
1188 
1189 unknown_feature_or_value:
1190  if (!is_mandatory)
1191  return dccp_push_empty_confirm(fn, feat, local);
1192 
1193 not_valid_or_not_known:
1194  return is_mandatory ? DCCP_RESET_CODE_MANDATORY_ERROR
1196 }
1197 
1208 static u8 dccp_feat_confirm_recv(struct list_head *fn, u8 is_mandatory, u8 opt,
1209  u8 feat, u8 *val, u8 len, const bool server)
1210 {
1211  u8 *plist, plen, type = dccp_feat_type(feat);
1212  const bool local = (opt == DCCPO_CONFIRM_R);
1213  struct dccp_feat_entry *entry = dccp_feat_list_lookup(fn, feat, local);
1214 
1215  dccp_feat_print_opt(opt, feat, val, len, is_mandatory);
1216 
1217  if (entry == NULL) { /* nothing queued: ignore or handle error */
1218  if (is_mandatory && type == FEAT_UNKNOWN)
1220 
1221  if (!local && type == FEAT_NN) /* 6.3.2 */
1222  goto confirmation_failed;
1223  return 0;
1224  }
1225 
1226  if (entry->state != FEAT_CHANGING) /* 6.6.2 */
1227  return 0;
1228 
1229  if (len == 0) {
1230  if (dccp_feat_must_be_understood(feat)) /* 6.6.7 */
1231  goto confirmation_failed;
1232  /*
1233  * Empty Confirm during connection setup: this means reverting
1234  * to the `old' value, which in this case is the default. Since
1235  * we handle default values automatically when no other values
1236  * have been set, we revert to the old value by removing this
1237  * entry from the list.
1238  */
1239  dccp_feat_list_pop(entry);
1240  return 0;
1241  }
1242 
1243  if (type == FEAT_NN) {
1244  if (len > sizeof(entry->val.nn))
1245  goto confirmation_failed;
1246 
1247  if (entry->val.nn == dccp_decode_value_var(val, len))
1248  goto confirmation_succeeded;
1249 
1250  DCCP_WARN("Bogus Confirm for non-existing value\n");
1251  goto confirmation_failed;
1252  }
1253 
1254  /*
1255  * Parsing SP Confirms: the first element of @val is the preferred
1256  * SP value which the peer confirms, the remainder depends on @len.
1257  * Note that only the confirmed value need to be a valid SP value.
1258  */
1259  if (!dccp_feat_is_valid_sp_val(feat, *val))
1260  goto confirmation_failed;
1261 
1262  if (len == 1) { /* peer didn't supply a preference list */
1263  plist = val;
1264  plen = len;
1265  } else { /* preferred value + preference list */
1266  plist = val + 1;
1267  plen = len - 1;
1268  }
1269 
1270  /* Check whether the peer got the reconciliation right (6.6.8) */
1271  if (dccp_feat_reconcile(&entry->val, plist, plen, server, 0) != *val) {
1272  DCCP_WARN("Confirm selected the wrong value %u\n", *val);
1274  }
1275  entry->val.sp.vec[0] = *val;
1276 
1277 confirmation_succeeded:
1278  entry->state = FEAT_STABLE;
1279  return 0;
1280 
1281 confirmation_failed:
1282  DCCP_WARN("Confirmation failed\n");
1283  return is_mandatory ? DCCP_RESET_CODE_MANDATORY_ERROR
1285 }
1286 
1305 static u8 dccp_feat_handle_nn_established(struct sock *sk, u8 mandatory, u8 opt,
1306  u8 feat, u8 *val, u8 len)
1307 {
1308  struct list_head *fn = &dccp_sk(sk)->dccps_featneg;
1309  const bool local = (opt == DCCPO_CONFIRM_R);
1310  struct dccp_feat_entry *entry;
1311  u8 type = dccp_feat_type(feat);
1312  dccp_feat_val fval;
1313 
1314  dccp_feat_print_opt(opt, feat, val, len, mandatory);
1315 
1316  /* Ignore non-mandatory unknown and non-NN features */
1317  if (type == FEAT_UNKNOWN) {
1318  if (local && !mandatory)
1319  return 0;
1320  goto fast_path_unknown;
1321  } else if (type != FEAT_NN) {
1322  return 0;
1323  }
1324 
1325  /*
1326  * We don't accept empty Confirms, since in fast-path feature
1327  * negotiation the values are enabled immediately after sending
1328  * the Change option.
1329  * Empty Changes on the other hand are invalid (RFC 4340, 6.1).
1330  */
1331  if (len == 0 || len > sizeof(fval.nn))
1332  goto fast_path_unknown;
1333 
1334  if (opt == DCCPO_CHANGE_L) {
1335  fval.nn = dccp_decode_value_var(val, len);
1336  if (!dccp_feat_is_valid_nn_val(feat, fval.nn))
1337  goto fast_path_unknown;
1338 
1339  if (dccp_feat_push_confirm(fn, feat, local, &fval) ||
1340  dccp_feat_activate(sk, feat, local, &fval))
1341  return DCCP_RESET_CODE_TOO_BUSY;
1342 
1343  /* set the `Ack Pending' flag to piggyback a Confirm */
1344  inet_csk_schedule_ack(sk);
1345 
1346  } else if (opt == DCCPO_CONFIRM_R) {
1347  entry = dccp_feat_list_lookup(fn, feat, local);
1348  if (entry == NULL || entry->state != FEAT_CHANGING)
1349  return 0;
1350 
1351  fval.nn = dccp_decode_value_var(val, len);
1352  /*
1353  * Just ignore a value that doesn't match our current value.
1354  * If the option changes twice within two RTTs, then at least
1355  * one CONFIRM will be received for the old value after a
1356  * new CHANGE was sent.
1357  */
1358  if (fval.nn != entry->val.nn)
1359  return 0;
1360 
1361  /* Only activate after receiving the Confirm option (6.6.1). */
1362  dccp_feat_activate(sk, feat, local, &fval);
1363 
1364  /* It has been confirmed - so remove the entry */
1365  dccp_feat_list_pop(entry);
1366 
1367  } else {
1368  DCCP_WARN("Received illegal option %u\n", opt);
1369  goto fast_path_failed;
1370  }
1371  return 0;
1372 
1373 fast_path_unknown:
1374  if (!mandatory)
1375  return dccp_push_empty_confirm(fn, feat, local);
1376 
1377 fast_path_failed:
1378  return mandatory ? DCCP_RESET_CODE_MANDATORY_ERROR
1380 }
1381 
1394 int dccp_feat_parse_options(struct sock *sk, struct dccp_request_sock *dreq,
1395  u8 mandatory, u8 opt, u8 feat, u8 *val, u8 len)
1396 {
1397  struct dccp_sock *dp = dccp_sk(sk);
1398  struct list_head *fn = dreq ? &dreq->dreq_featneg : &dp->dccps_featneg;
1399  bool server = false;
1400 
1401  switch (sk->sk_state) {
1402  /*
1403  * Negotiation during connection setup
1404  */
1405  case DCCP_LISTEN:
1406  server = true; /* fall through */
1407  case DCCP_REQUESTING:
1408  switch (opt) {
1409  case DCCPO_CHANGE_L:
1410  case DCCPO_CHANGE_R:
1411  return dccp_feat_change_recv(fn, mandatory, opt, feat,
1412  val, len, server);
1413  case DCCPO_CONFIRM_R:
1414  case DCCPO_CONFIRM_L:
1415  return dccp_feat_confirm_recv(fn, mandatory, opt, feat,
1416  val, len, server);
1417  }
1418  break;
1419  /*
1420  * Support for exchanging NN options on an established connection.
1421  */
1422  case DCCP_OPEN:
1423  case DCCP_PARTOPEN:
1424  return dccp_feat_handle_nn_established(sk, mandatory, opt, feat,
1425  val, len);
1426  }
1427  return 0; /* ignore FN options in all other states */
1428 }
1429 
1440 int dccp_feat_init(struct sock *sk)
1441 {
1442  struct list_head *fn = &dccp_sk(sk)->dccps_featneg;
1443  u8 on = 1, off = 0;
1444  int rc;
1445  struct {
1446  u8 *val;
1447  u8 len;
1448  } tx, rx;
1449 
1450  /* Non-negotiable (NN) features */
1451  rc = __feat_register_nn(fn, DCCPF_SEQUENCE_WINDOW, 0,
1453  if (rc)
1454  return rc;
1455 
1456  /* Server-priority (SP) features */
1457 
1458  /* Advertise that short seqnos are not supported (7.6.1) */
1459  rc = __feat_register_sp(fn, DCCPF_SHORT_SEQNOS, true, true, &off, 1);
1460  if (rc)
1461  return rc;
1462 
1463  /* RFC 4340 12.1: "If a DCCP is not ECN capable, ..." */
1464  rc = __feat_register_sp(fn, DCCPF_ECN_INCAPABLE, true, true, &on, 1);
1465  if (rc)
1466  return rc;
1467 
1468  /*
1469  * We advertise the available list of CCIDs and reorder according to
1470  * preferences, to avoid failure resulting from negotiating different
1471  * singleton values (which always leads to failure).
1472  * These settings can still (later) be overridden via sockopts.
1473  */
1474  if (ccid_get_builtin_ccids(&tx.val, &tx.len) ||
1475  ccid_get_builtin_ccids(&rx.val, &rx.len))
1476  return -ENOBUFS;
1477 
1478  if (!dccp_feat_prefer(sysctl_dccp_tx_ccid, tx.val, tx.len) ||
1479  !dccp_feat_prefer(sysctl_dccp_rx_ccid, rx.val, rx.len))
1480  goto free_ccid_lists;
1481 
1482  rc = __feat_register_sp(fn, DCCPF_CCID, true, false, tx.val, tx.len);
1483  if (rc)
1484  goto free_ccid_lists;
1485 
1486  rc = __feat_register_sp(fn, DCCPF_CCID, false, false, rx.val, rx.len);
1487 
1488 free_ccid_lists:
1489  kfree(tx.val);
1490  kfree(rx.val);
1491  return rc;
1492 }
1493 
1494 int dccp_feat_activate_values(struct sock *sk, struct list_head *fn_list)
1495 {
1496  struct dccp_sock *dp = dccp_sk(sk);
1497  struct dccp_feat_entry *cur, *next;
1498  int idx;
1499  dccp_feat_val *fvals[DCCP_FEAT_SUPPORTED_MAX][2] = {
1500  [0 ... DCCP_FEAT_SUPPORTED_MAX-1] = { NULL, NULL }
1501  };
1502 
1503  list_for_each_entry(cur, fn_list, node) {
1504  /*
1505  * An empty Confirm means that either an unknown feature type
1506  * or an invalid value was present. In the first case there is
1507  * nothing to activate, in the other the default value is used.
1508  */
1509  if (cur->empty_confirm)
1510  continue;
1511 
1512  idx = dccp_feat_index(cur->feat_num);
1513  if (idx < 0) {
1514  DCCP_BUG("Unknown feature %u", cur->feat_num);
1515  goto activation_failed;
1516  }
1517  if (cur->state != FEAT_STABLE) {
1518  DCCP_CRIT("Negotiation of %s %s failed in state %s",
1519  cur->is_local ? "local" : "remote",
1520  dccp_feat_fname(cur->feat_num),
1521  dccp_feat_sname[cur->state]);
1522  goto activation_failed;
1523  }
1524  fvals[idx][cur->is_local] = &cur->val;
1525  }
1526 
1527  /*
1528  * Activate in decreasing order of index, so that the CCIDs are always
1529  * activated as the last feature. This avoids the case where a CCID
1530  * relies on the initialisation of one or more features that it depends
1531  * on (e.g. Send NDP Count, Send Ack Vector, and Ack Ratio features).
1532  */
1533  for (idx = DCCP_FEAT_SUPPORTED_MAX; --idx >= 0;)
1534  if (__dccp_feat_activate(sk, idx, 0, fvals[idx][0]) ||
1535  __dccp_feat_activate(sk, idx, 1, fvals[idx][1])) {
1536  DCCP_CRIT("Could not activate %d", idx);
1537  goto activation_failed;
1538  }
1539 
1540  /* Clean up Change options which have been confirmed already */
1541  list_for_each_entry_safe(cur, next, fn_list, node)
1542  if (!cur->needs_confirm)
1543  dccp_feat_list_pop(cur);
1544 
1545  dccp_pr_debug("Activation OK\n");
1546  return 0;
1547 
1548 activation_failed:
1549  /*
1550  * We clean up everything that may have been allocated, since
1551  * it is difficult to track at which stage negotiation failed.
1552  * This is ok, since all allocation functions below are robust
1553  * against NULL arguments.
1554  */
1559  dp->dccps_hc_rx_ackvec = NULL;
1560  return -1;
1561 }