[openssh.git] / compress.c

/*
 * 
 * compress.c
 * 
 * Author: Tatu Ylonen <ylo@cs.hut.fi>
 * 
 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
 *                    All rights reserved
 * 
 * Created: Wed Oct 25 22:12:46 1995 ylo
 * 
 * Interface to packet compression for ssh.
 * 
 */

#include "includes.h"
RCSID("$Id$");

#include "ssh.h"
#include "buffer.h"
#include "zlib.h"

static z_stream incoming_stream;
static z_stream outgoing_stream;

/* Initializes compression; level is compression level from 1 to 9
   (as in gzip). */

void 
buffer_compress_init(int level)
{
	debug("Enabling compression at level %d.", level);
	if (level < 1 || level > 9)
		fatal("Bad compression level %d.", level);
	inflateInit(&incoming_stream);
	deflateInit(&outgoing_stream, level);
}

/* Frees any data structures allocated for compression. */

void 
buffer_compress_uninit()
{
	debug("compress outgoing: raw data %lu, compressed %lu, factor %.2f",
	      outgoing_stream.total_in, outgoing_stream.total_out,
	      outgoing_stream.total_in == 0 ? 0.0 :
	      (double) outgoing_stream.total_out / outgoing_stream.total_in);
	debug("compress incoming: raw data %lu, compressed %lu, factor %.2f",
	      incoming_stream.total_out, incoming_stream.total_in,
	      incoming_stream.total_out == 0 ? 0.0 :
	      (double) incoming_stream.total_in / incoming_stream.total_out);
	inflateEnd(&incoming_stream);
	deflateEnd(&outgoing_stream);
}

/* Compresses the contents of input_buffer into output_buffer.  All
   packets compressed using this function will form a single
   compressed data stream; however, data will be flushed at the end of
   every call so that each output_buffer can be decompressed
   independently (but in the appropriate order since they together
   form a single compression stream) by the receiver.  This appends
   the compressed data to the output buffer. */

void 
buffer_compress(Buffer * input_buffer, Buffer * output_buffer)
{
	char buf[4096];
	int status;

	/* This case is not handled below. */
	if (buffer_len(input_buffer) == 0)
		return;

	/* Input is the contents of the input buffer. */
	outgoing_stream.next_in = buffer_ptr(input_buffer);
	outgoing_stream.avail_in = buffer_len(input_buffer);

	/* Loop compressing until deflate() returns with avail_out != 0. */
	do {
		/* Set up fixed-size output buffer. */
		outgoing_stream.next_out = buf;
		outgoing_stream.avail_out = sizeof(buf);

		/* Compress as much data into the buffer as possible. */
		status = deflate(&outgoing_stream, Z_PARTIAL_FLUSH);
		switch (status) {
		case Z_OK:
			/* Append compressed data to output_buffer. */
			buffer_append(output_buffer, buf,
				      sizeof(buf) - outgoing_stream.avail_out);
			break;
		case Z_STREAM_END:
			fatal("buffer_compress: deflate returned Z_STREAM_END");
			/* NOTREACHED */
		case Z_STREAM_ERROR:
			fatal("buffer_compress: deflate returned Z_STREAM_ERROR");
			/* NOTREACHED */
		case Z_BUF_ERROR:
			fatal("buffer_compress: deflate returned Z_BUF_ERROR");
			/* NOTREACHED */
		default:
			fatal("buffer_compress: deflate returned %d", status);
			/* NOTREACHED */
		}
	}
	while (outgoing_stream.avail_out == 0);
}

/* Uncompresses the contents of input_buffer into output_buffer.  All
   packets uncompressed using this function will form a single
   compressed data stream; however, data will be flushed at the end of
   every call so that each output_buffer.  This must be called for the
   same size units that the buffer_compress was called, and in the
   same order that buffers compressed with that.  This appends the
   uncompressed data to the output buffer. */

