output.c 20.1 KB
Newer Older
1 2
/*
 *  net/dccp/output.c
3
 *
4 5 6 7 8 9 10 11 12 13
 *  An implementation of the DCCP protocol
 *  Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 */

#include <linux/dccp.h>
14
#include <linux/kernel.h>
15 16
#include <linux/skbuff.h>

17
#include <net/inet_sock.h>
18 19
#include <net/sock.h>

20
#include "ackvec.h"
21 22 23 24 25 26 27 28
#include "ccid.h"
#include "dccp.h"

static inline void dccp_event_ack_sent(struct sock *sk)
{
	inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
}

29
static void dccp_skb_entail(struct sock *sk, struct sk_buff *skb)
30 31 32 33 34 35
{
	skb_set_owner_w(skb, sk);
	WARN_ON(sk->sk_send_head);
	sk->sk_send_head = skb;
}

36 37 38 39 40 41
/*
 * All SKB's seen here are completely headerless. It is our
 * job to build the DCCP header, and pass the packet down to
 * IP so it can do the same plus pass the packet off to the
 * device.
 */
42
static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb)
43 44 45
{
	if (likely(skb != NULL)) {
		const struct inet_sock *inet = inet_sk(sk);
46
		const struct inet_connection_sock *icsk = inet_csk(sk);
47 48 49 50
		struct dccp_sock *dp = dccp_sk(sk);
		struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
		struct dccp_hdr *dh;
		/* XXX For now we're using only 48 bits sequence numbers */
51
		const u32 dccp_header_size = sizeof(*dh) +
52
					     sizeof(struct dccp_hdr_ext) +
53
					  dccp_packet_hdr_len(dcb->dccpd_type);
54 55
		int err, set_ack = 1;
		u64 ackno = dp->dccps_gsr;
56 57 58 59 60
		/*
		 * Increment GSS here already in case the option code needs it.
		 * Update GSS for real only if option processing below succeeds.
		 */
		dcb->dccpd_seq = ADD48(dp->dccps_gss, 1);
61 62 63 64

		switch (dcb->dccpd_type) {
		case DCCP_PKT_DATA:
			set_ack = 0;
65 66
			/* fall through */
		case DCCP_PKT_DATAACK:
67
		case DCCP_PKT_RESET:
68
			break;
69

70 71
		case DCCP_PKT_REQUEST:
			set_ack = 0;
72 73 74
			/* Use ISS on the first (non-retransmitted) Request. */
			if (icsk->icsk_retransmits == 0)
				dcb->dccpd_seq = dp->dccps_iss;
75 76
			/* fall through */

77 78
		case DCCP_PKT_SYNC:
		case DCCP_PKT_SYNCACK:
G
Gerrit Renker 已提交
79
			ackno = dcb->dccpd_ack_seq;
80 81 82
			/* fall through */
		default:
			/*
83 84 85 86
			 * Set owner/destructor: some skbs are allocated via
			 * alloc_skb (e.g. when retransmission may happen).
			 * Only Data, DataAck, and Reset packets should come
			 * through here with skb->sk set.
87 88 89
			 */
			WARN_ON(skb->sk);
			skb_set_owner_w(skb, sk);
90 91
			break;
		}
92

93 94 95 96
		if (dccp_insert_options(sk, skb)) {
			kfree_skb(skb);
			return -EPROTO;
		}
97

98

99
		/* Build DCCP header and checksum it. */
100
		dh = dccp_zeroed_hdr(skb, dccp_header_size);
101 102 103 104 105
		dh->dccph_type	= dcb->dccpd_type;
		dh->dccph_sport	= inet->sport;
		dh->dccph_dport	= inet->dport;
		dh->dccph_doff	= (dccp_header_size + dcb->dccpd_opt_len) / 4;
		dh->dccph_ccval	= dcb->dccpd_ccval;
106
		dh->dccph_cscov = dp->dccps_pcslen;
107 108 109
		/* XXX For now we're using only 48 bits sequence numbers */
		dh->dccph_x	= 1;

110
		dccp_update_gss(sk, dcb->dccpd_seq);
111 112 113 114 115 116
		dccp_hdr_set_seq(dh, dp->dccps_gss);
		if (set_ack)
			dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), ackno);

		switch (dcb->dccpd_type) {
		case DCCP_PKT_REQUEST:
117
			dccp_hdr_request(skb)->dccph_req_service =
118
							dp->dccps_service;
119 120 121 122 123
			/*
			 * Limit Ack window to ISS <= P.ackno <= GSS, so that
			 * only Responses to Requests we sent are considered.
			 */
			dp->dccps_awl = dp->dccps_iss;
124 125
			break;
		case DCCP_PKT_RESET:
126 127
			dccp_hdr_reset(skb)->dccph_reset_code =
							dcb->dccpd_reset_code;
128 129 130
			break;
		}

