output.c 16.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 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);

H
Herbert Xu 已提交
129
		memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
130
		err = icsk->icsk_af_ops->queue_xmit(skb, 0);
131
		return net_xmit_eval(err);
132 133 134 135 136 137
	}
	return -ENOBUFS;
}

unsigned int dccp_sync_mss(struct sock *sk, u32 pmtu)
{
138
	struct inet_connection_sock *icsk = inet_csk(sk);
139
	struct dccp_sock *dp = dccp_sk(sk);
140
	int mss_now = (pmtu - icsk->icsk_af_ops->net_header_len -
141
		       sizeof(struct dccp_hdr) - sizeof(struct dccp_hdr_ext));
142 143

	/* Now subtract optional transport overhead */
144
	mss_now -= icsk->icsk_ext_hdr_len;
145 146 147 148 149 150 151 152 153 154 155 156

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

	mss_now -= ((5 + 6 + 10 + 6 + 6 + 6 + 3) / 4) * 4;

	/* And store cached results */
157
	icsk->icsk_pmtu_cookie = pmtu;
158 159 160 161 162
	dp->dccps_mss_cache = mss_now;

	return mss_now;
}

163 164
EXPORT_SYMBOL_GPL(dccp_sync_mss);

165 166 167 168 169 170 171 172
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))
173
		sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
174 175 176 177

	read_unlock(&sk->sk_callback_lock);
}

178 179
/**
 * dccp_wait_for_ccid - Wait for ccid to tell us we can send a packet
G
Gerrit Renker 已提交
180 181 182 183 184
 * @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
185
 */
G
Gerrit Renker 已提交
186
static int dccp_wait_for_ccid(struct sock *sk, struct sk_buff *skb, int delay)
187 188 189
{
	struct dccp_sock *dp = dccp_sk(sk);
	DEFINE_WAIT(wait);
G
Gerrit Renker 已提交
190
	unsigned long jiffdelay;
191 192
	int rc;

G
Gerrit Renker 已提交
193 194 195 196
	do {
		dccp_pr_debug("delayed send by %d msec\n", delay);
		jiffdelay = msecs_to_jiffies(delay);

197 198
		prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);

G
Gerrit Renker 已提交
199 200 201 202 203 204
		sk->sk_write_pending++;
		release_sock(sk);
		schedule_timeout(jiffdelay);
		lock_sock(sk);
		sk->sk_write_pending--;

I
Ian McDonald 已提交
205
		if (sk->sk_err)
206 207 208 209
			goto do_error;
		if (signal_pending(current))
			goto do_interrupted;

210
		rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
G
Gerrit Renker 已提交
211
	} while ((delay = rc) > 0);
212 213 214 215 216 217 218 219
out:
	finish_wait(sk->sk_sleep, &wait);
	return rc;

do_error:
	rc = -EPIPE;
	goto out;
do_interrupted:
I
Ian McDonald 已提交
220
	rc = -EINTR;
221 222 223
	goto out;
}

I
Ian McDonald 已提交
224
void dccp_write_xmit(struct sock *sk, int block)
225
{
I
Ian McDonald 已提交
226 227 228 229
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;

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

I
Ian McDonald 已提交
232 233 234 235 236
		if (err > 0) {
			if (!block) {
				sk_reset_timer(sk, &dp->dccps_xmit_timer,
						msecs_to_jiffies(err)+jiffies);
				break;
I
Ian McDonald 已提交
237
			} else
G
Gerrit Renker 已提交
238
				err = dccp_wait_for_ccid(sk, skb, err);
239
			if (err && err != -EINTR)
240
				DCCP_BUG("err=%d after dccp_wait_for_ccid", err);
I
Ian McDonald 已提交
241
		}
242

I
Ian McDonald 已提交
243 244 245 246
		skb_dequeue(&sk->sk_write_queue);
		if (err == 0) {
			struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
			const int len = skb->len;
247

I
Ian McDonald 已提交
248 249 250 251
			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,
252 253
						  inet_csk(sk)->icsk_rto,
						  DCCP_RTO_MAX);
I
Ian McDonald 已提交
254 255 256 257 258 259 260 261
				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);
262 263 264
			if (err)
				DCCP_BUG("err=%d after ccid_hc_tx_packet_sent",
					 err);
