[gssapi-openssh.git] / openssh / roaming_common.c

/* $OpenBSD: roaming_common.c,v 1.5 2009/06/27 09:32:43 andreas Exp $ */
/*
 * Copyright (c) 2004-2009 AppGate Network Security AB
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "includes.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>

#include <errno.h>
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#include <stdarg.h>
#include <string.h>
#include <unistd.h>

#include "atomicio.h"
#include "log.h"
#include "packet.h"
#include "xmalloc.h"
#include "cipher.h"
#include "buffer.h"
#include "roaming.h"

static size_t out_buf_size = 0;
static char *out_buf = NULL;
static size_t out_start;
static size_t out_last;

static u_int64_t write_bytes = 0;
static u_int64_t read_bytes = 0;

int roaming_enabled = 0;
int resume_in_progress = 0;

int
get_snd_buf_size()
{
	int fd = packet_get_connection_out();
	int optval, optvallen;

	optvallen = sizeof(optval);
	if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optvallen) != 0)
		optval = DEFAULT_ROAMBUF;
	return optval;
}

int
get_recv_buf_size()
{
	int fd = packet_get_connection_in();
	int optval, optvallen;

	optvallen = sizeof(optval);
	if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &optval, &optvallen) != 0)
		optval = DEFAULT_ROAMBUF;
	return optval;
}

void
set_out_buffer_size(size_t size)
{
	/*
	 * The buffer size can only be set once and the buffer will live
	 * as long as the session lives.
	 */
	if (out_buf == NULL) {
		out_buf_size = size;
		out_buf = xmalloc(size);
		out_start = 0;
		out_last = 0;
	}
}

u_int64_t
get_recv_bytes(void)
{
	return read_bytes;
}

void
add_recv_bytes(u_int64_t num)
{
	read_bytes += num;
}

u_int64_t
get_sent_bytes(void)
{
	return write_bytes;
}

void
roam_set_bytes(u_int64_t sent, u_int64_t recvd)
{
	read_bytes = recvd;
	write_bytes = sent;
}

static void
buf_append(const char *buf, size_t count)
{
	if (count > out_buf_size) {
		buf += count - out_buf_size;
		count = out_buf_size;
	}
	if (count < out_buf_size - out_last) {
		memcpy(out_buf + out_last, buf, count);
		if (out_start > out_last)
			out_start += count;
		out_last += count;
	} else {
		/* data will wrap */
		size_t chunk = out_buf_size - out_last;
		memcpy(out_buf + out_last, buf, chunk);
		memcpy(out_buf, buf + chunk, count - chunk);
		out_last = count - chunk;
		out_start = out_last + 1;
	}
}

ssize_t
roaming_write(int fd, const void *buf, size_t count, int *cont)
{
	ssize_t ret;

	ret = write(fd, buf, count);
	if (ret > 0 && !resume_in_progress) {
		write_bytes += ret;
		if (out_buf_size > 0)
			buf_append(buf, ret);
	}
	return ret;
}

ssize_t
roaming_read(int fd, void *buf, size_t count, int *cont)
{
	ssize_t ret = read(fd, buf, count);
	if (ret > 0) {
		if (!resume_in_progress) {
			read_bytes += ret;
		}
	}
	return ret;
}

size_t
roaming_atomicio(ssize_t(*f)(int, void*, size_t), int fd, void *buf,
    size_t count)
{
	size_t ret = atomicio(f, fd, buf, count);

	if (f == vwrite && ret > 0 && !resume_in_progress) {
		write_bytes += ret;
	} else if (f == read && ret > 0 && !resume_in_progress) {
		read_bytes += ret;
	}
	return ret;
}

void
resend_bytes(int fd, u_int64_t *offset)
{
	size_t available, needed;

	if (out_start < out_last)
		available = out_last - out_start;
	else
		available = out_buf_size;
	needed = write_bytes - *offset;
	debug3("resend_bytes: resend %lu bytes from %llu",
	    (unsigned long)needed, (unsigned long long)*offset);
	if (needed > available)
		fatal("Needed to resend more data than in the cache");
	if (out_last < needed) {
		int chunkend = needed - out_last;
		atomicio(vwrite, fd, out_buf + out_buf_size - chunkend,
		    chunkend);
		atomicio(vwrite, fd, out_buf, out_last);
	} else {
		atomicio(vwrite, fd, out_buf + (out_last - needed), needed);
	}
}
Commit	Line	Data
39e70dec	1	/* $OpenBSD: roaming_common.c,v 1.5 2009/06/27 09:32:43 andreas Exp $ */
	2	/*
	3	* Copyright (c) 2004-2009 AppGate Network Security AB
	4	*
	5	* Permission to use, copy, modify, and distribute this software for any
	6	* purpose with or without fee is hereby granted, provided that the above
	7	* copyright notice and this permission notice appear in all copies.
	8	*
	9	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	10	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	11	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	12	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	13	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	14	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	15	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	16	*/
	17
	18	#include "includes.h"
	19
	20	#include <sys/types.h>
	21	#include <sys/socket.h>
	22	#include <sys/uio.h>
	23
	24	#include <errno.h>
	25	#ifdef HAVE_INTTYPES_H
	26	#include <inttypes.h>
	27	#endif
	28	#include <stdarg.h>
	29	#include <string.h>
	30	#include <unistd.h>
	31
	32	#include "atomicio.h"
	33	#include "log.h"
	34	#include "packet.h"
	35	#include "xmalloc.h"
	36	#include "cipher.h"
	37	#include "buffer.h"
	38	#include "roaming.h"
	39
	40	static size_t out_buf_size = 0;
	41	static char *out_buf = NULL;
	42	static size_t out_start;
	43	static size_t out_last;
	44
	45	static u_int64_t write_bytes = 0;
	46	static u_int64_t read_bytes = 0;
	47
	48	int roaming_enabled = 0;
	49	int resume_in_progress = 0;
	50
	51	int
	52	get_snd_buf_size()
	53	{
	54	int fd = packet_get_connection_out();
	55	int optval, optvallen;
	56
	57	optvallen = sizeof(optval);
	58	if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optvallen) != 0)
	59	optval = DEFAULT_ROAMBUF;
	60	return optval;
	61	}
	62
	63	int
	64	get_recv_buf_size()