131
		icsk->icsk_af_ops->send_check(sk, 0, skb);
132

133
		if (set_ack)
134 135 136 137
			dccp_event_ack_sent(sk);

		DCCP_INC_STATS(DCCP_MIB_OUTSEGS);

138
		err = icsk->icsk_af_ops->queue_xmit(skb, 0);
139
		return net_xmit_eval(err);
140 141 142 143
	}
	return -ENOBUFS;
}

G
Gerrit Renker 已提交
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
/**
 * dccp_determine_ccmps  -  Find out about CCID-specfic packet-size limits
 * We only consider the HC-sender CCID for setting the CCMPS (RFC 4340, 14.),
 * since the RX CCID is restricted to feedback packets (Acks), which are small
 * in comparison with the data traffic. A value of 0 means "no current CCMPS".
 */
static u32 dccp_determine_ccmps(const struct dccp_sock *dp)
{
	const struct ccid *tx_ccid = dp->dccps_hc_tx_ccid;

	if (tx_ccid == NULL || tx_ccid->ccid_ops == NULL)
		return 0;
	return tx_ccid->ccid_ops->ccid_ccmps;
}

159 160
unsigned int dccp_sync_mss(struct sock *sk, u32 pmtu)
{
161
	struct inet_connection_sock *icsk = inet_csk(sk);
162
	struct dccp_sock *dp = dccp_sk(sk);
G
Gerrit Renker 已提交
163
	u32 ccmps = dccp_determine_ccmps(dp);
164
	u32 cur_mps = ccmps ? min(pmtu, ccmps) : pmtu;
165

G
Gerrit Renker 已提交
166 167 168
	/* Account for header lengths and IPv4/v6 option overhead */
	cur_mps -= (icsk->icsk_af_ops->net_header_len + icsk->icsk_ext_hdr_len +
		    sizeof(struct dccp_hdr) + sizeof(struct dccp_hdr_ext));
169 170

	/*
171 172 173 174 175 176 177 178 179 180 181
	 * Leave enough headroom for common DCCP header options.
	 * This only considers options which may appear on DCCP-Data packets, as
	 * per table 3 in RFC 4340, 5.8. When running out of space for other
	 * options (eg. Ack Vector which can take up to 255 bytes), it is better
	 * to schedule a separate Ack. Thus we leave headroom for the following:
	 *  - 1 byte for Slow Receiver (11.6)
	 *  - 6 bytes for Timestamp (13.1)
	 *  - 10 bytes for Timestamp Echo (13.3)
	 *  - 8 bytes for NDP count (7.7, when activated)
	 *  - 6 bytes for Data Checksum (9.3)
	 *  - %DCCPAV_MIN_OPTLEN bytes for Ack Vector size (11.4, when enabled)
182
	 */
183 184
	cur_mps -= roundup(1 + 6 + 10 + dp->dccps_send_ndp_count * 8 + 6 +
			   (dp->dccps_hc_rx_ackvec ? DCCPAV_MIN_OPTLEN : 0), 4);
185 186

	/* And store cached results */
187
	icsk->icsk_pmtu_cookie = pmtu;
G
Gerrit Renker 已提交
188
	dp->dccps_mss_cache = cur_mps;
189

G
Gerrit Renker 已提交
190
	return cur_mps;
191 192
}

193 194
EXPORT_SYMBOL_GPL(dccp_sync_mss);

195 196 197 198 199 200 201 202
void dccp_write_space(struct sock *sk)
{
	read_lock(&sk->sk_callback_lock);

	if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
		wake_up_interruptible(sk->sk_sleep);
	/* Should agree with poll, otherwise some programs break */
	if (sock_writeable(sk))
203
		sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
204 205 206 207

	read_unlock(&sk->sk_callback_lock);
}

