Return to zc.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitsync / src

libaitsync Delta patch library

#include "global.h"
#include "file.h"
#include "zc.h"


int sync_Deflate(int inf, int outf, int level)
{
	z_stream z;
	int ret, flush, readed;
	u_char ibuf[Z_CHUNK], obuf[Z_CHUNK];

	lseek(outf, 0l, SEEK_SET);
	if (lseek(inf, 0l, SEEK_SET) == -1) {
		SETERR;
		return -1;
	}

	// init zlib
	memset(&z, 0, sizeof z);
	ret = deflateInit(&z, level);
	if (ret)
		return ret;

	do {
		// set input buffer for compress
		readed = read(inf, ibuf, Z_CHUNK);
		if (-1 == readed) {
			SETERR;
			break;
		} else {
			z.avail_in = readed;
			z.next_in = ibuf;
		}

		// check flush flag
		flush = syncEOF(inf) ? Z_FINISH : Z_NO_FLUSH;

		do {
			// compress and write to file
			z.avail_out = readed;
			z.next_out = obuf;
			ret = deflate(&z, flush);
			if (Z_STREAM_ERROR == ret) {
				syncSetErr(ENOEXEC, "Error:: can`t deflate !!!\n");
				flush = Z_FINISH;
				ret = -1;
				break;
			}

			ret = write(outf, obuf, readed - z.avail_out);
			if (-1 == ret || ret != readed - z.avail_out) {
				SETERR;
				flush = Z_FINISH;
				ret = -1;
				break;
			}
		} while (!z.avail_out);

		if (z.avail_in) {
			syncSetErr(ENOEXEC, "Error:: can`t get all input for deflate !!!\n");
			ret = -1;
			break;
		}
	} while (flush != Z_FINISH);

	// free zlib
	deflateEnd(&z);
	return ret;
}

int sync_Inflate(int inf, int outf)
{
	z_stream z;
	int ret, flush;
	u_char ibuf[Z_CHUNK], obuf[Z_CHUNK];

	lseek(outf, 0l, SEEK_SET);
	if (lseek(inf, 0l, SEEK_SET) == -1) {
		SETERR;
		return -1;
	}

	// init zlib
	memset(&z, 0, sizeof z);
	ret = inflateInit(&z);
	if (ret)
		return ret;

	do {
		// set input buffer for decompress
		ret = read(inf, ibuf, Z_CHUNK);
		if (-1 == ret) {
			SETERR;
			break;
		}
		if (!ret)
			break;
		z.avail_in = ret;
		z.next_in = ibuf;

		flush = Z_NO_FLUSH;

		do {
			// decompress and write to file
			z.avail_out = Z_CHUNK;
			z.next_out = obuf;
			ret = inflate(&z, flush);
			switch (ret) {
				case Z_NEED_DICT:
				case Z_DATA_ERROR:
				case Z_MEM_ERROR:
					syncSetErr(ENOEXEC, "Error:: can`t inflate !!!\n");
					flush = Z_STREAM_END;
					ret = -1;
					break;
			}

			ret = write(outf, obuf, Z_CHUNK - z.avail_out);
			if (-1 == ret || ret != Z_CHUNK - z.avail_out) {
				SETERR;
				flush = Z_STREAM_END;
				ret = -1;
				break;
			}
		} while (!z.avail_out);
	} while (flush != Z_STREAM_END);

	// free zlib
	inflateEnd(&z);
	return ret;
}