output.c 13.7 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 173 174 175 176 177
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))
		sk_wake_async(sk, 2, POLL_OUT);

	read_unlock(&sk->sk_callback_lock);
}

178 179 180 181
/**
 * dccp_wait_for_ccid - Wait for ccid to tell us we can send a packet
 * @sk: socket to wait for
 */
I
Ian McDonald 已提交
182
static int dccp_wait_for_ccid(struct sock *sk, struct sk_buff *skb)
183 184 185
{
	struct dccp_sock *dp = dccp_sk(sk);
	DEFINE_WAIT(wait);
I
Ian McDonald 已提交
186
	unsigned long delay;
187 188 189 190 191
	int rc;

	while (1) {
		prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);

I
Ian McDonald 已提交
192
		if (sk->sk_err)
193 194 195 196
			goto do_error;
		if (signal_pending(current))
			goto do_interrupted;

197
		rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
198 199
		if (rc <= 0)
			break;
200
		dccp_pr_debug("delayed send by %d msec\n", rc);
201 202 203
		delay = msecs_to_jiffies(rc);
		sk->sk_write_pending++;
		release_sock(sk);
I
Ian McDonald 已提交
204
		schedule_timeout(delay);
205 206 207 208 209 210 211 212 213 214 215
		lock_sock(sk);
		sk->sk_write_pending--;
	}
out:
	finish_wait(sk->sk_sleep, &wait);
	return rc;

do_error:
	rc = -EPIPE;
	goto out;
do_interrupted:
I
Ian McDonald 已提交
216
	rc = -EINTR;
217 218 219
	goto out;
}

I
Ian McDonald 已提交
220
void dccp_write_xmit(struct sock *sk, int block)
221
{
I
Ian McDonald 已提交
222 223 224 225
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;

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

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

I
Ian McDonald 已提交
239 240 241 242
		skb_dequeue(&sk->sk_write_queue);
		if (err == 0) {
			struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
			const int len = skb->len;
243

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

268 269
int dccp_retransmit_skb(struct sock *sk, struct sk_buff *skb)
{
270
	if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk) != 0)
271 272 273 274 275 276 277 278 279 280 281
		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;
282
	struct dccp_request_sock *dreq;
283
	const u32 dccp_header_size = sizeof(struct dccp_hdr) +
284 285
				     sizeof(struct dccp_hdr_ext) +
				     sizeof(struct dccp_hdr_response);
286
	struct sk_buff *skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1,
287 288 289 290 291
					   GFP_ATOMIC);
	if (skb == NULL)
		return NULL;

	/* Reserve space for headers. */
292
	skb_reserve(skb, sk->sk_prot->max_header);
293 294 295

	skb->dst = dst_clone(dst);

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

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

307
	/* Build and checksum header */
308
	dh = dccp_zeroed_hdr(skb, dccp_header_size);
309 310 311

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

320 321
	dccp_csum_outgoing(skb);

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

328 329
EXPORT_SYMBOL_GPL(dccp_make_response);

330
/* send Reset on established socket, to close or abort the connection */
331 332
int dccp_send_reset(struct sock *sk, enum dccp_reset_codes code)
{
333
	struct sk_buff *skb;
334 335 336 337 338 339
	/*
	 * FIXME: what if rebuild_header fails?
	 * Should we be doing a rebuild_header here?
	 */
	int err = inet_sk_rebuild_header(sk);

340 341 342 343 344 345 346 347 348 349 350
	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;
351

352
	return dccp_transmit_skb(sk, skb);
353 354
}

355 356 357 358 359
/*
 * Do all connect socket setups that can be done AF independent.
 */
static inline void dccp_connect_init(struct sock *sk)
{
360
	struct dccp_sock *dp = dccp_sk(sk);
361 362 363 364 365
	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);
366

367 368
	dccp_sync_mss(sk, dst_mtu(dst));

369
	/*
370 371 372 373 374 375
	 * 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.
376
	 */
377
	dccp_update_gss(sk, dp->dccps_iss);
