*  Feature negotiation for the DCCP protocol (RFC 4340, section 6)

 *

 *  Copyright (c) 2008 Gerrit Renker <gerrit@erg.abdn.ac.uk>

 *  Rewrote from scratch, some bits from earlier code by

 *  Copyright (c) 2005 Andrea Bittau <a.bittau@cs.ucl.ac.uk>

 *

 *  o Feature negotiation is coordinated with connection setup (as in TCP), wild

 *    changes of parameters of an established connection are not supported.

/*

 * Feature activation handlers.

 *

 * These all use an u64 argument, to provide enough room for NN/SP features. At

 * this stage the negotiated values have been checked to be within their range.

 */

static int dccp_hdlr_ccid(struct sock *sk, u64 ccid, bool rx)

	struct ccid *new_ccid = ccid_new(ccid, sk, rx);

	return 0;

}

static int dccp_hdlr_seq_win(struct sock *sk, u64 seq_win, bool rx)

{

	if (!rx)

		dccp_msk(sk)->dccpms_sequence_window = seq_win;

	return 0;

}

static int dccp_hdlr_ack_ratio(struct sock *sk, u64 ratio, bool rx)

{

	if (rx)

		dccp_sk(sk)->dccps_r_ack_ratio = ratio;

	else

		dccp_sk(sk)->dccps_l_ack_ratio = ratio;

static int dccp_hdlr_ackvec(struct sock *sk, u64 enable, bool rx)

	struct dccp_sock *dp = dccp_sk(sk);

	if (rx) {

		if (enable && dp->dccps_hc_rx_ackvec == NULL) {

			dp->dccps_hc_rx_ackvec = dccp_ackvec_alloc(gfp_any());

			if (dp->dccps_hc_rx_ackvec == NULL)

				return -ENOMEM;

		} else if (!enable) {

			dccp_ackvec_free(dp->dccps_hc_rx_ackvec);

			dp->dccps_hc_rx_ackvec = NULL;

		}

	}

	return 0;

}

static int dccp_hdlr_ndp(struct sock *sk, u64 enable, bool rx)

{

	if (!rx)

		dccp_sk(sk)->dccps_send_ndp_count = (enable > 0);

	return 0;

}

/*

 * Minimum Checksum Coverage is located at the RX side (9.2.1). This means that

 * `rx' holds when the sending peer informs about his partial coverage via a

 * ChangeR() option. In the other case, we are the sender and the receiver

 * announces its coverage via ChangeL() options. The policy here is to honour

 * such communication by enabling the corresponding partial coverage - but only

 * if it has not been set manually before; the warning here means that all

 * packets will be dropped.

 */

static int dccp_hdlr_min_cscov(struct sock *sk, u64 cscov, bool rx)

