output.c 17.5 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 164
	u32 ccmps = dccp_determine_ccmps(dp);
	int 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

	/*
	 * FIXME: this should come from the CCID infrastructure, where, say,
	 * TFRC will say it wants TIMESTAMPS, ELAPSED time, etc, for now lets
	 * put a rough estimate for NDP + TIMESTAMP + TIMESTAMP_ECHO + ELAPSED
	 * TIME + TFRC_OPT_LOSS_EVENT_RATE + TFRC_OPT_RECEIVE_RATE + padding to
	 * make it a multiple of 4
	 */

178
	cur_mps -= roundup(5 + 6 + 10 + 6 + 6 + 6, 4);
179 180

	/* And store cached results */
181
	icsk->icsk_pmtu_cookie = pmtu;
G
Gerrit Renker 已提交
182
	dp->dccps_mss_cache = cur_mps;
183

G
Gerrit Renker 已提交
184
	return cur_mps;
185 186
}

187 188
EXPORT_SYMBOL_GPL(dccp_sync_mss);

189 190 191 192 193 194 195 196
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))
197
		sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
198 199 200 201

	read_unlock(&sk->sk_callback_lock);
}

202 203
/**
 * dccp_wait_for_ccid - Wait for ccid to tell us we can send a packet
G
Gerrit Renker 已提交
204 205 206 207 208
 * @sk:    socket to wait for
 * @skb:   current skb to pass on for waiting
 * @delay: sleep timeout in milliseconds (> 0)
 * This function is called by default when the socket is closed, and
 * when a non-zero linger time is set on the socket. For consistency
209
 */
G
Gerrit Renker 已提交
210
static int dccp_wait_for_ccid(struct sock *sk, struct sk_buff *skb, int delay)
211 212 213
{
	struct dccp_sock *dp = dccp_sk(sk);
	DEFINE_WAIT(wait);
G
Gerrit Renker 已提交
214
	unsigned long jiffdelay;
215 216
	int rc;

G
Gerrit Renker 已提交
217 218 219 220
	do {
		dccp_pr_debug("delayed send by %d msec\n", delay);
		jiffdelay = msecs_to_jiffies(delay);

221 222
		prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);

G
Gerrit Renker 已提交
223 224 225 226 227 228
		sk->sk_write_pending++;
		release_sock(sk);
		schedule_timeout(jiffdelay);
		lock_sock(sk);
		sk->sk_write_pending--;

I
Ian McDonald 已提交
229
		if (sk->sk_err)
230 231 232 233
			goto do_error;
		if (signal_pending(current))
			goto do_interrupted;

234
		rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
G
Gerrit Renker 已提交
235
	} while ((delay = rc) > 0);
236 237 238 239 240 241 242 243
out:
	finish_wait(sk->sk_sleep, &wait);
	return rc;

do_error:
	rc = -EPIPE;
	goto out;
do_interrupted:
I
Ian McDonald 已提交
244
	rc = -EINTR;
245 246 247
	goto out;
}

I
Ian McDonald 已提交
248
void dccp_write_xmit(struct sock *sk, int block)
249
{
I
Ian McDonald 已提交
250 251 252 253
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;

	while ((skb = skb_peek(&sk->sk_write_queue))) {
254
		int err = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
255

I
Ian McDonald 已提交
256 257 258 259 260
		if (err > 0) {
			if (!block) {
				sk_reset_timer(sk, &dp->dccps_xmit_timer,
						msecs_to_jiffies(err)+jiffies);
				break;
I
Ian McDonald 已提交
261
			} else
G
Gerrit Renker 已提交
262
				err = dccp_wait_for_ccid(sk, skb, err);
263
			if (err && err != -EINTR)
264
				DCCP_BUG("err=%d after dccp_wait_for_ccid", err);
I
Ian McDonald 已提交
265
		}
266

I
Ian McDonald 已提交
267 268 269 270
		skb_dequeue(&sk->sk_write_queue);
		if (err == 0) {
			struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
			const int len = skb->len;
271

I
Ian McDonald 已提交
272 273 274 275
			if (sk->sk_state == DCCP_PARTOPEN) {
				/* See 8.1.5.  Handshake Completion */
				inet_csk_schedule_ack(sk);
				inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
276 277
						  inet_csk(sk)->icsk_rto,
						  DCCP_RTO_MAX);
I
Ian McDonald 已提交
278 279 280 281 282 283 284 285
				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);
286 287 288
			if (err)
				DCCP_BUG("err=%d after ccid_hc_tx_packet_sent",
					 err);
289
		} else {
290
			dccp_pr_debug("packet discarded due to err=%d\n", err);
P
Patrick McHardy 已提交
291
			kfree_skb(skb);
292
		}
I
Ian McDonald 已提交
293
	}
