output.c 19.0 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
#include <linux/skbuff.h>
16
#include <linux/slab.h>
17

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

21
#include "ackvec.h"
22 23 24 25 26 27 28 29
#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);
}

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

37 38 39 40 41 42
/*
 * 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.
 */
43
static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb)
44 45 46
{
	if (likely(skb != NULL)) {
		const struct inet_sock *inet = inet_sk(sk);
47
		const struct inet_connection_sock *icsk = inet_csk(sk);
48 49 50 51
		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 */
52
		const u32 dccp_header_size = sizeof(*dh) +
53
					     sizeof(struct dccp_hdr_ext) +
54
					  dccp_packet_hdr_len(dcb->dccpd_type);
55 56
		int err, set_ack = 1;
		u64 ackno = dp->dccps_gsr;
57 58 59 60 61
		/*
		 * 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);
62 63 64 65

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

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

78 79
		case DCCP_PKT_SYNC:
		case DCCP_PKT_SYNCACK:
G
Gerrit Renker 已提交
80
			ackno = dcb->dccpd_ack_seq;
81 82 83
			/* fall through */
		default:
			/*
84 85 86 87
			 * 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.
88 89 90
			 */
			WARN_ON(skb->sk);
			skb_set_owner_w(skb, sk);
91 92
			break;
		}
93

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

99

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

111
		dccp_update_gss(sk, dcb->dccpd_seq);
112 113 114 115 116 117
		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:
118
			dccp_hdr_request(skb)->dccph_req_service =
119
							dp->dccps_service;
120 121 122 123 124
			/*
			 * Limit Ack window to ISS <= P.ackno <= GSS, so that
			 * only Responses to Requests we sent are considered.
			 */
			dp->dccps_awl = dp->dccps_iss;
125 126
			break;
		case DCCP_PKT_RESET:
127 128
			dccp_hdr_reset(skb)->dccph_reset_code =
							dcb->dccpd_reset_code;
129 130 131
			break;
		}

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

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

		DCCP_INC_STATS(DCCP_MIB_OUTSEGS);

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

G
Gerrit Renker 已提交
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
/**
 * 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;
}

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

G
Gerrit Renker 已提交
167 168 169
	/* 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));
170 171

	/*
172 173 174 175 176 177 178 179 180 181 182
	 * 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)
183
	 */
184 185
	cur_mps -= roundup(1 + 6 + 10 + dp->dccps_send_ndp_count * 8 + 6 +
			   (dp->dccps_hc_rx_ackvec ? DCCPAV_MIN_OPTLEN : 0), 4);
186 187

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

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

194 195
EXPORT_SYMBOL_GPL(dccp_sync_mss);

196 197
void dccp_write_space(struct sock *sk)
{
198
	struct socket_wq *wq;
199

200 201 202 203
	rcu_read_lock();
	wq = rcu_dereference(sk->sk_wq);
	if (wq_has_sleeper(wq))
		wake_up_interruptible(&wq->wait);
204 205
	/* Should agree with poll, otherwise some programs break */
	if (sock_writeable(sk))
206
		sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
207

208
	rcu_read_unlock();
209 210
}

211 212
/**
 * dccp_wait_for_ccid - Wait for ccid to tell us we can send a packet
G
Gerrit Renker 已提交
213 214 215 216 217
 * @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
218
 */
G
Gerrit Renker 已提交
219
static int dccp_wait_for_ccid(struct sock *sk, struct sk_buff *skb, int delay)
220 221 222
{
	struct dccp_sock *dp = dccp_sk(sk);
	DEFINE_WAIT(wait);
G
Gerrit Renker 已提交
223
	unsigned long jiffdelay;
224 225
	int rc;

G
Gerrit Renker 已提交
226 227 228 229
	do {
		dccp_pr_debug("delayed send by %d msec\n", delay);
		jiffdelay = msecs_to_jiffies(delay);

E
Eric Dumazet 已提交
230
		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
231

G
Gerrit Renker 已提交
232 233 234 235 236 237
		sk->sk_write_pending++;
		release_sock(sk);
		schedule_timeout(jiffdelay);
		lock_sock(sk);
		sk->sk_write_pending--;

I
Ian McDonald 已提交
238
		if (sk->sk_err)
239 240 241 242
			goto do_error;
		if (signal_pending(current))
			goto do_interrupted;

243
		rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
G
Gerrit Renker 已提交
244
	} while ((delay = rc) > 0);
245
out:
E
Eric Dumazet 已提交
246
	finish_wait(sk_sleep(sk), &wait);
247 248 249 250 251 252
	return rc;

do_error:
	rc = -EPIPE;
	goto out;
do_interrupted:
I
Ian McDonald 已提交
253
	rc = -EINTR;
254 255 256
	goto out;
}

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 294 295 296 297 298 299 300 301 302 303 304 305 306 307
/**
 * 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);
}

I
Ian McDonald 已提交
308
void dccp_write_xmit(struct sock *sk, int block)
309
{
I
Ian McDonald 已提交
310 311 312 313
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;

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

316 317 318 319
		switch (ccid_packet_dequeue_eval(rc)) {
		case CCID_PACKET_WILL_DEQUEUE_LATER:
			return;
		case CCID_PACKET_DELAY:
I
Ian McDonald 已提交
320 321
			if (!block) {
				sk_reset_timer(sk, &dp->dccps_xmit_timer,
322 323 324 325 326 327 328 329
						msecs_to_jiffies(rc)+jiffies);
				return;
			}
			rc = dccp_wait_for_ccid(sk, skb, rc);
			if (rc && rc != -EINTR) {
				DCCP_BUG("err=%d after dccp_wait_for_ccid", rc);
				skb_dequeue(&sk->sk_write_queue);
				kfree_skb(skb);
I
Ian McDonald 已提交
330
				break;
331 332 333 334 335 336 337
			}
			/* fall through */
		case CCID_PACKET_SEND_AT_ONCE:
			dccp_xmit_packet(sk);
			break;
		case CCID_PACKET_ERR:
			skb_dequeue(&sk->sk_write_queue);
