Return to zc.c CVS log

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

add author

    1: /*************************************************************************
    2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
    3: *  by Michael Pounov <misho@openbsd-bg.org>
    4: *
    5: * $Author: misho $
    6: * $Id: zc.c,v 1.1.1.1.2.1 2010/03/24 16:04:49 misho Exp $
    7: *
    8: *************************************************************************/
    9: #include "global.h"
   10: #include "file.h"
   11: #include "zc.h"
   12: 
   13: 
   14: int sync_Deflate(int inf, int outf, int level)
   15: {
   16: 	z_stream z;
   17: 	int ret, flush, readed;
   18: 	u_char ibuf[Z_CHUNK], obuf[Z_CHUNK];
   19: 
   20: 	lseek(outf, 0l, SEEK_SET);
   21: 	if (lseek(inf, 0l, SEEK_SET) == -1) {
   22: 		SETERR;
   23: 		return -1;
   24: 	}
   25: 
   26: 	// init zlib
   27: 	memset(&z, 0, sizeof z);
   28: 	ret = deflateInit(&z, level);
   29: 	if (ret)
   30: 		return ret;
   31: 
   32: 	do {
   33: 		// set input buffer for compress
   34: 		readed = read(inf, ibuf, Z_CHUNK);
   35: 		if (-1 == readed) {
   36: 			SETERR;
   37: 			break;
   38: 		} else {
   39: 			z.avail_in = readed;
   40: 			z.next_in = ibuf;
   41: 		}
   42: 
   43: 		// check flush flag
   44: 		flush = syncEOF(inf) ? Z_FINISH : Z_NO_FLUSH;
   45: 
   46: 		do {
   47: 			// compress and write to file
   48: 			z.avail_out = readed;
   49: 			z.next_out = obuf;
   50: 			ret = deflate(&z, flush);
   51: 			if (Z_STREAM_ERROR == ret) {
   52: 				syncSetErr(ENOEXEC, "Error:: can`t deflate !!!\n");
   53: 				flush = Z_FINISH;
   54: 				ret = -1;
   55: 				break;
   56: 			}
   57: 
   58: 			ret = write(outf, obuf, readed - z.avail_out);
   59: 			if (-1 == ret || ret != readed - z.avail_out) {
   60: 				SETERR;
   61: 				flush = Z_FINISH;
   62: 				ret = -1;
   63: 				break;
   64: 			}
   65: 		} while (!z.avail_out);
   66: 
   67: 		if (z.avail_in) {
   68: 			syncSetErr(ENOEXEC, "Error:: can`t get all input for deflate !!!\n");
   69: 			ret = -1;
   70: 			break;
   71: 		}
   72: 	} while (flush != Z_FINISH);
   73: 
   74: 	// free zlib
   75: 	deflateEnd(&z);
   76: 	return ret;
   77: }
   78: 
   79: int sync_Inflate(int inf, int outf)
   80: {
   81: 	z_stream z;
   82: 	int ret, flush;
   83: 	u_char ibuf[Z_CHUNK], obuf[Z_CHUNK];
   84: 
   85: 	lseek(outf, 0l, SEEK_SET);
   86: 	if (lseek(inf, 0l, SEEK_SET) == -1) {
   87: 		SETERR;
   88: 		return -1;
   89: 	}
   90: 
   91: 	// init zlib
   92: 	memset(&z, 0, sizeof z);
   93: 	ret = inflateInit(&z);
   94: 	if (ret)
   95: 		return ret;
   96: 
   97: 	do {
   98: 		// set input buffer for decompress
   99: 		ret = read(inf, ibuf, Z_CHUNK);
  100: 		if (-1 == ret) {
  101: 			SETERR;
  102: 			break;
  103: 		}
  104: 		if (!ret)
  105: 			break;
  106: 		z.avail_in = ret;
  107: 		z.next_in = ibuf;
  108: 
  109: 		flush = Z_NO_FLUSH;
  110: 
  111: 		do {
  112: 			// decompress and write to file
  113: 			z.avail_out = Z_CHUNK;
  114: 			z.next_out = obuf;
  115: 			ret = inflate(&z, flush);
  116: 			switch (ret) {
  117: 				case Z_NEED_DICT:
  118: 				case Z_DATA_ERROR:
  119: 				case Z_MEM_ERROR:
  120: 					syncSetErr(ENOEXEC, "Error:: can`t inflate !!!\n");
  121: 					flush = Z_STREAM_END;
  122: 					ret = -1;
  123: 					break;
  124: 			}
  125: 
  126: 			ret = write(outf, obuf, Z_CHUNK - z.avail_out);
  127: 			if (-1 == ret || ret != Z_CHUNK - z.avail_out) {
  128: 				SETERR;
  129: 				flush = Z_STREAM_END;
  130: 				ret = -1;
  131: 				break;
  132: 			}
  133: 		} while (!z.avail_out);
  134: 	} while (flush != Z_STREAM_END);
  135: 
  136: 	// free zlib
  137: 	inflateEnd(&z);
  138: 	return ret;
  139: }