{

	struct dccp_sock *dp = dccp_sk(sk);

	if (rx)

		dp->dccps_pcrlen = cscov;

	else {

		if (dp->dccps_pcslen == 0)

			dp->dccps_pcslen = cscov;

		else if (cscov > dp->dccps_pcslen)

			DCCP_WARN("CsCov %u too small, peer requires >= %u\n",

				  dp->dccps_pcslen, (u8)cscov);

static const struct {

	u8			feat_num;		/* DCCPF_xxx */

	enum dccp_feat_type	rxtx;			/* RX or TX  */

	enum dccp_feat_type	reconciliation;		/* SP or NN  */

	u8			default_value;		/* as in 6.4 */

	int (*activation_hdlr)(struct sock *sk, u64 val, bool rx);

/*

 *    Lookup table for location and type of features (from RFC 4340/4342)

 *  +--------------------------+----+-----+----+----+---------+-----------+

 *  | Feature                  | Location | Reconc. | Initial |  Section  |

 *  |                          | RX | TX  | SP | NN |  Value  | Reference |

 *  +--------------------------+----+-----+----+----+---------+-----------+

 *  | DCCPF_CCID               |    |  X  | X  |    |   2     | 10        |

 *  | DCCPF_SHORT_SEQNOS       |    |  X  | X  |    |   0     |  7.6.1    |

 *  | DCCPF_SEQUENCE_WINDOW    |    |  X  |    | X  | 100     |  7.5.2    |

 *  | DCCPF_ECN_INCAPABLE      | X  |     | X  |    |   0     | 12.1      |

 *  | DCCPF_ACK_RATIO          |    |  X  |    | X  |   2     | 11.3      |

 *  | DCCPF_SEND_ACK_VECTOR    | X  |     | X  |    |   0     | 11.5      |

 *  | DCCPF_SEND_NDP_COUNT     |    |  X  | X  |    |   0     |  7.7.2    |

 *  | DCCPF_MIN_CSUM_COVER     | X  |     | X  |    |   0     |  9.2.1    |

 *  | DCCPF_DATA_CHECKSUM      | X  |     | X  |    |   0     |  9.3.1    |

 *  | DCCPF_SEND_LEV_RATE      | X  |     | X  |    |   0     | 4342/8.4  |

 *  +--------------------------+----+-----+----+----+---------+-----------+

 */

} dccp_feat_table[] = {

	{ DCCPF_CCID,		 FEAT_AT_TX, FEAT_SP, 2,   dccp_hdlr_ccid     },

	{ DCCPF_SHORT_SEQNOS,	 FEAT_AT_TX, FEAT_SP, 0,   NULL },

	{ DCCPF_SEQUENCE_WINDOW, FEAT_AT_TX, FEAT_NN, 100, dccp_hdlr_seq_win  },

	{ DCCPF_ECN_INCAPABLE,	 FEAT_AT_RX, FEAT_SP, 0,   NULL },

	{ DCCPF_ACK_RATIO,	 FEAT_AT_TX, FEAT_NN, 2,   dccp_hdlr_ack_ratio},

	{ DCCPF_SEND_ACK_VECTOR, FEAT_AT_RX, FEAT_SP, 0,   dccp_hdlr_ackvec   },

	{ DCCPF_SEND_NDP_COUNT,  FEAT_AT_TX, FEAT_SP, 0,   dccp_hdlr_ndp      },

	{ DCCPF_MIN_CSUM_COVER,  FEAT_AT_RX, FEAT_SP, 0,   dccp_hdlr_min_cscov},

	{ DCCPF_DATA_CHECKSUM,	 FEAT_AT_RX, FEAT_SP, 0,   NULL },

	{ DCCPF_SEND_LEV_RATE,	 FEAT_AT_RX, FEAT_SP, 0,   NULL },

};

#define DCCP_FEAT_SUPPORTED_MAX		ARRAY_SIZE(dccp_feat_table)

/**

 * dccp_feat_index  -  Hash function to map feature number into array position

 * Returns consecutive array index or -1 if the feature is not understood.

 */

static int dccp_feat_index(u8 feat_num)

{

	/* The first 9 entries are occupied by the types from RFC 4340, 6.4 */

	if (feat_num > DCCPF_RESERVED && feat_num <= DCCPF_DATA_CHECKSUM)

		return feat_num - 1;

	 * Other features: add cases for new feature types here after adding

	 * them to the above table.

	switch (feat_num) {

	case DCCPF_SEND_LEV_RATE:

			return DCCP_FEAT_SUPPORTED_MAX - 1;

	return -1;

}

static u8 dccp_feat_type(u8 feat_num)

{

	int idx = dccp_feat_index(feat_num);

	if (idx < 0)

		return FEAT_UNKNOWN;

	return dccp_feat_table[idx].reconciliation;

}

static int dccp_feat_default_value(u8 feat_num)

{

	int idx = dccp_feat_index(feat_num);

	/*

	 * There are no default values for unknown features, so encountering a

	 * negative index here indicates a serious problem somewhere else.

	 */

	DCCP_BUG_ON(idx < 0);

	return idx < 0 ? 0 : dccp_feat_table[idx].default_value;

}

static int __dccp_feat_activate(struct sock *sk, const int idx,

				const bool is_local, dccp_feat_val const *fval)

{

	bool rx;

	u64 val;

	if (idx < 0 || idx >= DCCP_FEAT_SUPPORTED_MAX)

		return -1;

	if (dccp_feat_table[idx].activation_hdlr == NULL)

		return 0;

	if (fval == NULL) {

		val = dccp_feat_table[idx].default_value;

	} else if (dccp_feat_table[idx].reconciliation == FEAT_SP) {

		if (fval->sp.vec == NULL) {

			/*

			 * This can happen when an empty Confirm is sent

			 * for an SP (i.e. known) feature. In this case

			 * we would be using the default anyway.

			 */

			DCCP_CRIT("Feature #%d undefined: using default", idx);

			val = dccp_feat_table[idx].default_value;

		} else {

			val = fval->sp.vec[0];

		val = fval->nn;

	/* Location is RX if this is a local-RX or remote-TX feature */

	rx = (is_local == (dccp_feat_table[idx].rxtx == FEAT_AT_RX));

	return dccp_feat_table[idx].activation_hdlr(sk, val, rx);

}

/* Test for "Req'd" feature (RFC 4340, 6.4) */

static inline int dccp_feat_must_be_understood(u8 feat_num)

{

	return	feat_num == DCCPF_CCID || feat_num == DCCPF_SHORT_SEQNOS ||

		feat_num == DCCPF_SEQUENCE_WINDOW;

}

/* copy constructor, fval must not already contain allocated memory */

static int dccp_feat_clone_sp_val(dccp_feat_val *fval, u8 const *val, u8 len)

{

	fval->sp.len = len;

	if (fval->sp.len > 0) {

		fval->sp.vec = kmemdup(val, len, gfp_any());

		if (fval->sp.vec == NULL) {

			fval->sp.len = 0;

			return -ENOBUFS;

		}

	}

	return 0;

}

static void dccp_feat_val_destructor(u8 feat_num, dccp_feat_val *val)

{

	if (unlikely(val == NULL))

		return;

	if (dccp_feat_type(feat_num) == FEAT_SP)

		kfree(val->sp.vec);

	memset(val, 0, sizeof(*val));

}

static struct dccp_feat_entry *

	      dccp_feat_clone_entry(struct dccp_feat_entry const *original)

{

	struct dccp_feat_entry *new;

	u8 type = dccp_feat_type(original->feat_num);

	if (type == FEAT_UNKNOWN)

		return NULL;

	new = kmemdup(original, sizeof(struct dccp_feat_entry), gfp_any());

	if (new == NULL)

		return NULL;

	if (type == FEAT_SP && dccp_feat_clone_sp_val(&new->val,

						      original->val.sp.vec,

						      original->val.sp.len)) {

		kfree(new);

		return NULL;

	return new;

}

static void dccp_feat_entry_destructor(struct dccp_feat_entry *entry)

{

	if (entry != NULL) {

		dccp_feat_val_destructor(entry->feat_num, &entry->val);

		kfree(entry);

	}

/*

 * List management functions

 *

 * Feature negotiation lists rely on and maintain the following invariants:

 * - each feat_num in the list is known, i.e. we know its type and default value

 * - each feat_num/is_local combination is unique (old entries are overwritten)

 * - SP values are always freshly allocated

 * - list is sorted in increasing order of feature number (faster lookup)

 */

static struct dccp_feat_entry *dccp_feat_list_lookup(struct list_head *fn_list,

						     u8 feat_num, bool is_local)

	struct dccp_feat_entry *entry;

	list_for_each_entry(entry, fn_list, node) {

		if (entry->feat_num == feat_num && entry->is_local == is_local)

			return entry;

		else if (entry->feat_num > feat_num)

			break;

	}

	return NULL;

}

/**

 * dccp_feat_entry_new  -  Central list update routine (called by all others)

 * @head:  list to add to

 * @feat:  feature number

 * @local: whether the local (1) or remote feature with number @feat is meant

 * This is the only constructor and serves to ensure the above invariants.

 */

static struct dccp_feat_entry *

	      dccp_feat_entry_new(struct list_head *head, u8 feat, bool local)

{

	struct dccp_feat_entry *entry;

	list_for_each_entry(entry, head, node)

		if (entry->feat_num == feat && entry->is_local == local) {

			dccp_feat_val_destructor(entry->feat_num, &entry->val);

			return entry;

		} else if (entry->feat_num > feat) {

			head = &entry->node;

			break;

		}

	entry = kmalloc(sizeof(*entry), gfp_any());

	if (entry != NULL) {

		entry->feat_num = feat;

		entry->is_local = local;

		list_add_tail(&entry->node, head);

	return entry;

/**

 * dccp_feat_push_change  -  Add/overwrite a Change option in the list

 * @fn_list: feature-negotiation list to update

 * @feat: one of %dccp_feature_numbers

 * @local: whether local (1) or remote (0) @feat_num is meant

 * @needs_mandatory: whether to use Mandatory feature negotiation options

 * @fval: pointer to NN/SP value to be inserted (will be copied)

 */

static int dccp_feat_push_change(struct list_head *fn_list, u8 feat, u8 local,

				 u8 mandatory, dccp_feat_val *fval)

	struct dccp_feat_entry *new = dccp_feat_entry_new(fn_list, feat, local);

	if (new == NULL)

	new->feat_num	     = feat;

	new->is_local	     = local;

	new->state	     = FEAT_INITIALISING;

	new->needs_confirm   = 0;

	new->empty_confirm   = 0;

	new->val	     = *fval;

	new->needs_mandatory = mandatory;

	return 0;

}

/**

 * dccp_feat_push_confirm  -  Add a Confirm entry to the FN list

 * @fn_list: feature-negotiation list to add to

 * @feat: one of %dccp_feature_numbers

 * @local: whether local (1) or remote (0) @feat_num is being confirmed

 * @fval: pointer to NN/SP value to be inserted or NULL

 * Returns 0 on success, a Reset code for further processing otherwise.

 */

static int dccp_feat_push_confirm(struct list_head *fn_list, u8 feat, u8 local,

				  dccp_feat_val *fval)

{

	struct dccp_feat_entry *new = dccp_feat_entry_new(fn_list, feat, local);

	if (new == NULL)

		return DCCP_RESET_CODE_TOO_BUSY;

	new->feat_num	     = feat;

	new->is_local	     = local;

	new->state	     = FEAT_STABLE;	/* transition in 6.6.2 */

	new->needs_confirm   = 1;

	new->empty_confirm   = (fval == NULL);

	new->val.nn	     = 0;		/* zeroes the whole structure */

	if (!new->empty_confirm)

		new->val     = *fval;

	new->needs_mandatory = 0;

static int dccp_push_empty_confirm(struct list_head *fn_list, u8 feat, u8 local)

	return dccp_feat_push_confirm(fn_list, feat, local, NULL);

}

static inline void dccp_feat_list_pop(struct dccp_feat_entry *entry)

{

	list_del(&entry->node);

	dccp_feat_entry_destructor(entry);

}

void dccp_feat_list_purge(struct list_head *fn_list)

{

	struct dccp_feat_entry *entry, *next;

	list_for_each_entry_safe(entry, next, fn_list, node)

		dccp_feat_entry_destructor(entry);

	INIT_LIST_HEAD(fn_list);

}

EXPORT_SYMBOL_GPL(dccp_feat_list_purge);

/* generate @to as full clone of @from - @to must not contain any nodes */

int dccp_feat_clone_list(struct list_head const *from, struct list_head *to)

{

	struct dccp_feat_entry *entry, *new;

	INIT_LIST_HEAD(to);

	list_for_each_entry(entry, from, node) {

		new = dccp_feat_clone_entry(entry);

		if (new == NULL)

			goto cloning_failed;

		list_add_tail(&new->node, to);

	return 0;

cloning_failed:

	dccp_feat_list_purge(to);

	return -ENOMEM;

}

/**

 * dccp_feat_valid_nn_length  -  Enforce length constraints on NN options

 * Length is between 0 and %DCCP_OPTVAL_MAXLEN. Used for outgoing packets only,

 * incoming options are accepted as long as their values are valid.

 */

static u8 dccp_feat_valid_nn_length(u8 feat_num)

{

	if (feat_num == DCCPF_ACK_RATIO)	/* RFC 4340, 11.3 and 6.6.8 */

		return 2;

	if (feat_num == DCCPF_SEQUENCE_WINDOW)	/* RFC 4340, 7.5.2 and 6.5  */

		return 6;

	return 0;

}

static u8 dccp_feat_is_valid_nn_val(u8 feat_num, u64 val)

{

	switch (feat_num) {

	case DCCPF_ACK_RATIO:

		return val <= DCCPF_ACK_RATIO_MAX;

	case DCCPF_SEQUENCE_WINDOW:

		return val >= DCCPF_SEQ_WMIN && val <= DCCPF_SEQ_WMAX;

	}

	return 0;	/* feature unknown - so we can't tell */

/* check that SP values are within the ranges defined in RFC 4340 */

static u8 dccp_feat_is_valid_sp_val(u8 feat_num, u8 val)

	switch (feat_num) {

	case DCCPF_CCID:

		return val == DCCPC_CCID2 || val == DCCPC_CCID3;

	/* Type-check Boolean feature values: */

	case DCCPF_SHORT_SEQNOS:

	case DCCPF_ECN_INCAPABLE:

	case DCCPF_SEND_ACK_VECTOR:

	case DCCPF_SEND_NDP_COUNT:

	case DCCPF_DATA_CHECKSUM:

	case DCCPF_SEND_LEV_RATE:

		return val < 2;

	case DCCPF_MIN_CSUM_COVER:

		return val < 16;

	}

	return 0;			/* feature unknown */

}

static u8 dccp_feat_sp_list_ok(u8 feat_num, u8 const *sp_list, u8 sp_len)

{

	if (sp_list == NULL || sp_len < 1)

		return 0;

	while (sp_len--)

		if (!dccp_feat_is_valid_sp_val(feat_num, *sp_list++))

			return 0;

	return 1;

}