自学教程：C++ DCCP_WARN函数代码示例

/** * dccp_insert_fn_opt  -  Insert single Feature-Negotiation option into @skb * @type: %DCCPO_CHANGE_L, %DCCPO_CHANGE_R, %DCCPO_CONFIRM_L, %DCCPO_CONFIRM_R * @feat: one out of %dccp_feature_numbers * @val: NN value or SP array (preferred element first) to copy * @len: true length of @val in bytes (excluding first element repetition) * @repeat_first: whether to copy the first element of @val twice * The last argument is used to construct Confirm options, where the preferred * value and the preference list appear separately (RFC 4340, 6.3.1). Preference * lists are kept such that the preferred entry is always first, so we only need * to copy twice, and avoid the overhead of cloning into a bigger array. */int dccp_insert_fn_opt(struct sk_buff *skb, u8 type, u8 feat,                       u8 *val, u8 len, bool repeat_first){    u8 tot_len, *to;    /* take the `Feature' field and possible repetition into account */    if (len > (DCCP_SINGLE_OPT_MAXLEN - 2)) {        DCCP_WARN("length %u for feature %u too large/n", len, feat);        return -1;    }    if (unlikely(val == NULL || len == 0))        len = repeat_first = false;    tot_len = 3 + repeat_first + len;    if (DCCP_SKB_CB(skb)->dccpd_opt_len + tot_len > DCCP_MAX_OPT_LEN) {        DCCP_WARN("packet too small for feature %d option!/n", feat);        return -1;    }    DCCP_SKB_CB(skb)->dccpd_opt_len += tot_len;    to    = skb_push(skb, tot_len);    *to++ = type;    *to++ = tot_len;    *to++ = feat;    if (repeat_first)        *to++ = *val;    if (len)        memcpy(to, val, len);    return 0;}