265
		} else {
266
			dccp_pr_debug("packet discarded due to err=%d\n", err);
P
Patrick McHardy 已提交
267
			kfree_skb(skb);
268
		}
I
Ian McDonald 已提交
269
	}
270 271
}

272 273
int dccp_retransmit_skb(struct sock *sk, struct sk_buff *skb)
{
274
	if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk) != 0)
275 276 277 278 279 280 281 282 283 284 285
		return -EHOSTUNREACH; /* Routing failure or similar. */

	return dccp_transmit_skb(sk, (skb_cloned(skb) ?
				      pskb_copy(skb, GFP_ATOMIC):
				      skb_clone(skb, GFP_ATOMIC)));
}

struct sk_buff *dccp_make_response(struct sock *sk, struct dst_entry *dst,
				   struct request_sock *req)
{
	struct dccp_hdr *dh;
286
	struct dccp_request_sock *dreq;
287
	const u32 dccp_header_size = sizeof(struct dccp_hdr) +
288 289
				     sizeof(struct dccp_hdr_ext) +
				     sizeof(struct dccp_hdr_response);
290
	struct sk_buff *skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1,
291 292 293 294 295
					   GFP_ATOMIC);
	if (skb == NULL)
		return NULL;

	/* Reserve space for headers. */
296
	skb_reserve(skb, sk->sk_prot->max_header);
297 298 299

	skb->dst = dst_clone(dst);

300
	dreq = dccp_rsk(req);
301 302
	if (inet_rsk(req)->acked)	/* increase ISS upon retransmission */
		dccp_inc_seqno(&dreq->dreq_iss);
303
	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_RESPONSE;
304
	DCCP_SKB_CB(skb)->dccpd_seq  = dreq->dreq_iss;
305 306 307 308 309

	if (dccp_insert_options(sk, skb)) {
		kfree_skb(skb);
		return NULL;
	}
310

311
	/* Build and checksum header */
312
	dh = dccp_zeroed_hdr(skb, dccp_header_size);
313 314 315

	dh->dccph_sport	= inet_sk(sk)->sport;
	dh->dccph_dport	= inet_rsk(req)->rmt_port;
316 317
	dh->dccph_doff	= (dccp_header_size +
			   DCCP_SKB_CB(skb)->dccpd_opt_len) / 4;
318 319
	dh->dccph_type	= DCCP_PKT_RESPONSE;
	dh->dccph_x	= 1;
320 321 322
	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;
323

324 325
	dccp_csum_outgoing(skb);

326 327
	/* We use `acked' to remember that a Response was already sent. */
	inet_rsk(req)->acked = 1;
328 329 330 331
	DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
	return skb;
}

332 333
EXPORT_SYMBOL_GPL(dccp_make_response);

334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
/* answer offending packet in @rcv_skb with Reset from control socket @ctl */
struct sk_buff *dccp_ctl_make_reset(struct socket *ctl, struct sk_buff *rcv_skb)
{
	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;

	skb = alloc_skb(ctl->sk->sk_prot->max_header, GFP_ATOMIC);
	if (skb == NULL)
		return NULL;

	skb_reserve(skb, ctl->sk->sk_prot->max_header);

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

386
/* send Reset on established socket, to close or abort the connection */
387 388
int dccp_send_reset(struct sock *sk, enum dccp_reset_codes code)
{
389
	struct sk_buff *skb;
390 391 392 393
	/*
	 * FIXME: what if rebuild_header fails?
	 * Should we be doing a rebuild_header here?
	 */
394
	int err = inet_csk(sk)->icsk_af_ops->rebuild_header(sk);
395

396 397 398 399 400 401 402 403 404 405 406
	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;
407

408
	return dccp_transmit_skb(sk, skb);
409 410
}

411 412 413 414 415
/*
 * Do all connect socket setups that can be done AF independent.
 */
static inline void dccp_connect_init(struct sock *sk)
{
416
	struct dccp_sock *dp = dccp_sk(sk);
417 418 419 420 421
	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);
422

423 424
	dccp_sync_mss(sk, dst_mtu(dst));

425
	/*
426 427 428 429 430 431
	 * 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.
432
	 */
433
	dccp_update_gss(sk, dp->dccps_iss);
434
	dccp_set_seqno(&dp->dccps_awl, max48(dp->dccps_awl, dp->dccps_iss));
435

436 437 438 439
	/* S.GAR - greatest valid acknowledgement number received on a non-Sync;
	 *         initialized to S.ISS (sec. 8.5)                            */
	dp->dccps_gar = dp->dccps_iss;

440 441 442 443 444 445 446 447 448 449
	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);

