output.c 17.2 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 56 57 58 59 60 61
		int err, set_ack = 1;
		u64 ackno = dp->dccps_gsr;

		dccp_inc_seqno(&dp->dccps_gss);

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

67 68 69 70
		case DCCP_PKT_REQUEST:
			set_ack = 0;
			/* fall through */

71 72
		case DCCP_PKT_SYNC:
		case DCCP_PKT_SYNCACK:
G
Gerrit Renker 已提交
73
			ackno = dcb->dccpd_ack_seq;
74 75 76
			/* fall through */
		default:
			/*
77 78 79 80
			 * 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.
81 82 83
			 */
			WARN_ON(skb->sk);
			skb_set_owner_w(skb, sk);
84 85
			break;
		}
86 87

		dcb->dccpd_seq = dp->dccps_gss;
88 89 90 91 92

		if (dccp_insert_options(sk, skb)) {
			kfree_skb(skb);
			return -EPROTO;
		}
93

94

95
		/* Build DCCP header and checksum it. */
96
		dh = dccp_zeroed_hdr(skb, dccp_header_size);
97 98 99 100 101
		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;
102
		dh->dccph_cscov = dp->dccps_pcslen;
103 104 105 106 107 108 109 110 111 112
		/* XXX For now we're using only 48 bits sequence numbers */
		dh->dccph_x	= 1;

		dp->dccps_awh = dp->dccps_gss;
		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:
113
			dccp_hdr_request(skb)->dccph_req_service =
114
							dp->dccps_service;
115 116
			break;
		case DCCP_PKT_RESET:
117 118
			dccp_hdr_reset(skb)->dccph_reset_code =
							dcb->dccpd_reset_code;
119 120 121
			break;
		}

122
		icsk->icsk_af_ops->send_check(sk, 0, skb);
123

124
		if (set_ack)
125 126 127 128
			dccp_event_ack_sent(sk);

		DCCP_INC_STATS(DCCP_MIB_OUTSEGS);

129
		err = icsk->icsk_af_ops->queue_xmit(skb, 0);
130
		return net_xmit_eval(err);
131 132 133 134
	}
	return -ENOBUFS;
}

G
Gerrit Renker 已提交
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
/**
 * 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;
}

150 151
unsigned int dccp_sync_mss(struct sock *sk, u32 pmtu)
{
152
	struct inet_connection_sock *icsk = inet_csk(sk);
153
	struct dccp_sock *dp = dccp_sk(sk);
G
Gerrit Renker 已提交
154 155
	u32 ccmps = dccp_determine_ccmps(dp);
	int cur_mps = ccmps ? min(pmtu, ccmps) : pmtu;
156

G
Gerrit Renker 已提交
157 158 159
	/* 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));
160 161 162 163 164 165 166 167 168

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

G
Gerrit Renker 已提交
169
	cur_mps -= ((5 + 6 + 10 + 6 + 6 + 6 + 3) / 4) * 4;
170 171

	/* And store cached results */
172
	icsk->icsk_pmtu_cookie = pmtu;
G
Gerrit Renker 已提交
173
	dp->dccps_mss_cache = cur_mps;
174

G
Gerrit Renker 已提交
175
	return cur_mps;
176 177
}

178 179
EXPORT_SYMBOL_GPL(dccp_sync_mss);

180 181 182 183 184 185 186 187
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))
188
		sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
189 190 191 192

	read_unlock(&sk->sk_callback_lock);
}

193 194
/**
 * dccp_wait_for_ccid - Wait for ccid to tell us we can send a packet
G
Gerrit Renker 已提交
195 196 197 198 199
 * @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
200
 */
G
Gerrit Renker 已提交
201
static int dccp_wait_for_ccid(struct sock *sk, struct sk_buff *skb, int delay)
202 203 204
{
	struct dccp_sock *dp = dccp_sk(sk);
	DEFINE_WAIT(wait);
G
Gerrit Renker 已提交
205
	unsigned long jiffdelay;
206 207
	int rc;

G
Gerrit Renker 已提交
208 209 210 211
	do {
		dccp_pr_debug("delayed send by %d msec\n", delay);
		jiffdelay = msecs_to_jiffies(delay);

212 213
		prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);

G
Gerrit Renker 已提交
214 215 216 217 218 219
		sk->sk_write_pending++;
		release_sock(sk);
		schedule_timeout(jiffdelay);
		lock_sock(sk);
		sk->sk_write_pending--;

I
Ian McDonald 已提交
220
		if (sk->sk_err)
221 222 223 224
			goto do_error;
		if (signal_pending(current))
			goto do_interrupted;

225
		rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
G
Gerrit Renker 已提交
226
	} while ((delay = rc) > 0);
227 228 229 230 231 232 233 234
out:
	finish_wait(sk->sk_sleep, &wait);
	return rc;