208
/**
209
 * dccp_wait_for_ccid  -  Await CCID send permission
G
Gerrit Renker 已提交
210
 * @sk:    socket to wait for
211 212
 * @delay: timeout in jiffies
 * This is used by CCIDs which need to delay the send time in process context.
213
 */
214
static int dccp_wait_for_ccid(struct sock *sk, unsigned long delay)
215 216
{
	DEFINE_WAIT(wait);
217
	long remaining;
218

219 220 221
	prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
	sk->sk_write_pending++;
	release_sock(sk);
G
Gerrit Renker 已提交
222

223
	remaining = schedule_timeout(delay);
224

225 226
	lock_sock(sk);
	sk->sk_write_pending--;
227
	finish_wait(sk->sk_sleep, &wait);
228 229 230 231

	if (signal_pending(current) || sk->sk_err)
		return -1;
	return remaining;
232 233
}

234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
/**
 * 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 = skb_dequeue(&sk->sk_write_queue);

	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);
}

294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
/**
 * dccp_flush_write_queue  -  Drain queue at end of connection
 * Since dccp_sendmsg queues packets without waiting for them to be sent, it may
 * happen that the TX queue is not empty at the end of a connection. We give the
 * HC-sender CCID a grace period of up to @time_budget jiffies. If this function
 * returns with a non-empty write queue, it will be purged later.
 */
void dccp_flush_write_queue(struct sock *sk, long *time_budget)
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;
	long delay, rc;

	while (*time_budget > 0 && (skb = skb_peek(&sk->sk_write_queue))) {
		rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);

		switch (ccid_packet_dequeue_eval(rc)) {
		case CCID_PACKET_WILL_DEQUEUE_LATER:
			/*
			 * If the CCID determines when to send, the next sending
			 * time is unknown or the CCID may not even send again
			 * (e.g. remote host crashes or lost Ack packets).
			 */
			DCCP_WARN("CCID did not manage to send all packets\n");
			return;
		case CCID_PACKET_DELAY:
			delay = msecs_to_jiffies(rc);
			if (delay > *time_budget)
				return;
			rc = dccp_wait_for_ccid(sk, delay);
			if (rc < 0)
				return;
			*time_budget -= (delay - rc);
			/* check again if we can send now */
			break;
		case CCID_PACKET_SEND_AT_ONCE:
			dccp_xmit_packet(sk);
			break;
		case CCID_PACKET_ERR:
			skb_dequeue(&sk->sk_write_queue);
			kfree_skb(skb);
			dccp_pr_debug("packet discarded due to err=%ld\n", rc);
		}
	}
}

void dccp_write_xmit(struct sock *sk)
341
{
I
Ian McDonald 已提交
342 343 344 345
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;

	while ((skb = skb_peek(&sk->sk_write_queue))) {
346
		int rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
347

348 349 350 351
		switch (ccid_packet_dequeue_eval(rc)) {
		case CCID_PACKET_WILL_DEQUEUE_LATER:
			return;
		case CCID_PACKET_DELAY:
352 353 354
			sk_reset_timer(sk, &dp->dccps_xmit_timer,
				       jiffies + msecs_to_jiffies(rc));
			return;
355 356 357 358 359
		case CCID_PACKET_SEND_AT_ONCE:
			dccp_xmit_packet(sk);
			break;
		case CCID_PACKET_ERR:
			skb_dequeue(&sk->sk_write_queue);
P
Patrick McHardy 已提交
360
			kfree_skb(skb);
361
			dccp_pr_debug("packet discarded due to err=%d\n", rc);
362
		}
I
Ian McDonald 已提交
363
	}
364 365
}

366 367 368 369 370 371 372 373 374 375
/**
 * dccp_retransmit_skb  -  Retransmit Request, Close, or CloseReq packets
 * There are only four retransmittable packet types in DCCP:
 * - Request  in client-REQUEST  state (sec. 8.1.1),
 * - CloseReq in server-CLOSEREQ state (sec. 8.3),
 * - Close    in   node-CLOSING  state (sec. 8.3),
 * - Acks in client-PARTOPEN state (sec. 8.1.5, handled by dccp_delack_timer()).
 * This function expects sk->sk_send_head to contain the original skb.
 */
int dccp_retransmit_skb(struct sock *sk)
376
{
377 378
	WARN_ON(sk->sk_send_head == NULL);

379
	if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk) != 0)
380 381
		return -EHOSTUNREACH; /* Routing failure or similar. */

