[BACK]Return to zc.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitsync / src

Diff for /libaitsync/src/zc.c between versions 1.3 and 1.5

version 1.3, 2012/07/22 22:09:47 version 1.5, 2014/02/04 16:58:17
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012Copyright 2004 - 2014
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 49  SUCH DAMAGE. Line 49  SUCH DAMAGE.
   
   
 /*  /*
 * sync_Deflate() LibZ deflate data * sync_Deflate() - LibZ deflate data
  *
  * @inf = Input file   * @inf = Input file
  * @outf = Output file   * @outf = Output file
  * @level = Compress level   * @level = Compress level
Line 64  sync_Deflate(int inf, int outf, int level) Line 65  sync_Deflate(int inf, int outf, int level)
   
         lseek(outf, 0l, SEEK_SET);          lseek(outf, 0l, SEEK_SET);
         if (lseek(inf, 0l, SEEK_SET) == -1) {          if (lseek(inf, 0l, SEEK_SET) == -1) {
                SETERR;                LOGERR;
                 return -1;                  return -1;
         }          }
   
        // init zlib        /* init zlib */
         memset(&z, 0, sizeof z);          memset(&z, 0, sizeof z);
         ret = deflateInit(&z, level);          ret = deflateInit(&z, level);
         if (ret)          if (ret)
                 return ret;                  return ret;
   
         do {          do {
                // set input buffer for compress                /* set input buffer for compress */
                 readed = read(inf, ibuf, Z_CHUNK);                  readed = read(inf, ibuf, Z_CHUNK);
                 if (-1 == readed) {                  if (-1 == readed) {
                        SETERR;                        LOGERR;
                         break;                          break;
                 } else {                  } else {
                         z.avail_in = readed;                          z.avail_in = readed;
                         z.next_in = ibuf;                          z.next_in = ibuf;
                 }                  }
   
                // check flush flag                /* check flush flag */
                flush = syncEOF(inf) ? Z_FINISH : Z_NO_FLUSH;                flush = sync_EOF(inf) ? Z_FINISH : Z_NO_FLUSH;
   
                 do {                  do {
                        // compress and write to file                        /* compress and write to file */
                         z.avail_out = readed;                          z.avail_out = readed;
                         z.next_out = obuf;                          z.next_out = obuf;
                         ret = deflate(&z, flush);                          ret = deflate(&z, flush);
                         if (Z_STREAM_ERROR == ret) {                          if (Z_STREAM_ERROR == ret) {
                                syncSetErr(ENOEXEC, "Error:: can`t deflate !!!\n");                                sync_SetErr(ENOEXEC, "Error:: can`t deflate !!!\n");
                                 flush = Z_FINISH;                                  flush = Z_FINISH;
                                 ret = -1;                                  ret = -1;
                                 break;                                  break;
Line 102  sync_Deflate(int inf, int outf, int level) Line 103  sync_Deflate(int inf, int outf, int level)
   
                         ret = write(outf, obuf, readed - z.avail_out);                          ret = write(outf, obuf, readed - z.avail_out);
                         if (-1 == ret || ret != readed - z.avail_out) {                          if (-1 == ret || ret != readed - z.avail_out) {
                                SETERR;                                LOGERR;
                                 flush = Z_FINISH;                                  flush = Z_FINISH;
                                 ret = -1;                                  ret = -1;
                                 break;                                  break;
Line 110  sync_Deflate(int inf, int outf, int level) Line 111  sync_Deflate(int inf, int outf, int level)
                 } while (!z.avail_out);                  } while (!z.avail_out);
   
                 if (z.avail_in) {                  if (z.avail_in) {
                        syncSetErr(ENOEXEC, "Error:: can`t get all input for deflate !!!\n");                        sync_SetErr(ENOEXEC, "Error:: can`t get all input for deflate !!!\n");
                         ret = -1;                          ret = -1;
                         break;                          break;
                 }                  }
         } while (flush != Z_FINISH);          } while (flush != Z_FINISH);
   
        // free zlib        /* free zlib */
         deflateEnd(&z);          deflateEnd(&z);
         return ret;          return ret;
 }  }
   
 /*  /*
 * sync_Inflate() LibZ inflate data * sync_Inflate() - LibZ inflate data
  *
  * @inf = Input file   * @inf = Input file
  * @outf = Output file   * @outf = Output file
  * return: -1 error, != -1 ok   * return: -1 error, != -1 ok
Line 136  sync_Inflate(int inf, int outf) Line 138  sync_Inflate(int inf, int outf)
   
         lseek(outf, 0l, SEEK_SET);          lseek(outf, 0l, SEEK_SET);
         if (lseek(inf, 0l, SEEK_SET) == -1) {          if (lseek(inf, 0l, SEEK_SET) == -1) {
                SETERR;                LOGERR;
                 return -1;                  return -1;
         }          }
   
        // init zlib        /* init zlib */
         memset(&z, 0, sizeof z);          memset(&z, 0, sizeof z);
         ret = inflateInit(&z);          ret = inflateInit(&z);
         if (ret)          if (ret)
                 return ret;                  return ret;
   
         do {          do {
                // set input buffer for decompress                /* set input buffer for decompress */
                 ret = read(inf, ibuf, Z_CHUNK);                  ret = read(inf, ibuf, Z_CHUNK);
                 if (-1 == ret) {                  if (-1 == ret) {
                        SETERR;                        LOGERR;
                         break;                          break;
                 }                  }
                 if (!ret)                  if (!ret)
Line 161  sync_Inflate(int inf, int outf) Line 163  sync_Inflate(int inf, int outf)
                 flush = Z_NO_FLUSH;                  flush = Z_NO_FLUSH;
   
                 do {                  do {
                        // decompress and write to file                        /* decompress and write to file */
                         z.avail_out = Z_CHUNK;                          z.avail_out = Z_CHUNK;
                         z.next_out = obuf;                          z.next_out = obuf;
                         ret = inflate(&z, flush);                          ret = inflate(&z, flush);
Line 169  sync_Inflate(int inf, int outf) Line 171  sync_Inflate(int inf, int outf)
                                 case Z_NEED_DICT:                                  case Z_NEED_DICT:
                                 case Z_DATA_ERROR:                                  case Z_DATA_ERROR:
                                 case Z_MEM_ERROR:                                  case Z_MEM_ERROR:
                                        syncSetErr(ENOEXEC, "Error:: can`t inflate !!!\n");                                        sync_SetErr(ENOEXEC, "Error:: can`t inflate !!!\n");
                                         flush = Z_STREAM_END;                                          flush = Z_STREAM_END;
                                         ret = -1;                                          ret = -1;
                                         break;                                          break;
Line 177  sync_Inflate(int inf, int outf) Line 179  sync_Inflate(int inf, int outf)
   
                         ret = write(outf, obuf, Z_CHUNK - z.avail_out);                          ret = write(outf, obuf, Z_CHUNK - z.avail_out);
                         if (-1 == ret || ret != Z_CHUNK - z.avail_out) {                          if (-1 == ret || ret != Z_CHUNK - z.avail_out) {
                                SETERR;                                LOGERR;
                                 flush = Z_STREAM_END;                                  flush = Z_STREAM_END;
                                 ret = -1;                                  ret = -1;
                                 break;                                  break;
Line 185  sync_Inflate(int inf, int outf) Line 187  sync_Inflate(int inf, int outf)
                 } while (!z.avail_out);                  } while (!z.avail_out);
         } while (flush != Z_STREAM_END);          } while (flush != Z_STREAM_END);
   
        // free zlib        /* free zlib */
         inflateEnd(&z);          inflateEnd(&z);
         return ret;          return ret;
 }  }
Removed from v.1.3  
changed lines
  Added in v.1.5

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>