void 
buffer_uncompress(Buffer * input_buffer, Buffer * output_buffer)
{
	char buf[4096];
	int status;

	incoming_stream.next_in = buffer_ptr(input_buffer);
	incoming_stream.avail_in = buffer_len(input_buffer);

	incoming_stream.next_out = buf;
	incoming_stream.avail_out = sizeof(buf);

	for (;;) {
		status = inflate(&incoming_stream, Z_PARTIAL_FLUSH);
		switch (status) {
		case Z_OK:
			buffer_append(output_buffer, buf,
				      sizeof(buf) - incoming_stream.avail_out);
			incoming_stream.next_out = buf;
			incoming_stream.avail_out = sizeof(buf);
			break;
		case Z_STREAM_END:
			fatal("buffer_uncompress: inflate returned Z_STREAM_END");
			/* NOTREACHED */
		case Z_DATA_ERROR:
			fatal("buffer_uncompress: inflate returned Z_DATA_ERROR");
			/* NOTREACHED */
		case Z_STREAM_ERROR:
			fatal("buffer_uncompress: inflate returned Z_STREAM_ERROR");
			/* NOTREACHED */
		case Z_BUF_ERROR:
			/* Comments in zlib.h say that we should keep
			   calling inflate() until we get an error.  This
			   appears to be the error that we get. */
			return;
		case Z_MEM_ERROR:
			fatal("buffer_uncompress: inflate returned Z_MEM_ERROR");
			/* NOTREACHED */
		default:
			fatal("buffer_uncompress: inflate returned %d", status);
		}
	}
}
Commit	Line	Data
8efc0c15	1	/*
5260325f	2	*
	3	* compress.c
	4	*
	5	* Author: Tatu Ylonen <ylo@cs.hut.fi>
	6	*
	7	* Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
	8	* All rights reserved
	9	*
	10	* Created: Wed Oct 25 22:12:46 1995 ylo
	11	*
	12	* Interface to packet compression for ssh.
	13	*
	14	*/
8efc0c15	15
	16	#include "includes.h"
	17	RCSID("$Id$");
	18
	19	#include "ssh.h"
	20	#include "buffer.h"
	21	#include "zlib.h"
	22
	23	static z_stream incoming_stream;
	24	static z_stream outgoing_stream;
	25
5260325f	26	/* Initializes compression; level is compression level from 1 to 9
5260325f	27	(as in gzip). */
8efc0c15	28
5260325f	29	void
5260325f	30	buffer_compress_init(int level)
8efc0c15	31	{
5260325f	32	debug("Enabling compression at level %d.", level);
	33	if (level < 1 \|\| level > 9)
	34	fatal("Bad compression level %d.", level);
	35	inflateInit(&incoming_stream);
	36	deflateInit(&outgoing_stream, level);
8efc0c15	37	}
	38
	39	/* Frees any data structures allocated for compression. */
	40
5260325f	41	void
5260325f	42	buffer_compress_uninit()
8efc0c15	43	{
5260325f	44	debug("compress outgoing: raw data %lu, compressed %lu, factor %.2f",
	45	outgoing_stream.total_in, outgoing_stream.total_out,
	46	outgoing_stream.total_in == 0 ? 0.0 :
	47	(double) outgoing_stream.total_out / outgoing_stream.total_in);
	48	debug("compress incoming: raw data %lu, compressed %lu, factor %.2f",
	49	incoming_stream.total_out, incoming_stream.total_in,
	50	incoming_stream.total_out == 0 ? 0.0 :
	51	(double) incoming_stream.total_in / incoming_stream.total_out);
	52	inflateEnd(&incoming_stream);
	53	deflateEnd(&outgoing_stream);
8efc0c15	54	}
	55
	56	/* Compresses the contents of input_buffer into output_buffer. All
	57	packets compressed using this function will form a single
	58	compressed data stream; however, data will be flushed at the end of
	59	every call so that each output_buffer can be decompressed
	60	independently (but in the appropriate order since they together
	61	form a single compression stream) by the receiver. This appends
	62	the compressed data to the output buffer. */
	63