382 383 384 385
	/* this count is used to distinguish original and retransmitted skb */
	inet_csk(sk)->icsk_retransmits++;

	return dccp_transmit_skb(sk, skb_clone(sk->sk_send_head, GFP_ATOMIC));
386 387 388 389 390 391
}

struct sk_buff *dccp_make_response(struct sock *sk, struct dst_entry *dst,
				   struct request_sock *req)
{
	struct dccp_hdr *dh;
392
	struct dccp_request_sock *dreq;
393
	const u32 dccp_header_size = sizeof(struct dccp_hdr) +
394 395
				     sizeof(struct dccp_hdr_ext) +
				     sizeof(struct dccp_hdr_response);
396
	struct sk_buff *skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1,
397 398 399 400 401
					   GFP_ATOMIC);
	if (skb == NULL)
		return NULL;

	/* Reserve space for headers. */
402
	skb_reserve(skb, sk->sk_prot->max_header);
403 404 405

	skb->dst = dst_clone(dst);

406
	dreq = dccp_rsk(req);
407 408
	if (inet_rsk(req)->acked)	/* increase ISS upon retransmission */
		dccp_inc_seqno(&dreq->dreq_iss);
409
	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_RESPONSE;
410
	DCCP_SKB_CB(skb)->dccpd_seq  = dreq->dreq_iss;
411

412 413 414 415 416 417
	/* Resolve feature dependencies resulting from choice of CCID */
	if (dccp_feat_server_ccid_dependencies(dreq))
		goto response_failed;

	if (dccp_insert_options_rsk(dreq, skb))
		goto response_failed;
418

419
	/* Build and checksum header */
420
	dh = dccp_zeroed_hdr(skb, dccp_header_size);
421 422 423

	dh->dccph_sport	= inet_sk(sk)->sport;
	dh->dccph_dport	= inet_rsk(req)->rmt_port;
424 425
	dh->dccph_doff	= (dccp_header_size +
			   DCCP_SKB_CB(skb)->dccpd_opt_len) / 4;
426 427
	dh->dccph_type	= DCCP_PKT_RESPONSE;
	dh->dccph_x	= 1;
428 429 430
	dccp_hdr_set_seq(dh, dreq->dreq_iss);
	dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), dreq->dreq_isr);
	dccp_hdr_response(skb)->dccph_resp_service = dreq->dreq_service;
431

432 433
	dccp_csum_outgoing(skb);

434 435
	/* We use `acked' to remember that a Response was already sent. */
	inet_rsk(req)->acked = 1;
436 437
	DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
	return skb;
438 439 440
response_failed:
	kfree_skb(skb);
	return NULL;
441 442
}

443 444
EXPORT_SYMBOL_GPL(dccp_make_response);

445
/* answer offending packet in @rcv_skb with Reset from control socket @ctl */
446
struct sk_buff *dccp_ctl_make_reset(struct sock *sk, struct sk_buff *rcv_skb)
447 448 449 450 451 452 453 454 455
{
	struct dccp_hdr *rxdh = dccp_hdr(rcv_skb), *dh;
	struct dccp_skb_cb *dcb = DCCP_SKB_CB(rcv_skb);
	const u32 dccp_hdr_reset_len = sizeof(struct dccp_hdr) +
				       sizeof(struct dccp_hdr_ext) +
				       sizeof(struct dccp_hdr_reset);
	struct dccp_hdr_reset *dhr;
	struct sk_buff *skb;

456
	skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
457 458 459
	if (skb == NULL)
		return NULL;

460
	skb_reserve(skb, sk->sk_prot->max_header);
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496

	/* Swap the send and the receive. */
	dh = dccp_zeroed_hdr(skb, dccp_hdr_reset_len);
	dh->dccph_type	= DCCP_PKT_RESET;
	dh->dccph_sport	= rxdh->dccph_dport;
	dh->dccph_dport	= rxdh->dccph_sport;
	dh->dccph_doff	= dccp_hdr_reset_len / 4;
	dh->dccph_x	= 1;

	dhr = dccp_hdr_reset(skb);
	dhr->dccph_reset_code = dcb->dccpd_reset_code;

	switch (dcb->dccpd_reset_code) {
	case DCCP_RESET_CODE_PACKET_ERROR:
		dhr->dccph_reset_data[0] = rxdh->dccph_type;
		break;
	case DCCP_RESET_CODE_OPTION_ERROR:	/* fall through */
	case DCCP_RESET_CODE_MANDATORY_ERROR:
		memcpy(dhr->dccph_reset_data, dcb->dccpd_reset_data, 3);
		break;
	}
	/*
	 * From RFC 4340, 8.3.1:
	 *   If P.ackno exists, set R.seqno := P.ackno + 1.
	 *   Else set R.seqno := 0.
	 */
	if (dcb->dccpd_ack_seq != DCCP_PKT_WITHOUT_ACK_SEQ)
		dccp_hdr_set_seq(dh, ADD48(dcb->dccpd_ack_seq, 1));
	dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), dcb->dccpd_seq);

	dccp_csum_outgoing(skb);
	return skb;
}