65	{
66	int fd = packet_get_connection_in();
67	int optval, optvallen;
68
69	optvallen = sizeof(optval);
70	if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &optval, &optvallen) != 0)
71	optval = DEFAULT_ROAMBUF;
72	return optval;
73	}
74
75	void
76	set_out_buffer_size(size_t size)
77	{
78	/*
79	* The buffer size can only be set once and the buffer will live
80	* as long as the session lives.
81	*/
82	if (out_buf == NULL) {
83	out_buf_size = size;
84	out_buf = xmalloc(size);
85	out_start = 0;
86	out_last = 0;
87	}
88	}
89
90	u_int64_t
91	get_recv_bytes(void)
92	{
93	return read_bytes;
94	}
95
96	void
97	add_recv_bytes(u_int64_t num)
98	{
99	read_bytes += num;
100	}
101
102	u_int64_t
103	get_sent_bytes(void)
104	{
105	return write_bytes;
106	}
107
108	void
109	roam_set_bytes(u_int64_t sent, u_int64_t recvd)
110	{
111	read_bytes = recvd;
112	write_bytes = sent;
113	}
114
115	static void
116	buf_append(const char *buf, size_t count)
117	{
118	if (count > out_buf_size) {
119	buf += count - out_buf_size;
120	count = out_buf_size;
121	}
122	if (count < out_buf_size - out_last) {
123	memcpy(out_buf + out_last, buf, count);
124	if (out_start > out_last)
125	out_start += count;
126	out_last += count;
127	} else {
128	/* data will wrap */
129	size_t chunk = out_buf_size - out_last;
130	memcpy(out_buf + out_last, buf, chunk);
131	memcpy(out_buf, buf + chunk, count - chunk);
132	out_last = count - chunk;
133	out_start = out_last + 1;
134	}
135	}
136
137	ssize_t
138	roaming_write(int fd, const void buf, size_t count, int cont)
139	{
140	ssize_t ret;
141
142	ret = write(fd, buf, count);
143	if (ret > 0 && !resume_in_progress) {
144	write_bytes += ret;
145	if (out_buf_size > 0)
146	buf_append(buf, ret);
147	}
39e70dec	148	return ret;
	149	}
	150
	151	ssize_t
	152	roaming_read(int fd, void buf, size_t count, int cont)
	153	{
	154	ssize_t ret = read(fd, buf, count);
	155	if (ret > 0) {
	156	if (!resume_in_progress) {
	157	read_bytes += ret;
	158	}
	159	}
	160	return ret;
	161	}
	162
	163	size_t
	164	roaming_atomicio(ssize_t(f)(int, void, size_t), int fd, void *buf,
	165	size_t count)
	166	{
	167	size_t ret = atomicio(f, fd, buf, count);
	168
	169	if (f == vwrite && ret > 0 && !resume_in_progress) {
	170	write_bytes += ret;
	171	} else if (f == read && ret > 0 && !resume_in_progress) {
	172	read_bytes += ret;
	173	}
	174	return ret;
	175	}
	176
	177	void
	178	resend_bytes(int fd, u_int64_t *offset)
	179	{
	180	size_t available, needed;
	181
	182	if (out_start < out_last)
	183	available = out_last - out_start;
	184	else
	185	available = out_buf_size;
	186	needed = write_bytes - *offset;
	187	debug3("resend_bytes: resend %lu bytes from %llu",
	188	(unsigned long)needed, (unsigned long long)*offset);
	189	if (needed > available)
	190	fatal("Needed to resend more data than in the cache");
	191	if (out_last < needed) {
	192	int chunkend = needed - out_last;
	193	atomicio(vwrite, fd, out_buf + out_buf_size - chunkend,
	194	chunkend);
	195	atomicio(vwrite, fd, out_buf, out_last);
	196	} else {
	197	atomicio(vwrite, fd, out_buf + (out_last - needed), needed);
	198	}
	199	}