do_error:
	rc = -EPIPE;
	goto out;
do_interrupted:
I
Ian McDonald 已提交
235
	rc = -EINTR;
236 237 238
	goto out;
}

I
Ian McDonald 已提交
239
void dccp_write_xmit(struct sock *sk, int block)
240
{
I
Ian McDonald 已提交
241 242 243 244
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;

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

I
Ian McDonald 已提交
247 248 249 250 251
		if (err > 0) {
			if (!block) {
				sk_reset_timer(sk, &dp->dccps_xmit_timer,
						msecs_to_jiffies(err)+jiffies);
				break;
I
Ian McDonald 已提交
252
			} else
G
Gerrit Renker 已提交
253
				err = dccp_wait_for_ccid(sk, skb, err);
254
			if (err && err != -EINTR)
255
				DCCP_BUG("err=%d after dccp_wait_for_ccid", err);
I
Ian McDonald 已提交
256
		}
257

I
Ian McDonald 已提交
258 259 260 261
		skb_dequeue(&sk->sk_write_queue);
		if (err == 0) {
			struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
			const int len = skb->len;
262

I
Ian McDonald 已提交
263 264 265 266
			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,
267 268
						  inet_csk(sk)->icsk_rto,
						  DCCP_RTO_MAX);
I
Ian McDonald 已提交
269 270 271 272 273 274 275 276
				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);
277 278 279
			if (err)
				DCCP_BUG("err=%d after ccid_hc_tx_packet_sent",
					 err);
280
		} else {
281
			dccp_pr_debug("packet discarded due to err=%d\n", err);
P
Patrick McHardy 已提交
282
			kfree_skb(skb);
283
		}
I
Ian McDonald 已提交
284
	}
285 286
}

287 288 289 290 291 292 293 294 295 296
/**
 * 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)
297
{
298 299
	WARN_ON(sk->sk_send_head == NULL);

300
	if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk) != 0)
301 302
		return -EHOSTUNREACH; /* Routing failure or similar. */

303 304 305 306
	/* 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));
307 308 309 310 311 312
}

struct sk_buff *dccp_make_response(struct sock *sk, struct dst_entry *dst,
				   struct request_sock *req)
{
	struct dccp_hdr *dh;
313
	struct dccp_request_sock *dreq;
314
	const u32 dccp_header_size = sizeof(struct dccp_hdr) +
315 316
				     sizeof(struct dccp_hdr_ext) +
				     sizeof(struct dccp_hdr_response);
317
	struct sk_buff *skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1,
318 319 320 321 322
					   GFP_ATOMIC);
	if (skb == NULL)
		return NULL;

	/* Reserve space for headers. */
323
	skb_reserve(skb, sk->sk_prot->max_header);
324 325 326

	skb->dst = dst_clone(dst);

327
	dreq = dccp_rsk(req);
328 329
	if (inet_rsk(req)->acked)	/* increase ISS upon retransmission */
		dccp_inc_seqno(&dreq->dreq_iss);
330
	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_RESPONSE;
331
	DCCP_SKB_CB(skb)->dccpd_seq  = dreq->dreq_iss;
332

333
	if (dccp_insert_options_rsk(dreq, skb)) {
334 335 336
		kfree_skb(skb);
		return NULL;
	}
337

338
	/* Build and checksum header */
339
	dh = dccp_zeroed_hdr(skb, dccp_header_size);
340 341 342

	dh->dccph_sport	= inet_sk(sk)->sport;
	dh->dccph_dport	= inet_rsk(req)->rmt_port;
343 344
	dh->dccph_doff	= (dccp_header_size +
			   DCCP_SKB_CB(skb)->dccpd_opt_len) / 4;
345 346
	dh->dccph_type	= DCCP_PKT_RESPONSE;
	dh->dccph_x	= 1;
347 348 349
	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;
350

351 352
	dccp_csum_outgoing(skb);

353 354
	/* We use `acked' to remember that a Response was already sent. */
	inet_rsk(req)->acked = 1;
355 356 357 358
	DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
	return skb;
}

359 360
EXPORT_SYMBOL_GPL(dccp_make_response);

