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

Diff for /libaitsync/src/aitsync.c between versions 1.1.1.1 and 1.1.1.1.2.1

version 1.1.1.1, 2010/03/24 16:00:15 version 1.1.1.1.2.1, 2010/03/24 16:31:28
Line 56  inline void syncSetErr(int eno, char *estr, ...) Line 56  inline void syncSetErr(int eno, char *estr, ...)
  * syncSignature() Calculate and create signature for diff   * syncSignature() Calculate and create signature for diff
  * @csInput = Input patched file name for calculating check sums   * @csInput = Input patched file name for calculating check sums
  * @csSig = Output Signature file name   * @csSig = Output Signature file name
    * @compress = 2 compress signatures output, 0 not compressed
  * return: -1 error, 0 ok   * return: -1 error, 0 ok
  */   */
int syncSignature(const char *csInput, const char *csSig)int syncSignature(const char *csInput, const char *csSig, int compress)
 {  {
        int inf, outf, ret;        int inf, outf, f, ret;
         u_char buf[CHUNK_MAX];          u_char buf[CHUNK_MAX];
         register int i = 0;          register int i = 0;
         off_t off = 0ll;          off_t off = 0ll;
         sync_chunk_t sc;          sync_chunk_t sc;
           char szTemp[MAXPATHLEN];
   
         inf = syncOpen(csInput, O_RDONLY);          inf = syncOpen(csInput, O_RDONLY);
         if (inf == -1)          if (inf == -1)
                 return inf;                  return inf;
        outf = syncOpen(csSig, O_WRONLY);        if (compress & 2)
        if (outf == -1) {                f = syncTemp(szTemp, MAXPATHLEN);
         else
                 f = syncOpen(csSig, O_WRONLY);
         if (f == -1) {
                 syncClose(inf);                  syncClose(inf);
                return outf;                return f;
         }          }
   
         for (i = 0, off = 0ll, ret = -1; ret; i++, off += ret) {          for (i = 0, off = 0ll, ret = -1; ret; i++, off += ret) {
Line 86  int syncSignature(const char *csInput, const char *csS Line 91  int syncSignature(const char *csInput, const char *csS
                 // fill chunk                  // fill chunk
                 sync_mksig(i, off, buf, ret, &sc);                  sync_mksig(i, off, buf, ret, &sc);
   
                if (write(outf, &sc, sizeof sc) == -1) {                if (write(f, &sc, sizeof sc) == -1) {
                         SETERR;                          SETERR;
                         break;                          break;
                 }                  }
         }          }
   
        syncClose(outf);        /* Signatures is READY */
 
         // build compressed delta file
         if (compress & 2) {
                 outf = syncOpen(csSig, O_WRONLY);
                 if (outf == -1) {
                         ret = outf;
                         goto end;
                 }
                 if (sync_Deflate(f, outf, Z_DEFAULT_COMPRESSION) == -1) {
                         syncClose(outf);
                         unlink(csSig);
                         ret = -1;
                         goto end;
                 }
                 syncClose(outf);
         }
 end:
         syncClose(f);
         if (compress & 2)
                 unlink(szTemp);
 
         syncClose(inf);          syncClose(inf);
         return ret;          return ret;
 }  }
Line 102  int syncSignature(const char *csInput, const char *csS Line 128  int syncSignature(const char *csInput, const char *csS
  * @csInput = Input original source file name for make delta patch file   * @csInput = Input original source file name for make delta patch file
  * @csSig = Input Signature file name   * @csSig = Input Signature file name
  * @csDelta = Output Delta patch file name   * @csDelta = Output Delta patch file name
 * @compress = Compress output, 0 not compressed * @compress = 3 everything compress, 2 compressed signatures, 1 compress delta output, 0 not compressed
  * return: -1 error, 0 ok   * return: -1 error, 0 ok
  */   */
 int syncDelta(const char *csInput, const char *csSig, const char *csDelta, int compress)  int syncDelta(const char *csInput, const char *csSig, const char *csDelta, int compress)
Line 120  int syncDelta(const char *csInput, const char *csSig,  Line 146  int syncDelta(const char *csInput, const char *csSig, 
   
         /* load signatures */          /* load signatures */
   
        sigf = syncOpen(csSig, O_RDONLY);        if (compress & 2) {
        if (sigf == -1) {                f = syncOpen(csSig, O_RDONLY);
                return sigf;                if (-1 == f)
                         return f;
                 sigf = syncTemp(szTemp, MAXPATHLEN);
                 if (-1 == sigf) {
                         syncClose(f);
                         return sigf;
                 }
 
                 if (sync_Inflate(f, sigf) == -1) {
                         syncClose(sigf);
                         syncClose(f);
                         unlink(szTemp);
                         return -1;
                 } else
                         syncClose(f);
         } else {
                 sigf = syncOpen(csSig, O_RDONLY);
                 if (-1 == sigf)
                         return sigf;
         }          }
   
         if (fstat(sigf, &sb) == -1) {          if (fstat(sigf, &sb) == -1) {
                 SETERR;                  SETERR;
                 syncClose(sigf);                  syncClose(sigf);
                   if (compress & 2)
                           unlink(szTemp);
                 return -1;                  return -1;
         } else {          } else {
                 if (!sb.st_size) {                  if (!sb.st_size) {
                         syncClose(sigf);                          syncClose(sigf);
                           if (compress & 2)
                                   unlink(szTemp);
                         return 1;                          return 1;
                 }                  }
   
Line 138  int syncDelta(const char *csInput, const char *csSig,  Line 187  int syncDelta(const char *csInput, const char *csSig, 
                 if (sb.st_size % sizeof(sync_chunk_t)) {                  if (sb.st_size % sizeof(sync_chunk_t)) {
                         syncSetErr(ENOEXEC, "Error:: signature file is broken!\n");                          syncSetErr(ENOEXEC, "Error:: signature file is broken!\n");
                         syncClose(sigf);                          syncClose(sigf);
                           if (compress & 2)
                                   unlink(szTemp);
                         return -1;                          return -1;
                 }                  }
         }          }
Line 145  int syncDelta(const char *csInput, const char *csSig,  Line 196  int syncDelta(const char *csInput, const char *csSig, 
         if (MAP_FAILED == chunks) {          if (MAP_FAILED == chunks) {
                 SETERR;                  SETERR;
                 syncClose(sigf);                  syncClose(sigf);
                   if (compress & 2)
                           unlink(szTemp);
                 return -1;                  return -1;
           } else {
                   syncClose(sigf);
                   if (compress & 2)
                           unlink(szTemp);
         }          }
         syncClose(sigf);  
   
         /* build from signatures sorted index and hashes */          /* build from signatures sorted index and hashes */
   
Line 181  int syncDelta(const char *csInput, const char *csSig,  Line 237  int syncDelta(const char *csInput, const char *csSig, 
                 munmap(chunks, sb.st_size);                  munmap(chunks, sb.st_size);
                 return inf;                  return inf;
         }          }
        if (compress)        if (compress & 1)
                 f = syncTemp(szTemp, MAXPATHLEN);                  f = syncTemp(szTemp, MAXPATHLEN);
         else          else
                 f = syncOpen(csDelta, O_WRONLY);                  f = syncOpen(csDelta, O_WRONLY);
Line 294  int syncDelta(const char *csInput, const char *csSig,  Line 350  int syncDelta(const char *csInput, const char *csSig, 
         /* Delta patch is READY */          /* Delta patch is READY */
   
         // build compressed delta file          // build compressed delta file
        if (compress) {        if (compress & 1) {
                 outf = syncOpen(csDelta, O_WRONLY);                  outf = syncOpen(csDelta, O_WRONLY);
                 if (outf == -1) {                  if (outf == -1) {
                         ret = outf;                          ret = outf;
Line 311  int syncDelta(const char *csInput, const char *csSig,  Line 367  int syncDelta(const char *csInput, const char *csSig, 
   
 end:  end:
         syncClose(f);          syncClose(f);
        unlink(szTemp);        if (compress & 1)
                 unlink(szTemp);
   
         syncClose(inf);          syncClose(inf);
         free(tag_table);          free(tag_table);
Line 324  end: Line 381  end:
  * @csInput = Input target file name for patch   * @csInput = Input target file name for patch
  * @csDelta = Input Delta patch file name   * @csDelta = Input Delta patch file name
  * @csPatch = After applied patch create new alternate target file, if != NULL   * @csPatch = After applied patch create new alternate target file, if != NULL
 * @compress = Compress output, 0 not compressed * @compress = 1 compress delta input, 0 not compressed
  * return: -1 error, 0 ok, create delta patch, 1 ok, no differences and not create patch   * return: -1 error, 0 ok, create delta patch, 1 ok, no differences and not create patch
  */   */
 int syncPatch(const char *csInput, const char *csDelta, const char *csPatch, int compress)  int syncPatch(const char *csInput, const char *csDelta, const char *csPatch, int compress)
Line 339  int syncPatch(const char *csInput, const char *csDelta Line 396  int syncPatch(const char *csInput, const char *csDelta
         off_t off;          off_t off;
         sync_chunk_t sc, *suffix;          sync_chunk_t sc, *suffix;
   
        if (compress) {        if (compress & 1) {
                 f = syncOpen(csDelta, O_RDONLY);                  f = syncOpen(csDelta, O_RDONLY);
                 if (f == -1)                  if (f == -1)
                         return f;                          return f;
Line 365  int syncPatch(const char *csInput, const char *csDelta Line 422  int syncPatch(const char *csInput, const char *csDelta
         if (fstat(d, &sb) == -1) {          if (fstat(d, &sb) == -1) {
                 SETERR;                  SETERR;
                 syncClose(d);                  syncClose(d);
                if (compress)                if (compress & 1)
                         unlink(szTemp);                          unlink(szTemp);
                 return -1;                  return -1;
         }          }
Line 373  int syncPatch(const char *csInput, const char *csDelta Line 430  int syncPatch(const char *csInput, const char *csDelta
         if (MAP_FAILED == delta) {          if (MAP_FAILED == delta) {
                 SETERR;                  SETERR;
                 syncClose(d);                  syncClose(d);
                if (compress)                if (compress & 1)
                         unlink(szTemp);                          unlink(szTemp);
                 return -1;                  return -1;
         } else {          } else {
                 syncClose(d);                  syncClose(d);
                if (compress)                if (compress & 1)
                         unlink(szTemp);                          unlink(szTemp);
         }          }
   
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.1.2.1

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