P
Patrick McHardy 已提交
338
			kfree_skb(skb);
339
			dccp_pr_debug("packet discarded due to err=%d\n", rc);
340
		}
I
Ian McDonald 已提交
341
	}
342 343
}

344 345 346 347 348 349 350 351 352 353
/**
 * 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)
354
{
355 356
	WARN_ON(sk->sk_send_head == NULL);

357
	if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk) != 0)
358 359
		return -EHOSTUNREACH; /* Routing failure or similar. */

360 361 362 363
	/* 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));
364 365 366 367 368 369
}

struct sk_buff *dccp_make_response(struct sock *sk, struct dst_entry *dst,
				   struct request_sock *req)
{
	struct dccp_hdr *dh;
370
	struct dccp_request_sock *dreq;
371
	const u32 dccp_header_size = sizeof(struct dccp_hdr) +
372 373
				     sizeof(struct dccp_hdr_ext) +
				     sizeof(struct dccp_hdr_response);
374
	struct sk_buff *skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1,
375 376 377 378 379
					   GFP_ATOMIC);
	if (skb == NULL)
		return NULL;

	/* Reserve space for headers. */
380
	skb_reserve(skb, sk->sk_prot->max_header);
381

E
Eric Dumazet 已提交
382
	skb_dst_set(skb, dst_clone(dst));
383

384
	dreq = dccp_rsk(req);
385 386
	if (inet_rsk(req)->acked)	/* increase ISS upon retransmission */
		dccp_inc_seqno(&dreq->dreq_iss);
387
	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_RESPONSE;
388
	DCCP_SKB_CB(skb)->dccpd_seq  = dreq->dreq_iss;
389

390 391 392 393 394 395
	/* 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;
396

397
	/* Build and checksum header */
398
	dh = dccp_zeroed_hdr(skb, dccp_header_size);
399

400
	dh->dccph_sport	= inet_rsk(req)->loc_port;
401
	dh->dccph_dport	= inet_rsk(req)->rmt_port;
402 403
	dh->dccph_doff	= (dccp_header_size +
			   DCCP_SKB_CB(skb)->dccpd_opt_len) / 4;
404 405
	dh->dccph_type	= DCCP_PKT_RESPONSE;
	dh->dccph_x	= 1;
406 407 408
	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;
409

410 411
	dccp_csum_outgoing(skb);

412 413
	/* We use `acked' to remember that a Response was already sent. */
	inet_rsk(req)->acked = 1;
414 415
	DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
	return skb;
416 417 418
response_failed:
	kfree_skb(skb);
	return NULL;
419 420
}

421 422
EXPORT_SYMBOL_GPL(dccp_make_response);