361
/* answer offending packet in @rcv_skb with Reset from control socket @ctl */
362
struct sk_buff *dccp_ctl_make_reset(struct sock *sk, struct sk_buff *rcv_skb)
363 364 365 366 367 368 369 370 371
{
	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;

372
	skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
373 374 375
	if (skb == NULL)
		return NULL;

376
	skb_reserve(skb, sk->sk_prot->max_header);
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412

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

413
/* send Reset on established socket, to close or abort the connection */
414 415
int dccp_send_reset(struct sock *sk, enum dccp_reset_codes code)
{
416
	struct sk_buff *skb;
417 418 419 420
	/*
	 * FIXME: what if rebuild_header fails?
	 * Should we be doing a rebuild_header here?
	 */
421
	int err = inet_csk(sk)->icsk_af_ops->rebuild_header(sk);
422

423 424 425 426 427 428 429 430 431 432 433
	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;
434

435
	return dccp_transmit_skb(sk, skb);
436 437
}

438 439 440 441 442
/*
 * Do all connect socket setups that can be done AF independent.
 */
static inline void dccp_connect_init(struct sock *sk)
{
443
	struct dccp_sock *dp = dccp_sk(sk);
444 445 446 447 448
	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);
449

450 451
	dccp_sync_mss(sk, dst_mtu(dst));

452
	/*
453 454 455 456 457 458
	 * SWL and AWL are initially adjusted so that they are not less than
	 * the initial Sequence Numbers received and sent, respectively:
	 *	SWL := max(GSR + 1 - floor(W/4), ISR),
	 *	AWL := max(GSS - W' + 1, ISS).
	 * These adjustments MUST be applied only at the beginning of the
	 * connection.
459
	 */
460
	dccp_update_gss(sk, dp->dccps_iss);
461
	dccp_set_seqno(&dp->dccps_awl, max48(dp->dccps_awl, dp->dccps_iss));
462

463 464 465 466
	/* S.GAR - greatest valid acknowledgement number received on a non-Sync;
	 *         initialized to S.ISS (sec. 8.5)                            */
	dp->dccps_gar = dp->dccps_iss;

467 468 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);

	dccp_connect_init(sk);

477
	skb = alloc_skb(sk->sk_prot->max_header, sk->sk_allocation);
478 479 480 481
	if (unlikely(skb == NULL))
		return -ENOBUFS;

	/* Reserve space for headers. */
482
	skb_reserve(skb, sk->sk_prot->max_header);
483 484 485

	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_REQUEST;

486
	dccp_skb_entail(sk, skb);
487 488 489 490
	dccp_transmit_skb(sk, skb_clone(skb, GFP_KERNEL));
	DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS);

	/* Timer for repeating the REQUEST until an answer. */
491 492
	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
				  icsk->icsk_rto, DCCP_RTO_MAX);
493 494 495
	return 0;
}

496 497
EXPORT_SYMBOL_GPL(dccp_connect);

498 499 500 501
void dccp_send_ack(struct sock *sk)
{
	/* If we have been reset, we may not send again. */
	if (sk->sk_state != DCCP_CLOSED) {
502 503
		struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header,
						GFP_ATOMIC);
504 505 506 507

		if (skb == NULL) {
			inet_csk_schedule_ack(sk);
			inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
508 509 510
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX,
						  DCCP_RTO_MAX);
511 512 513 514
			return;
		}

		/* Reserve space for headers */
515
		skb_reserve(skb, sk->sk_prot->max_header);
516 517 518 519 520 521 522
		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_ACK;
		dccp_transmit_skb(sk, skb);
	}
}

EXPORT_SYMBOL_GPL(dccp_send_ack);

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

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

G
Gerrit Renker 已提交
566
	if (skb == NULL) {
567
		/* FIXME: how to make sure the sync is sent? */
G
Gerrit Renker 已提交
568
		DCCP_CRIT("could not send %s", dccp_packet_name(pkt_type));
569
		return;
G
Gerrit Renker 已提交
570
	}
571 572

	/* Reserve space for headers and prepare control bits. */
573
	skb_reserve(skb, sk->sk_prot->max_header);
574
	DCCP_SKB_CB(skb)->dccpd_type = pkt_type;
G
Gerrit Renker 已提交
575
	DCCP_SKB_CB(skb)->dccpd_ack_seq = ackno;
576 577 578 579

	dccp_transmit_skb(sk, skb);
}

580 581
EXPORT_SYMBOL_GPL(dccp_send_sync);

582 583 584 585
/*
 * 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.
586
 */
587
void dccp_send_close(struct sock *sk, const int active)
588 589 590
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;
A
Al Viro 已提交
591
	const gfp_t prio = active ? GFP_KERNEL : GFP_ATOMIC;
592

593 594 595
	skb = alloc_skb(sk->sk_prot->max_header, prio);
	if (skb == NULL)
		return;
596 597 598

	/* Reserve space for headers and prepare control bits. */
	skb_reserve(skb, sk->sk_prot->max_header);
599 600 601 602
	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;
603

604
	if (active) {
I
Ian McDonald 已提交
605
		dccp_write_xmit(sk, 1);
606
		dccp_skb_entail(sk, skb);
607
		dccp_transmit_skb(sk, skb_clone(skb, prio));
608 609 610 611 612 613 614 615 616 617 618 619
		/*
		 * 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);
620 621
	} else
		dccp_transmit_skb(sk, skb);
622
}