[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.4

version 1.3, 2012/07/22 22:09:47 version 1.4, 2012/11/13 14:19:39
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.4

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