423
/* answer offending packet in @rcv_skb with Reset from control socket @ctl */
424
struct sk_buff *dccp_ctl_make_reset(struct sock *sk, struct sk_buff *rcv_skb)
425 426 427 428 429 430 431 432 433
{
	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;

434
	skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
435 436 437
	if (skb == NULL)
		return NULL;

438
	skb_reserve(skb, sk->sk_prot->max_header);
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474

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

475
/* send Reset on established socket, to close or abort the connection */
476 477
int dccp_send_reset(struct sock *sk, enum dccp_reset_codes code)
{
478
	struct sk_buff *skb;
479 480 481 482
	/*
	 * FIXME: what if rebuild_header fails?
	 * Should we be doing a rebuild_header here?
	 */
483
	int err = inet_csk(sk)->icsk_af_ops->rebuild_header(sk);
484

485 486 487 488 489 490 491 492 493 494 495
	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;
496

497
	return dccp_transmit_skb(sk, skb);
498 499
}

500 501 502
/*
 * Do all connect socket setups that can be done AF independent.
 */
503
int dccp_connect(struct sock *sk)
504
{
505
	struct sk_buff *skb;
506
	struct dccp_sock *dp = dccp_sk(sk);
507 508 509 510 511
	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);
512

513 514
	dccp_sync_mss(sk, dst_mtu(dst));

515 516 517 518
	/* do not connect if feature negotiation setup fails */
	if (dccp_feat_finalise_settings(dccp_sk(sk)))
		return -EPROTO;

519 520
	/* Initialise GAR as per 8.5; AWL/AWH are set in dccp_transmit_skb() */
	dp->dccps_gar = dp->dccps_iss;
521

522
	skb = alloc_skb(sk->sk_prot->max_header, sk->sk_allocation);
523 524 525 526
	if (unlikely(skb == NULL))
		return -ENOBUFS;

	/* Reserve space for headers. */
527
	skb_reserve(skb, sk->sk_prot->max_header);
528 529 530

	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_REQUEST;

531
	dccp_skb_entail(sk, skb);
532 533 534 535
	dccp_transmit_skb(sk, skb_clone(skb, GFP_KERNEL));
	DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS);

	/* Timer for repeating the REQUEST until an answer. */
536
	icsk->icsk_retransmits = 0;
537 538
	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
				  icsk->icsk_rto, DCCP_RTO_MAX);
539 540 541
	return 0;
}

542 543
EXPORT_SYMBOL_GPL(dccp_connect);

544 545 546 547
void dccp_send_ack(struct sock *sk)
{
	/* If we have been reset, we may not send again. */
	if (sk->sk_state != DCCP_CLOSED) {
548 549
		struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header,
						GFP_ATOMIC);
550 551 552 553

		if (skb == NULL) {
			inet_csk_schedule_ack(sk);
			inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
554 555 556
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX,
						  DCCP_RTO_MAX);
557 558 559 560
			return;
		}

		/* Reserve space for headers */
561
		skb_reserve(skb, sk->sk_prot->max_header);
562 563 564 565 566 567 568
		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_ACK;
		dccp_transmit_skb(sk, skb);
	}
}

EXPORT_SYMBOL_GPL(dccp_send_ack);

G
Gerrit Renker 已提交
569
#if 0
570
/* FIXME: Is this still necessary (11.3) - currently nowhere used by DCCP. */
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
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 已提交
600
#endif
601

G
Gerrit Renker 已提交
602
void dccp_send_sync(struct sock *sk, const u64 ackno,
603
		    const enum dccp_pkt_type pkt_type)
604 605 606 607 608 609
{
	/*
	 * We are not putting this on the write queue, so
	 * dccp_transmit_skb() will set the ownership to this
	 * sock.
	 */
610
	struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
611

G
Gerrit Renker 已提交
612
	if (skb == NULL) {
613
		/* FIXME: how to make sure the sync is sent? */
G
Gerrit Renker 已提交
614
		DCCP_CRIT("could not send %s", dccp_packet_name(pkt_type));
615
		return;
G
Gerrit Renker 已提交
616
	}
617 618

	/* Reserve space for headers and prepare control bits. */
619
	skb_reserve(skb, sk->sk_prot->max_header);
620
	DCCP_SKB_CB(skb)->dccpd_type = pkt_type;
G
Gerrit Renker 已提交
621
	DCCP_SKB_CB(skb)->dccpd_ack_seq = ackno;
622 623 624 625

	dccp_transmit_skb(sk, skb);
}

626 627
EXPORT_SYMBOL_GPL(dccp_send_sync);

628 629 630 631
/*
 * 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.
632
 */
633
void dccp_send_close(struct sock *sk, const int active)
634 635 636
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;
A
Al Viro 已提交
637
	const gfp_t prio = active ? GFP_KERNEL : GFP_ATOMIC;
638

639 640 641
	skb = alloc_skb(sk->sk_prot->max_header, prio);
	if (skb == NULL)
		return;
642 643 644

	/* Reserve space for headers and prepare control bits. */
	skb_reserve(skb, sk->sk_prot->max_header);
645 646 647 648
	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;
649

650
	if (active) {
I
Ian McDonald 已提交
651
		dccp_write_xmit(sk, 1);
652
		dccp_skb_entail(sk, skb);
653
		dccp_transmit_skb(sk, skb_clone(skb, prio));
654 655 656 657 658 659 660 661 662 663 664 665
		/*
		 * 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);
666 667
	} else
		dccp_transmit_skb(sk, skb);
668
}