static int do_dccp_setsockopt(struct sock *sk, int level, int optname,		char __user *optval, unsigned int optlen){	struct dccp_sock *dp = dccp_sk(sk);	int val, err = 0;	switch (optname) {	case DCCP_SOCKOPT_PACKET_SIZE:		DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app/n");		return 0;	case DCCP_SOCKOPT_CHANGE_L:	case DCCP_SOCKOPT_CHANGE_R:		DCCP_WARN("sockopt(CHANGE_L/R) is deprecated: fix your app/n");		return 0;	case DCCP_SOCKOPT_CCID:	case DCCP_SOCKOPT_RX_CCID:	case DCCP_SOCKOPT_TX_CCID:		return dccp_setsockopt_ccid(sk, optname, optval, optlen);	}	if (optlen < (int)sizeof(int))		return -EINVAL;	if (get_user(val, (int __user *)optval))		return -EFAULT;	if (optname == DCCP_SOCKOPT_SERVICE)		return dccp_setsockopt_service(sk, val, optval, optlen);	lock_sock(sk);	switch (optname) {	case DCCP_SOCKOPT_SERVER_TIMEWAIT:		if (dp->dccps_role != DCCP_ROLE_SERVER)			err = -EOPNOTSUPP;		else			dp->dccps_server_timewait = (val != 0);		break;	case DCCP_SOCKOPT_SEND_CSCOV:		err = dccp_setsockopt_cscov(sk, val, false);		break;	case DCCP_SOCKOPT_RECV_CSCOV:		err = dccp_setsockopt_cscov(sk, val, true);		break;	default:		err = -ENOPROTOOPT;		break;	}	release_sock(sk);	return err;}

static int do_dccp_setsockopt(struct sock *sk, int level, int optname,		char __user *optval, int optlen){	struct dccp_sock *dp = dccp_sk(sk);	int val, err = 0;	if (optlen < sizeof(int))		return -EINVAL;	if (get_user(val, (int __user *)optval))		return -EFAULT;	if (optname == DCCP_SOCKOPT_SERVICE)		return dccp_setsockopt_service(sk, val, optval, optlen);	lock_sock(sk);	switch (optname) {	case DCCP_SOCKOPT_PACKET_SIZE:		DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app/n");		err = 0;		break;	case DCCP_SOCKOPT_CHANGE_L:		if (optlen != sizeof(struct dccp_so_feat))			err = -EINVAL;		else			err = dccp_setsockopt_change(sk, DCCPO_CHANGE_L,						     (struct dccp_so_feat __user *)						     optval);		break;	case DCCP_SOCKOPT_CHANGE_R:		if (optlen != sizeof(struct dccp_so_feat))			err = -EINVAL;		else			err = dccp_setsockopt_change(sk, DCCPO_CHANGE_R,						     (struct dccp_so_feat __user *)						     optval);		break;	case DCCP_SOCKOPT_SEND_CSCOV:	/* sender side, RFC 4340, sec. 9.2 */		if (val < 0 || val > 15)			err = -EINVAL;		else			dp->dccps_pcslen = val;		break;	case DCCP_SOCKOPT_RECV_CSCOV:	/* receiver side, RFC 4340 sec. 9.2.1 */		if (val < 0 || val > 15)			err = -EINVAL;		else {			dp->dccps_pcrlen = val;			/* FIXME: add feature negotiation,			 * ChangeL(MinimumChecksumCoverage, val) */		}		break;	default:		err = -ENOPROTOOPT;		break;	}	release_sock(sk);	return err;}

void dccp_write_xmit(struct sock *sk, int block){	struct dccp_sock *dp = dccp_sk(sk);	struct sk_buff *skb;	while ((skb = skb_peek(&sk->sk_write_queue))) {		int err = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);		if (err > 0) {			if (!block) {				sk_reset_timer(sk, &dp->dccps_xmit_timer,						msecs_to_jiffies(err)+jiffies);				break;			} else				err = dccp_wait_for_ccid(sk, skb, err);			if (err && err != -EINTR)				DCCP_BUG("err=%d after dccp_wait_for_ccid", err);		}		skb_dequeue(&sk->sk_write_queue);		if (err == 0) {			struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);			const int len = skb->len;			if (sk->sk_state == DCCP_PARTOPEN) {				const u32 cur_mps = dp->dccps_mss_cache - DCCP_FEATNEG_OVERHEAD;				/*				 * See 8.1.5 - Handshake Completion.				 *				 * For robustness we resend Confirm options until the client has				 * entered OPEN. During the initial feature negotiation, the MPS				 * is smaller than usual, reduced by the Change/Confirm options.				 */				if (!list_empty(&dp->dccps_featneg) && len > cur_mps) {					DCCP_WARN("Payload too large (%d) for featneg./n", len);					dccp_send_ack(sk);					dccp_feat_list_purge(&dp->dccps_featneg);				}				inet_csk_schedule_ack(sk);				inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,						  inet_csk(sk)->icsk_rto,						  DCCP_RTO_MAX);				dcb->dccpd_type = DCCP_PKT_DATAACK;			} else if (dccp_ack_pending(sk))				dcb->dccpd_type = DCCP_PKT_DATAACK;			else				dcb->dccpd_type = DCCP_PKT_DATA;			err = dccp_transmit_skb(sk, skb);			ccid_hc_tx_packet_sent(dp->dccps_hc_tx_ccid, sk, 0, len);			if (err)				DCCP_BUG("err=%d after ccid_hc_tx_packet_sent",					 err);		} else {			dccp_pr_debug("packet discarded due to err=%d/n", err);			kfree_skb(skb);		}	}}

/** * dccp_xmit_packet  -  Send data packet under control of CCID * Transmits next-queued payload and informs CCID to account for the packet. */static void dccp_xmit_packet(struct sock *sk){	int err, len;	struct dccp_sock *dp = dccp_sk(sk);	struct sk_buff *skb = dccp_qpolicy_pop(sk);	if (unlikely(skb == NULL))		return;	len = skb->len;	if (sk->sk_state == DCCP_PARTOPEN) {		const u32 cur_mps = dp->dccps_mss_cache - DCCP_FEATNEG_OVERHEAD;		/*		 * See 8.1.5 - Handshake Completion.		 *		 * For robustness we resend Confirm options until the client has		 * entered OPEN. During the initial feature negotiation, the MPS		 * is smaller than usual, reduced by the Change/Confirm options.		 */		if (!list_empty(&dp->dccps_featneg) && len > cur_mps) {			DCCP_WARN("Payload too large (%d) for featneg./n", len);			dccp_send_ack(sk);			dccp_feat_list_purge(&dp->dccps_featneg);		}		inet_csk_schedule_ack(sk);		inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,					      inet_csk(sk)->icsk_rto,					      DCCP_RTO_MAX);		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_DATAACK;	} else if (dccp_ack_pending(sk)) {		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_DATAACK;	} else {		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_DATA;	}	err = dccp_transmit_skb(sk, skb);	if (err)		dccp_pr_debug("transmit_skb() returned err=%d/n", err);	/*	 * Register this one as sent even if an error occurred. To the remote	 * end a local packet drop is indistinguishable from network loss, i.e.	 * any local drop will eventually be reported via receiver feedback.	 */	ccid_hc_tx_packet_sent(dp->dccps_hc_tx_ccid, sk, len);	/*	 * If the CCID needs to transfer additional header options out-of-band	 * (e.g. Ack Vectors or feature-negotiation options), it activates this	 * flag to schedule a Sync. The Sync will automatically incorporate all	 * currently pending header options, thus clearing the backlog.	 */	if (dp->dccps_sync_scheduled)		dccp_send_sync(sk, dp->dccps_gsr, DCCP_PKT_SYNC);}

