andersk Git - openssh.git/blame_incremental

... / ...

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