EXPORT_SYMBOL_GPL(dccp_ctl_make_reset);

497
/* send Reset on established socket, to close or abort the connection */
498 499
int dccp_send_reset(struct sock *sk, enum dccp_reset_codes code)
{
500
	struct sk_buff *skb;
501 502 503 504
	/*
	 * FIXME: what if rebuild_header fails?
	 * Should we be doing a rebuild_header here?
	 */
505
	int err = inet_csk(sk)->icsk_af_ops->rebuild_header(sk);
506

507 508 509 510 511 512 513 514 515 516 517
	if (err != 0)
		return err;

	skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1, GFP_ATOMIC);
	if (skb == NULL)
		return -ENOBUFS;

	/* Reserve space for headers and prepare control bits. */
	skb_reserve(skb, sk->sk_prot->max_header);
	DCCP_SKB_CB(skb)->dccpd_type	   = DCCP_PKT_RESET;
	DCCP_SKB_CB(skb)->dccpd_reset_code = code;
518

519
	return dccp_transmit_skb(sk, skb);
520 521
}

522 523 524
/*
 * Do all connect socket setups that can be done AF independent.
 */
525
int dccp_connect(struct sock *sk)
526
{
527
	struct sk_buff *skb;
528
	struct dccp_sock *dp = dccp_sk(sk);
529 530 531 532 533
	struct dst_entry *dst = __sk_dst_get(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);

	sk->sk_err = 0;
	sock_reset_flag(sk, SOCK_DONE);
534

535 536
	dccp_sync_mss(sk, dst_mtu(dst));

537 538 539 540
	/* do not connect if feature negotiation setup fails */
	if (dccp_feat_finalise_settings(dccp_sk(sk)))
		return -EPROTO;

541 542
	/* Initialise GAR as per 8.5; AWL/AWH are set in dccp_transmit_skb() */
	dp->dccps_gar = dp->dccps_iss;
543

544
	skb = alloc_skb(sk->sk_prot->max_header, sk->sk_allocation);
545 546 547 548
	if (unlikely(skb == NULL))
		return -ENOBUFS;

	/* Reserve space for headers. */
549
	skb_reserve(skb, sk->sk_prot->max_header);
550 551 552

	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_REQUEST;

553
	dccp_skb_entail(sk, skb);
554 555 556 557
	dccp_transmit_skb(sk, skb_clone(skb, GFP_KERNEL));
	DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS);

	/* Timer for repeating the REQUEST until an answer. */
558
	icsk->icsk_retransmits = 0;
559 560
	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
				  icsk->icsk_rto, DCCP_RTO_MAX);
561 562 563
	return 0;
}

564 565
EXPORT_SYMBOL_GPL(dccp_connect);

566 567 568 569
void dccp_send_ack(struct sock *sk)
{
	/* If we have been reset, we may not send again. */
	if (sk->sk_state != DCCP_CLOSED) {
570 571
		struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header,
						GFP_ATOMIC);
572 573 574 575

		if (skb == NULL) {
			inet_csk_schedule_ack(sk);
			inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
576 577 578
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX,
						  DCCP_RTO_MAX);
579 580 581 582
			return;
		}

		/* Reserve space for headers */
583
		skb_reserve(skb, sk->sk_prot->max_header);
584 585 586 587 588 589 590
		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_ACK;
		dccp_transmit_skb(sk, skb);
	}
}

EXPORT_SYMBOL_GPL(dccp_send_ack);