450
	skb = alloc_skb(sk->sk_prot->max_header, sk->sk_allocation);
451 452 453 454
	if (unlikely(skb == NULL))
		return -ENOBUFS;

	/* Reserve space for headers. */
455
	skb_reserve(skb, sk->sk_prot->max_header);
456 457 458

	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_REQUEST;

459
	dccp_skb_entail(sk, skb);
460 461 462 463
	dccp_transmit_skb(sk, skb_clone(skb, GFP_KERNEL));
	DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS);

	/* Timer for repeating the REQUEST until an answer. */
464 465
	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
				  icsk->icsk_rto, DCCP_RTO_MAX);
466 467 468
	return 0;
}

469 470
EXPORT_SYMBOL_GPL(dccp_connect);

471 472 473 474
void dccp_send_ack(struct sock *sk)
{
	/* If we have been reset, we may not send again. */
	if (sk->sk_state != DCCP_CLOSED) {
475 476
		struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header,
						GFP_ATOMIC);
477 478 479 480

		if (skb == NULL) {
			inet_csk_schedule_ack(sk);
			inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
481 482 483
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX,
						  DCCP_RTO_MAX);
484 485 486 487
			return;
		}

		/* Reserve space for headers */
488
		skb_reserve(skb, sk->sk_prot->max_header);
489 490 491 492 493 494 495
		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_ACK;
		dccp_transmit_skb(sk, skb);
	}
}

EXPORT_SYMBOL_GPL(dccp_send_ack);

496
/* FIXME: Is this still necessary (11.3) - currently nowhere used by DCCP. */
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
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 已提交
527
void dccp_send_sync(struct sock *sk, const u64 ackno,
528
		    const enum dccp_pkt_type pkt_type)
529 530 531 532 533 534
{
	/*
	 * We are not putting this on the write queue, so
	 * dccp_transmit_skb() will set the ownership to this
	 * sock.
	 */
535
	struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
536

G
Gerrit Renker 已提交
537
	if (skb == NULL) {
538
		/* FIXME: how to make sure the sync is sent? */
G
Gerrit Renker 已提交
539
		DCCP_CRIT("could not send %s", dccp_packet_name(pkt_type));
540
		return;
G
Gerrit Renker 已提交
541
	}
542 543

	/* Reserve space for headers and prepare control bits. */
544
	skb_reserve(skb, sk->sk_prot->max_header);
545
	DCCP_SKB_CB(skb)->dccpd_type = pkt_type;
G
Gerrit Renker 已提交
546
	DCCP_SKB_CB(skb)->dccpd_ack_seq = ackno;
547 548 549 550

	dccp_transmit_skb(sk, skb);
}

551 552
EXPORT_SYMBOL_GPL(dccp_send_sync);

553 554 555 556
/*
 * 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.
557
 */
558
void dccp_send_close(struct sock *sk, const int active)
559 560 561
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;
A
Al Viro 已提交
562
	const gfp_t prio = active ? GFP_KERNEL : GFP_ATOMIC;
563

564 565 566
	skb = alloc_skb(sk->sk_prot->max_header, prio);
	if (skb == NULL)
		return;
567 568 569

	/* Reserve space for headers and prepare control bits. */
	skb_reserve(skb, sk->sk_prot->max_header);
570 571
	DCCP_SKB_CB(skb)->dccpd_type = dp->dccps_role == DCCP_ROLE_CLIENT ?
					DCCP_PKT_CLOSE : DCCP_PKT_CLOSEREQ;
572

573
	if (active) {
I
Ian McDonald 已提交
574
		dccp_write_xmit(sk, 1);
575
		dccp_skb_entail(sk, skb);
576
		dccp_transmit_skb(sk, skb_clone(skb, prio));
577 578 579 580 581 582 583 584 585 586 587 588
		/*
		 * 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);
589 590
	} else
		dccp_transmit_skb(sk, skb);
591
}