Return to zc.c CVS log

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

Annotation of libaitsync/src/zc.c, revision 1.1.1.1.2.1

1.1.1.1.2.1! misho       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: aitsync.c,v 1.1.1.1 2010/03/24 16:00:15 misho Exp $
        !             7: *
        !             8: *************************************************************************/
1.1       misho       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: }