output.c 14.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *  net/dccp/output.c
 * 
 *  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
			break;
65

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

70 71 72
		case DCCP_PKT_SYNC:
		case DCCP_PKT_SYNCACK:
			ackno = dcb->dccpd_seq;
73 74 75 76 77 78 79 80
			/* fall through */
		default:
			/*
			 * Only data packets should come through with skb->sk
			 * set.
			 */
			WARN_ON(skb->sk);
			skb_set_owner_w(skb, sk);
81 82
			break;
		}
83 84

		dcb->dccpd_seq = dp->dccps_gss;
85 86 87 88 89

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

92
		/* Build DCCP header and checksum it. */
93
		dh = dccp_zeroed_hdr(skb, dccp_header_size);
94 95 96 97 98
		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;
99
		dh->dccph_cscov = dp->dccps_pcslen;
100 101 102 103 104 105 106 107 108 109
		/* 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:
110
			dccp_hdr_request(skb)->dccph_req_service =
111
							dp->dccps_service;
112 113
			break;
		case DCCP_PKT_RESET:
114 115
			dccp_hdr_reset(skb)->dccph_reset_code =
							dcb->dccpd_reset_code;
116 117 118
			break;
		}

119
		icsk->icsk_af_ops->send_check(sk, 0, skb);
120

121
		if (set_ack)
122 123 124 125
			dccp_event_ack_sent(sk);

		DCCP_INC_STATS(DCCP_MIB_OUTSEGS);

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

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

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

	/*
	 * 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 */
154
	icsk->icsk_pmtu_cookie = pmtu;
155 156 157 158 159
	dp->dccps_mss_cache = mss_now;

	return mss_now;
}

160 161
EXPORT_SYMBOL_GPL(dccp_sync_mss);

162 163 164 165 166 167 168 169 170 171 172 173 174
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);
}

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

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

I
Ian McDonald 已提交
189
		if (sk->sk_err)
190 191 192 193
			goto do_error;
		if (signal_pending(current))
			goto do_interrupted;

194
		rc = ccid_hc_tx_send_packet(dp->dccps_hc_tx_ccid, sk, skb);
195 196 197 198 199
		if (rc <= 0)
			break;
		delay = msecs_to_jiffies(rc);
		sk->sk_write_pending++;
		release_sock(sk);
I
Ian McDonald 已提交
200
		schedule_timeout(delay);
201 202 203 204 205 206 207 208 209 210 211
		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 已提交
212
	rc = -EINTR;
213 214 215
	goto out;
}

I
Ian McDonald 已提交
216 217 218 219 220 221 222 223 224 225 226 227 228 229
static void dccp_write_xmit_timer(unsigned long data) {
	struct sock *sk = (struct sock *)data;
	struct dccp_sock *dp = dccp_sk(sk);

	bh_lock_sock(sk);
	if (sock_owned_by_user(sk))
		sk_reset_timer(sk, &dp->dccps_xmit_timer, jiffies+1);
	else
		dccp_write_xmit(sk, 0);
	bh_unlock_sock(sk);
	sock_put(sk);
}

void dccp_write_xmit(struct sock *sk, int block)
230
{
I
Ian McDonald 已提交
231 232 233 234
	struct dccp_sock *dp = dccp_sk(sk);
	struct sk_buff *skb;

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

I
Ian McDonald 已提交
237 238 239 240 241
		if (err > 0) {
			if (!block) {
				sk_reset_timer(sk, &dp->dccps_xmit_timer,
						msecs_to_jiffies(err)+jiffies);
				break;
I
Ian McDonald 已提交
242 243
			} else
				err = dccp_wait_for_ccid(sk, skb);
244 245
			if (err)
				DCCP_BUG("err=%d after dccp_wait_for_ccid", err);
I
Ian McDonald 已提交
246
		}
247

I
Ian McDonald 已提交
248 249 250 251
		skb_dequeue(&sk->sk_write_queue);
		if (err == 0) {
			struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
			const int len = skb->len;
252

I
Ian McDonald 已提交
253 254 255 256
			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,
257 258
						  inet_csk(sk)->icsk_rto,
						  DCCP_RTO_MAX);
I
Ian McDonald 已提交
259 260 261 262 263 264 265 266
				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);
267 268 269
			if (err)
				DCCP_BUG("err=%d after ccid_hc_tx_packet_sent",
					 err);
I
Ian McDonald 已提交
270 271 272
		} else
			kfree(skb);
	}
273 274
}

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

	/* Reserve space for headers. */
299
	skb_reserve(skb, sk->sk_prot->max_header);
300 301 302

	skb->dst = dst_clone(dst);

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

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

314
	/* Build and checksum header */
315
	dh = dccp_zeroed_hdr(skb, dccp_header_size);
316 317 318

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

327 328
	dccp_csum_outgoing(skb);

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

335 336
EXPORT_SYMBOL_GPL(dccp_make_response);

337 338
static struct sk_buff *dccp_make_reset(struct sock *sk, struct dst_entry *dst,
				       const enum dccp_reset_codes code)
339 340 341 342
				   