378
	dccp_set_seqno(&dp->dccps_awl, max48(dp->dccps_awl, dp->dccps_iss));
379

380 381 382 383
	/* S.GAR - greatest valid acknowledgement number received on a non-Sync;
	 *         initialized to S.ISS (sec. 8.5)                            */
	dp->dccps_gar = dp->dccps_iss;

384 385 386 387 388 389 390 391 392 393
	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);

394
	skb = alloc_skb(sk->sk_prot->max_header, sk->sk_allocation);
395 396 397 398
	if (unlikely(skb == NULL))
		return -ENOBUFS;

	/* Reserve space for headers. */
399
	skb_reserve(skb, sk->sk_prot->max_header);
400 401 402

	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_REQUEST;

403
	dccp_skb_entail(sk, skb);
404 405 406 407
	dccp_transmit_skb(sk, skb_clone(skb, GFP_KERNEL));
	DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS);

	/* Timer for repeating the REQUEST until an answer. */
408 409
	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
				  icsk->icsk_rto, DCCP_RTO_MAX);
410 411 412
	return 0;
}

413 414
EXPORT_SYMBOL_GPL(dccp_connect);

415 416 417 418
void dccp_send_ack(struct sock *sk)
{
	/* If we have been reset, we may not send again. */
	if (sk->sk_state != DCCP_CLOSED) {
419 420
		struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header,
						GFP_ATOMIC);
421 422 423 424

		if (skb == NULL) {
			inet_csk_schedule_ack(sk);
			inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
425 426 427
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX,
						  DCCP_RTO_MAX);
428 429 430 431
			return;
		}

		/* Reserve space for headers */
432
		skb_reserve(skb, sk->sk_prot->max_header);
433 434 435 436 437 438 439
		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_ACK;
		dccp_transmit_skb(sk, skb);
	}
}

EXPORT_SYMBOL_GPL(dccp_send_ack);

440
/* FIXME: Is this still necessary (11.3) - currently nowhere used by DCCP. */
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
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 已提交
471
void dccp_send_sync(struct sock *sk, const u64 ackno,
472
		    const enum dccp_pkt_type pkt_type)
473 474 475 476 477 478
{
	/*
	 * We are not putting this on the write queue, so
	 * dccp_transmit_skb() will set the ownership to this
	 * sock.
	 */
479
	struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
480

G
Gerrit Renker 已提交
481
	if (skb == NULL) {
482
		/* FIXME: how to make sure the sync is sent? */
G
Gerrit Renker 已提交
483
		DCCP_CRIT("could not send %s", dccp_packet_name(pkt_type));
484
		return;
G
Gerrit Renker 已提交
485
	}
486 487

	/* Reserve space for headers and prepare control bits. */
488
	skb_reserve(skb, sk->sk_prot->max_header);
489
	DCCP_SKB_CB(skb)->dccpd_type = pkt_type;
G
Gerrit Renker 已提交
490
	DCCP_SKB_CB(skb)->dccpd_ack_seq = ackno;
491 492 493 494

	dccp_transmit_skb(sk, skb);
}

495 496
EXPORT_SYMBOL_GPL(dccp_send_sync);

497 498 499 500
/*
 * 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.
501
 */
502
void dccp_send_close(struct sock *sk, const int active)
503 504 505
{
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;
A
Al Viro 已提交
506
	const gfp_t prio = active ? GFP_KERNEL : GFP_ATOMIC;
507

508 509 510
	skb = alloc_skb(sk->sk_prot->max_header, prio);
	if (skb == NULL)
		return;
511 512 513

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

517
	if (active) {
I
Ian McDonald 已提交
518
		dccp_write_xmit(sk, 1);
519
		dccp_skb_entail(sk, skb);
520
		dccp_transmit_skb(sk, skb_clone(skb, prio));
I
Ian McDonald 已提交
521
		/* FIXME do we need a retransmit timer here? */
522 523
	} else
		dccp_transmit_skb(sk, skb);
524
}