static int do_dccp_getsockopt(struct sock *sk, int level, int optname,		    char __user *optval, int __user *optlen){	struct dccp_sock *dp;	int val, len;	if (get_user(len, optlen))		return -EFAULT;	if (len < (int)sizeof(int))		return -EINVAL;	dp = dccp_sk(sk);	switch (optname) {	case DCCP_SOCKOPT_PACKET_SIZE:		DCCP_WARN("sockopt(PACKET_SIZE) is deprecated: fix your app/n");		return 0;	case DCCP_SOCKOPT_SERVICE:		return dccp_getsockopt_service(sk, len,					       (__be32 __user *)optval, optlen);	case DCCP_SOCKOPT_GET_CUR_MPS:		val = dp->dccps_mss_cache;		break;	case DCCP_SOCKOPT_SERVER_TIMEWAIT:		val = dp->dccps_server_timewait;		break;	case DCCP_SOCKOPT_SEND_CSCOV:		val = dp->dccps_pcslen;		break;	case DCCP_SOCKOPT_RECV_CSCOV:		val = dp->dccps_pcrlen;		break;	case 128 ... 191:		return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,					     len, (u32 __user *)optval, optlen);	case 192 ... 255:		return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,					     len, (u32 __user *)optval, optlen);	default:		return -ENOPROTOOPT;	}	len = sizeof(val);	if (put_user(len, optlen) || copy_to_user(optval, &val, len))		return -EFAULT;	return 0;}

/** * tfrc_rx_hist_sample_rtt  -  Sample RTT from timestamp / CCVal * Based on ideas presented in RFC 4342, 8.1. Returns 0 if it was not able * to compute a sample with given data - calling function should check this. */u32 tfrc_rx_hist_sample_rtt(struct tfrc_rx_hist *h, const struct sk_buff *skb){	u32 sample = 0,	    delta_v = SUB16(dccp_hdr(skb)->dccph_ccval,			    tfrc_rx_hist_rtt_last_s(h)->tfrchrx_ccval);	if (delta_v < 1 || delta_v > 4) {	/* unsuitable CCVal delta */		if (h->rtt_sample_prev == 2) {	/* previous candidate stored */			sample = SUB16(tfrc_rx_hist_rtt_prev_s(h)->tfrchrx_ccval,				       tfrc_rx_hist_rtt_last_s(h)->tfrchrx_ccval);			if (sample)				sample = 4 / sample *				         ktime_us_delta(tfrc_rx_hist_rtt_prev_s(h)->tfrchrx_tstamp,							tfrc_rx_hist_rtt_last_s(h)->tfrchrx_tstamp);			else    /*				 * FIXME: This condition is in principle not				 * possible but occurs when CCID is used for				 * two-way data traffic. I have tried to trace				 * it, but the cause does not seem to be here.				 */				DCCP_BUG("please report to [email
C++ DCC_LOG1函数代码示例
C++ DC函数代码示例