294 295
}

296 297 298 299 300 301 302 303 304 305
/**
 * 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)
306
{
307 308
	WARN_ON(sk->sk_send_head == NULL);

309
	if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk) != 0)
310 311
		return -EHOSTUNREACH; /* Routing failure or similar. */

312 313 314 315
	/* 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));
316 317 318 319 320 321
}

struct sk_buff *dccp_make_response(struct sock *sk, struct dst_entry *dst,
				   struct request_sock *req)
{
	struct dccp_hdr *dh;
322
	struct dccp_request_sock *dreq;
323
	const u32 dccp_header_size = sizeof(struct dccp_hdr) +
324 325
				     sizeof(struct dccp_hdr_ext) +
				     sizeof(struct dccp_hdr_response);
326
	struct sk_buff *skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1,
327 328 329 330 331
					   GFP_ATOMIC);
	if (skb == NULL)
		return NULL;

	/* Reserve space for headers. */
332
	skb_reserve(skb, sk->sk_prot->max_header);
333 334 335

	skb->dst = dst_clone(dst);

336
	dreq = dccp_rsk(req);
337 338
	if (inet_rsk(req)->acked)	/* increase ISS upon retransmission */
		dccp_inc_seqno(&dreq->dreq_iss);
339
	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_RESPONSE;
340
	DCCP_SKB_CB(skb)->dccpd_seq  = dreq->dreq_iss;
341

342 343 344 345 346 347
	/* 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;
348

349
	/* Build and checksum header */
350
	dh = dccp_zeroed_hdr(skb, dccp_header_size);
351

352
	dh->dccph_sport	= inet_rsk(req)->loc_port;
353
	dh->dccph_dport	= inet_rsk(req)->rmt_port;
354 355
	dh->dccph_doff	= (dccp_header_size +
			   DCCP_SKB_CB(skb)->dccpd_opt_len) / 4;
356 357
	dh->dccph_type	= DCCP_PKT_RESPONSE;
	dh->dccph_x	= 1;
358 359 360
	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;
361

362 363
	dccp_csum_outgoing(skb);

364 365
	/* We use `acked' to remember that a Response was already sent. */
	inet_rsk(req)->acked = 1;
366 367
	DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
	return skb;
368 369 370
response_failed:
	kfree_skb(skb);
	return NULL;
371 372
}

373 374
EXPORT_SYMBOL_GPL(dccp_make_response);

375
/* answer offending packet in @rcv_skb with Reset from control socket @ctl */
376
struct sk_buff *dccp_ctl_make_reset(struct sock *sk, struct sk_buff *rcv_skb)
377 378 379 380 381 382 383 384 385
{
	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;

386
	skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
387 388 389
	if (skb == NULL)
		return NULL;

390
	skb_reserve(skb, sk->sk_prot->max_header);
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426

	/* 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);

427
/* send Reset on established socket, to close or abort the connection */
428 429
int dccp_send_reset(struct sock *sk, enum dccp_reset_codes code)
{
430
	struct sk_buff *skb;
431 432 433 434
	/*
	 * FIXME: what if rebuild_header fails?
	 * Should we be doing a rebuild_header here?
	 */
435
	int err = inet_csk(sk)->icsk_af_ops->rebuild_header(sk);
436

437 438 439 440 441 442 443 444 445 446 447
	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;
448

449
	return dccp_transmit_skb(sk, skb);
450 451
}

452 453 454 455 456
/*
 * Do all connect socket setups that can be done AF independent.
 */
static inline void dccp_connect_init(struct sock *sk)
{
457
	struct dccp_sock *dp = dccp_sk(sk);
458 459 460 461 462
	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);
463

464 465
	dccp_sync_mss(sk, dst_mtu(dst));

466
	/* Initialise GAR as per 8.5; AWL/AWH are set in dccp_transmit_skb() */
467 468
	dp->dccps_gar = dp->dccps_iss;

469 470 471 472 473 474 475 476
	icsk->icsk_retransmits = 0;
}