5260325f	64	void
5260325f	65	buffer_compress(Buffer * input_buffer, Buffer * output_buffer)
8efc0c15	66	{
5260325f	67	char buf[4096];
	68	int status;
	69
	70	/* This case is not handled below. */
	71	if (buffer_len(input_buffer) == 0)
	72	return;
	73
	74	/* Input is the contents of the input buffer. */
	75	outgoing_stream.next_in = buffer_ptr(input_buffer);
	76	outgoing_stream.avail_in = buffer_len(input_buffer);
	77
	78	/* Loop compressing until deflate() returns with avail_out != 0. */
	79	do {
	80	/* Set up fixed-size output buffer. */
	81	outgoing_stream.next_out = buf;
	82	outgoing_stream.avail_out = sizeof(buf);
	83
	84	/* Compress as much data into the buffer as possible. */
	85	status = deflate(&outgoing_stream, Z_PARTIAL_FLUSH);
	86	switch (status) {
	87	case Z_OK:
	88	/* Append compressed data to output_buffer. */
	89	buffer_append(output_buffer, buf,
	90	sizeof(buf) - outgoing_stream.avail_out);
	91	break;
	92	case Z_STREAM_END:
	93	fatal("buffer_compress: deflate returned Z_STREAM_END");
	94	/* NOTREACHED */
	95	case Z_STREAM_ERROR:
	96	fatal("buffer_compress: deflate returned Z_STREAM_ERROR");
	97	/* NOTREACHED */
	98	case Z_BUF_ERROR:
	99	fatal("buffer_compress: deflate returned Z_BUF_ERROR");
	100	/* NOTREACHED */
	101	default:
	102	fatal("buffer_compress: deflate returned %d", status);
	103	/* NOTREACHED */
	104	}
8efc0c15	105	}
5260325f	106	while (outgoing_stream.avail_out == 0);
8efc0c15	107	}
	108
	109	/* Uncompresses the contents of input_buffer into output_buffer. All
	110	packets uncompressed using this function will form a single
	111	compressed data stream; however, data will be flushed at the end of
	112	every call so that each output_buffer. This must be called for the
	113	same size units that the buffer_compress was called, and in the
	114	same order that buffers compressed with that. This appends the
	115	uncompressed data to the output buffer. */
	116
5260325f	117	void
5260325f	118	buffer_uncompress(Buffer * input_buffer, Buffer * output_buffer)
8efc0c15	119	{
5260325f	120	char buf[4096];
	121	int status;
	122
	123	incoming_stream.next_in = buffer_ptr(input_buffer);
	124	incoming_stream.avail_in = buffer_len(input_buffer);
	125
	126	incoming_stream.next_out = buf;
	127	incoming_stream.avail_out = sizeof(buf);
	128
	129	for (;;) {
	130	status = inflate(&incoming_stream, Z_PARTIAL_FLUSH);
	131	switch (status) {
	132	case Z_OK:
	133	buffer_append(output_buffer, buf,
	134	sizeof(buf) - incoming_stream.avail_out);
	135	incoming_stream.next_out = buf;
	136	incoming_stream.avail_out = sizeof(buf);
	137	break;
	138	case Z_STREAM_END:
	139	fatal("buffer_uncompress: inflate returned Z_STREAM_END");
	140	/* NOTREACHED */
	141	case Z_DATA_ERROR:
	142	fatal("buffer_uncompress: inflate returned Z_DATA_ERROR");
	143	/* NOTREACHED */
	144	case Z_STREAM_ERROR:
	145	fatal("buffer_uncompress: inflate returned Z_STREAM_ERROR");
	146	/* NOTREACHED */
	147	case Z_BUF_ERROR:
	148	/* Comments in zlib.h say that we should keep
	149	calling inflate() until we get an error. This
	150	appears to be the error that we get. */
	151	return;
	152	case Z_MEM_ERROR:
	153	fatal("buffer_uncompress: inflate returned Z_MEM_ERROR");
	154	/* NOTREACHED */
	155	default:
	156	fatal("buffer_uncompress: inflate returned %d", status);
	157	}
8efc0c15	158	}
8efc0c15	159	}