{
	struct dccp_hdr *dh;
	struct dccp_sock *dp = dccp_sk(sk);
343
	const u32 dccp_header_size = sizeof(struct dccp_hdr) +
344 345
				     sizeof(struct dccp_hdr_ext) +
				     sizeof(struct dccp_hdr_reset);
346
	struct sk_buff *skb = sock_wmalloc(sk, sk->sk_prot->max_header, 1,
347 348 349 350 351
					   GFP_ATOMIC);
	if (skb == NULL)
		return NULL;

	/* Reserve space for headers. */
352
	skb_reserve(skb, sk->sk_prot->max_header);
353 354 355 356 357 358 359 360

	skb->dst = dst_clone(dst);

	dccp_inc_seqno(&dp->dccps_gss);

	DCCP_SKB_CB(skb)->dccpd_reset_code = code;
	DCCP_SKB_CB(skb)->dccpd_type	   = DCCP_PKT_RESET;
	DCCP_SKB_CB(skb)->dccpd_seq	   = dp->dccps_gss;
361 362 363 364 365

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

367
	dh = dccp_zeroed_hdr(skb, dccp_header_size);
368 369 370

	dh->dccph_sport	= inet_sk(sk)->sport;
	dh->dccph_dport	= inet_sk(sk)->dport;
371 372
	dh->dccph_doff	= (dccp_header_size +
			   DCCP_SKB_CB(skb)->dccpd_opt_len) / 4;
373 374 375 376 377 378
	dh->dccph_type	= DCCP_PKT_RESET;
	dh->dccph_x	= 1;
	dccp_hdr_set_seq(dh, dp->dccps_gss);
	dccp_hdr_set_ack(dccp_hdr_ack_bits(skb), dp->dccps_gsr);

	dccp_hdr_reset(skb)->dccph_reset_code = code;
379
	inet_csk(sk)->icsk_af_ops->send_check(sk, 0, skb);
380 381 382 383 384

	DCCP_INC_STATS(DCCP_MIB_OUTSEGS);
	return skb;
}

385 386 387 388 389 390 391 392 393 394 395 396 397
int dccp_send_reset(struct sock *sk, enum dccp_reset_codes code)
{
	/*
	 * FIXME: what if rebuild_header fails?
	 * Should we be doing a rebuild_header here?
	 */
	int err = inet_sk_rebuild_header(sk);

	if (err == 0) {
		struct sk_buff *skb = dccp_make_reset(sk, sk->sk_dst_cache,
						      code);
		if (skb != NULL) {
			memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
398
			err = inet_csk(sk)->icsk_af_ops->queue_xmit(skb, sk, 0);
399
			return net_xmit_eval(err);
400 401 402 403 404 405
		}
	}

	return err;
}

406 407 408 409 410
/*
 * Do all connect socket setups that can be done AF independent.
 */
static inline void dccp_connect_init(struct sock *sk)
{
411
	struct dccp_sock *dp = dccp_sk(sk);
412 413 414 415 416 417 418 419
	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);
	
	dccp_sync_mss(sk, dst_mtu(dst));

420 421 422 423 424 425 426 427
 	/*
	 * 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.
 	 */
428
	dccp_update_gss(sk, dp->dccps_iss);
429
	dccp_set_seqno(&dp->dccps_awl, max48(dp->dccps_awl, dp->dccps_iss));
430

431 432 433 434
	/* S.GAR - greatest valid acknowledgement number received on a non-Sync;
	 *         initialized to S.ISS (sec. 8.5)                            */
	dp->dccps_gar = dp->dccps_iss;

435
	icsk->icsk_retransmits = 0;
I
Ian McDonald 已提交
436 437 438
	init_timer(&dp->dccps_xmit_timer);
	dp->dccps_xmit_timer.data = (unsigned long)sk;
	dp->dccps_xmit_timer.function = dccp_write_xmit_timer;
439 440 441 442 443 444 445 446 447
}

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

	dccp_connect_init(sk);

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

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

	DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_REQUEST;

457
	dccp_skb_entail(sk, skb);
458 459 460 461
	dccp_transmit_skb(sk, skb_clone(skb, GFP_KERNEL));
	DCCP_INC_STATS(DCCP_MIB_ACTIVEOPENS);

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

467 468
EXPORT_SYMBOL_GPL(dccp_connect);

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

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

		/* Reserve space for headers */
486
		skb_reserve(skb, sk->sk_prot->max_header);
487 488 489 490 491 492 493 494 495 496 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
		DCCP_SKB_CB(skb)->dccpd_type = DCCP_PKT_ACK;
		dccp_transmit_skb(sk, skb);
	}
}

EXPORT_SYMBOL_GPL(dccp_send_ack);

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);
}

524 525
void dccp_send_sync(struct sock *sk, const u64 seq,
		    const enum dccp_pkt_type pkt_type)
526 527 528 529 530 531
{
	/*
	 * We are not putting this on the write queue, so
	 * dccp_transmit_skb() will set the ownership to this
	 * sock.
	 */
532
	struct sk_buff *skb = alloc_skb(sk->sk_prot->max_header, GFP_ATOMIC);
533 534 535 536 537 538

	if (skb == NULL)
		/* FIXME: how to make sure the sync is sent? */
		return;

	/* Reserve space for headers and prepare control bits. */
539
	skb_reserve(skb, sk->sk_prot->max_header);
540
	DCCP_SKB_CB(skb)->dccpd_type = pkt_type;
541 542 543 544 545
	DCCP_SKB_CB(skb)->dccpd_seq = seq;

	dccp_transmit_skb(sk, skb);
}

546 547
EXPORT_SYMBOL_GPL(dccp_send_sync);

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

559 560 561
	skb = alloc_skb(sk->sk_prot->max_header, prio);
	if (skb == NULL)
		return;
562 563 564

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

568
	if (active) {
I
Ian McDonald 已提交
569
		dccp_write_xmit(sk, 1);
570
		dccp_skb_entail(sk, skb);
571
		dccp_transmit_skb(sk, skb_clone(skb, prio));
I
Ian McDonald 已提交
572
		/* FIXME do we need a retransmit timer here? */
573 574
	} else
		dccp_transmit_skb(sk, skb);
575
}