int dccp_connect(struct sock *sk)
{
	struct sk_buff *skb;
	struct inet_connection_sock *icsk = inet_csk(sk);

477 478 479 480
	/* do not connect if feature negotiation setup fails */
	if (dccp_feat_finalise_settings(dccp_sk(sk)))
		return -EPROTO;

481 482
	dccp_connect_init(sk);

483
	skb = alloc_skb(sk->sk_prot->max_header, sk->sk_allocation);
484 485 486 487
	if (unlikely(skb == NULL))
		return -ENOBUFS;

	/* Reserve space for headers. */
488
	skb_reserve(skb, sk->sk_prot->max_header);
489 490 491

	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_REQUEST;

492
	dccp_skb_entail(sk, skb);
493 494 495 496
	dccp_transmit_skb(sk, skb_clone(skb, GFP_KERNEL));
	DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS);

	/* Timer for repeating the REQUEST until an answer. */
497 498
	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
				  icsk->icsk_rto, DCCP_RTO_MAX);
499 500 501
	return 0;
}

502 503
EXPORT_SYMBOL_GPL(dccp_connect);

504 505 506 507
void dccp_send_ack(struct sock *sk)
{
	/* If we have been reset, we may not send again. */
	if (sk->sk_state != DCCP_CLOSED) {
508 509
		struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header,
						GFP_ATOMIC);
510 511 512 513

		if (skb == NULL) {
			inet_csk_schedule_ack(sk);
			inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
514 515 516
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX,
						  DCCP_RTO_MAX);
517 518 519 520
			return;
		}

		/* Reserve space for headers */
521
		skb_reserve(skb, sk->sk_prot->max_header);
522 523 524 525 526 527 528
		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_ACK;
		dccp_transmit_skb(sk, skb);
	}
}

EXPORT_SYMBOL_GPL(dccp_send_ack);

G
Gerrit Renker 已提交
529
#if 0
530
/* FIXME: Is this still necessary (11.3) - currently nowhere used by DCCP. */
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
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 已提交
560
#endif
561

G
Gerrit Renker 已提交
562
void dccp_send_sync(struct sock *sk, const u64 ackno,
563
		    const enum dccp_pkt_type pkt_type)
564 565 566 567 568 569
{
	/*
	 * We are not putting this on the write queue, so
	 * dccp_transmit_skb() will set the ownership to this
	 * sock.
	 */
570
	struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
571

G
Gerrit Renker 已提交
572
	if (skb == NULL) {
573
		/* FIXME: how to make sure the sync is sent? */
G
Gerrit Renker 已提交
574
		DCCP_CRIT("could not send %s", dccp_packet_name(pkt_type));
575
		return;
G
Gerrit Renker 已提交
576
	}
577 578

	/* Reserve space for headers and prepare control bits. */
579
	skb_reserve(skb, sk->sk_prot->max_header);
580
	DCCP_SKB_CB(skb)->dccpd_type = pkt_type;
G
Gerrit Renker 已提交
581
	DCCP_SKB_CB(skb)->dccpd_ack_seq = ackno;
582 583 584 585

	dccp_transmit_skb(sk, skb);
}

586 587
EXPORT_SYMBOL_GPL(dccp_send_sync);

588 589 590 591
/*
 * 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.
592
 */
593
void dccp_send_close(struct sock *sk, const int active)
594 595 596
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;
A
Al Viro 已提交
597
	const gfp_t prio = active ? GFP_KERNEL : GFP_ATOMIC;
598

599 600 601
	skb = alloc_skb(sk->sk_prot->max_header, prio);
	if (skb == NULL)
		return;
602 603 604

	/* Reserve space for headers and prepare control bits. */
	skb_reserve(skb, sk->sk_prot->max_header);
605 606 607 608
	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;
609

610
	if (active) {
I
Ian McDonald 已提交
611
		dccp_write_xmit(sk, 1);
612
		dccp_skb_entail(sk, skb);
613
		dccp_transmit_skb(sk, skb_clone(skb, prio));
614 615 616 617 618 619 620 621 622 623 624 625
		/*
		 * 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);
626 627
	} else
		dccp_transmit_skb(sk, skb);
628
}