G
Gerrit Renker 已提交
591
#if 0
592
/* FIXME: Is this still necessary (11.3) - currently nowhere used by DCCP. */
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
void dccp_send_delayed_ack(struct sock *sk)
{
	struct inet_connection_sock *icsk = inet_csk(sk);
	/*
	 * FIXME: tune this timer. elapsed time fixes the skew, so no problem
	 * with using 2s, and active senders also piggyback the ACK into a
	 * DATAACK packet, so this is really for quiescent senders.
	 */
	unsigned long timeout = jiffies + 2 * HZ;

	/* Use new timeout only if there wasn't a older one earlier. */
	if (icsk->icsk_ack.pending & ICSK_ACK_TIMER) {
		/* If delack timer was blocked or is about to expire,
		 * send ACK now.
		 *
		 * FIXME: check the "about to expire" part
		 */
		if (icsk->icsk_ack.blocked) {
			dccp_send_ack(sk);
			return;
		}

		if (!time_before(timeout, icsk->icsk_ack.timeout))
			timeout = icsk->icsk_ack.timeout;
	}
	icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER;
	icsk->icsk_ack.timeout = timeout;
	sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout);
}
G
Gerrit Renker 已提交
622
#endif
623

G
Gerrit Renker 已提交
624
void dccp_send_sync(struct sock *sk, const u64 ackno,
625
		    const enum dccp_pkt_type pkt_type)
626 627 628 629 630 631
{
	/*
	 * We are not putting this on the write queue, so
	 * dccp_transmit_skb() will set the ownership to this
	 * sock.
	 */
632
	struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
633

G
Gerrit Renker 已提交
634
	if (skb == NULL) {
635
		/* FIXME: how to make sure the sync is sent? */
G
Gerrit Renker 已提交
636
		DCCP_CRIT("could not send %s", dccp_packet_name(pkt_type));
637
		return;
G
Gerrit Renker 已提交
638
	}
639 640

	/* Reserve space for headers and prepare control bits. */
641
	skb_reserve(skb, sk->sk_prot->max_header);
642
	DCCP_SKB_CB(skb)->dccpd_type = pkt_type;
G
Gerrit Renker 已提交
643
	DCCP_SKB_CB(skb)->dccpd_ack_seq = ackno;
644

645 646 647 648 649 650
	/*
	 * Clear the flag in case the Sync was scheduled for out-of-band data,
	 * such as carrying a long Ack Vector.
	 */
	dccp_sk(sk)->dccps_sync_scheduled = 0;

651 652 653
	dccp_transmit_skb(sk, skb);
}

654 655
EXPORT_SYMBOL_GPL(dccp_send_sync);

656 657 658 659
/*
 * Send a DCCP_PKT_CLOSE/CLOSEREQ. The caller locks the socket for us. This
 * cannot be allowed to fail queueing a DCCP_PKT_CLOSE/CLOSEREQ frame under
 * any circumstances.
660
 */
661
void dccp_send_close(struct sock *sk, const int active)
662 663 664
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;
A
Al Viro 已提交
665
	const gfp_t prio = active ? GFP_KERNEL : GFP_ATOMIC;
666

667 668 669
	skb = alloc_skb(sk->sk_prot->max_header, prio);
	if (skb == NULL)
		return;
670 671 672

	/* Reserve space for headers and prepare control bits. */
	skb_reserve(skb, sk->sk_prot->max_header);
673 674 675 676
	if (dp->dccps_role == DCCP_ROLE_SERVER && !dp->dccps_server_timewait)
		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_CLOSEREQ;
	else
		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_CLOSE;
677

678
	if (active) {
679
		dccp_skb_entail(sk, skb);
680
		dccp_transmit_skb(sk, skb_clone(skb, prio));
681 682 683 684 685 686 687 688 689 690 691 692
		/*
		 * Retransmission timer for active-close: RFC 4340, 8.3 requires
		 * to retransmit the Close/CloseReq until the CLOSING/CLOSEREQ
		 * state can be left. The initial timeout is 2 RTTs.
		 * Since RTT measurement is done by the CCIDs, there is no easy
		 * way to get an RTT sample. The fallback RTT from RFC 4340, 3.4
		 * is too low (200ms); we use a high value to avoid unnecessary
		 * retransmissions when the link RTT is > 0.2 seconds.
		 * FIXME: Let main module sample RTTs and use that instead.
		 */
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
					  DCCP_TIMEOUT_INIT, DCCP_RTO_MAX);
693 694
	} else
		dccp_transmit_skb(sk, skb);
695
}