[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.3 and 1.4

version 1.3, 2012/07/22 22:09:47 version 1.4, 2012/11/13 14:19:39
Line 60  func_comp(sync_tag_t const *t1, sync_tag_t const *t2) Line 60  func_comp(sync_tag_t const *t1, sync_tag_t const *t2)
         return t1->st_tag - t2->st_tag;          return t1->st_tag - t2->st_tag;
 }  }
   
///*
// Error maintenance functions ... * Error maintenance functions ...
// */
   
 // sync_GetErrno() Get error code of last operation  // sync_GetErrno() Get error code of last operation
 inline int  inline int
Line 80  sync_GetError() Line 80  sync_GetError()
   
 // sync_SetErr() Set error to variables for internal use!!!  // sync_SetErr() Set error to variables for internal use!!!
 inline void  inline void
syncSetErr(int eno, char *estr, ...)sync_SetErr(int eno, char *estr, ...)
 {  {
         va_list lst;          va_list lst;
   
         sync_Errno = eno;          sync_Errno = eno;
        memset(sync_Error, 0, STRSIZ);        memset(sync_Error, 0, sizeof sync_Error);
         va_start(lst, estr);          va_start(lst, estr);
        vsnprintf(sync_Error, STRSIZ, estr, lst);        vsnprintf(sync_Error, sizeof sync_Error, estr, lst);
         va_end(lst);          va_end(lst);
 }  }
   
// ----------------------------------------------------------/* ---------------------------------------------------------- */
   
 /*  /*
 * 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 target file name for calculating check sums
  * @csSig = Output Signature file name   * @csSig = Output Signature file name
  * @compress = 2 compress signatures output, 0 not compressed   * @compress = 2 compress signatures output, 0 not compressed
  * return: -1 error, 0 ok   * return: -1 error, 0 ok
Line 110  syncSignature(const char *csInput, const char *csSig,  Line 111  syncSignature(const char *csInput, const char *csSig, 
         sync_chunk_t sc;          sync_chunk_t sc;
         char szTemp[MAXPATHLEN];          char szTemp[MAXPATHLEN];
   
        inf = syncOpen(csInput, O_RDONLY);        /* open work files */
         inf = sync_Open(csInput, O_RDONLY, 0);
         if (inf == -1)          if (inf == -1)
                 return inf;                  return inf;
         if (compress & 2)          if (compress & 2)
                f = syncTemp(szTemp, MAXPATHLEN);                f = sync_Temp(szTemp, sizeof szTemp);
         else          else
                f = syncOpen(csSig, O_WRONLY);                f = sync_Open(csSig, O_WRONLY, 0);
         if (f == -1) {          if (f == -1) {
                syncClose(inf);                sync_Close(inf);
                 return f;                  return f;
         }          }
   
Line 126  syncSignature(const char *csInput, const char *csSig,  Line 128  syncSignature(const char *csInput, const char *csSig, 
                 memset(buf, 0, CHUNK_MAX);                  memset(buf, 0, CHUNK_MAX);
                 ret = read(inf, buf, CHUNK_MAX);                  ret = read(inf, buf, CHUNK_MAX);
                 if (ret == -1) {                  if (ret == -1) {
                        SETERR;                        LOGERR;
                         break;                          break;
                 }                  }
   
                // fill chunk                /* fill chunk */
                 sync_mksig(i, off, buf, ret, &sc);                  sync_mksig(i, off, buf, ret, &sc);
   
                 if (write(f, &sc, sizeof sc) == -1) {                  if (write(f, &sc, sizeof sc) == -1) {
                        SETERR;                        LOGERR;
                         break;                          break;
                 }                  }
         }          }
   
        /* Signatures is READY */        /* Signatures are READY */
   
         // build compressed delta file  
         if (compress & 2) {          if (compress & 2) {
                outf = syncOpen(csSig, O_WRONLY);                /* build compressed delta file */
                 outf = sync_Open(csSig, O_WRONLY, 0);
                 if (outf == -1) {                  if (outf == -1) {
                         ret = outf;                          ret = outf;
                         goto end;                          goto end;
                 }                  }
                 if (sync_Deflate(f, outf, Z_DEFAULT_COMPRESSION) == -1) {                  if (sync_Deflate(f, outf, Z_DEFAULT_COMPRESSION) == -1) {
                        syncClose(outf);                        sync_Close(outf);
                         unlink(csSig);                          unlink(csSig);
                         ret = -1;                          ret = -1;
                         goto end;                          goto end;
                 }                  }
                syncClose(outf);                sync_Close(outf);
         }          }
 end:  end:
        syncClose(f);        sync_Close(f);
         if (compress & 2)          if (compress & 2)
                 unlink(szTemp);                  unlink(szTemp);
        sync_Close(inf);
        syncClose(inf); 
         return ret;          return ret;
 }  }
   
 /*  /*
 * syncDelta() Create Delta patch file * syncDelta() - Create Delta patch file
  *
  * @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 target Signature file name
  * @csDelta = Output Delta patch file name   * @csDelta = Output Delta patch file name
  * @compress = 3 everything compress, 2 compressed signatures, 1 compress delta 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
Line 190  syncDelta(const char *csInput, const char *csSig, cons Line 192  syncDelta(const char *csInput, const char *csSig, cons
         /* load signatures */          /* load signatures */
   
         if (compress & 2) {          if (compress & 2) {
                f = syncOpen(csSig, O_RDONLY);                f = sync_Open(csSig, O_RDONLY, 0);
                 if (-1 == f)                  if (-1 == f)
                         return f;                          return f;
                sigf = syncTemp(szTemp, MAXPATHLEN);                sigf = sync_Temp(szTemp, sizeof szTemp);
                 if (-1 == sigf) {                  if (-1 == sigf) {
                        syncClose(f);                        sync_Close(f);
                         return sigf;                          return sigf;
                 }                  }
   
                 if (sync_Inflate(f, sigf) == -1) {                  if (sync_Inflate(f, sigf) == -1) {
                        syncClose(sigf);                        sync_Close(sigf);
                        syncClose(f);                        sync_Close(f);
                         unlink(szTemp);                          unlink(szTemp);
                         return -1;                          return -1;
                 } else                  } else
                        syncClose(f);                        sync_Close(f);
         } else {          } else {
                sigf = syncOpen(csSig, O_RDONLY);                sigf = sync_Open(csSig, O_RDONLY, 0);
                 if (-1 == sigf)                  if (-1 == sigf)
                         return sigf;                          return sigf;
         }          }
   
         if (fstat(sigf, &sb) == -1) {          if (fstat(sigf, &sb) == -1) {
                SETERR;                LOGERR;
                syncClose(sigf);                sync_Close(sigf);
                 if (compress & 2)                  if (compress & 2)
                         unlink(szTemp);                          unlink(szTemp);
                 return -1;                  return -1;
         } else {          } else {
                 if (!sb.st_size) {                  if (!sb.st_size) {
                        syncClose(sigf);                        sync_Close(sigf);
                         if (compress & 2)                          if (compress & 2)
                                 unlink(szTemp);                                  unlink(szTemp);
                         return 1;                          return 1;
Line 228  syncDelta(const char *csInput, const char *csSig, cons Line 230  syncDelta(const char *csInput, const char *csSig, cons
   
                 cnt = sb.st_size / sizeof(sync_chunk_t);                  cnt = sb.st_size / sizeof(sync_chunk_t);
                 if (sb.st_size % sizeof(sync_chunk_t)) {                  if (sb.st_size % sizeof(sync_chunk_t)) {
                        syncSetErr(ENOEXEC, "Error:: signature file is broken!\n");                        sync_SetErr(ENOEXEC, "Error:: signature file is broken!\n");
                        syncClose(sigf);                        sync_Close(sigf);
                         if (compress & 2)                          if (compress & 2)
                                 unlink(szTemp);                                  unlink(szTemp);
                         return -1;                          return -1;
Line 237  syncDelta(const char *csInput, const char *csSig, cons Line 239  syncDelta(const char *csInput, const char *csSig, cons
         }          }
         chunks = (sync_chunk_t*) mmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, sigf, 0);          chunks = (sync_chunk_t*) mmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, sigf, 0);
         if (MAP_FAILED == chunks) {          if (MAP_FAILED == chunks) {
                SETERR;                LOGERR;
                syncClose(sigf);                sync_Close(sigf);
                 if (compress & 2)                  if (compress & 2)
                         unlink(szTemp);                          unlink(szTemp);
                 return -1;                  return -1;
         } else {          } else {
                syncClose(sigf);                sync_Close(sigf);
                 if (compress & 2)                  if (compress & 2)
                         unlink(szTemp);                          unlink(szTemp);
         }          }
   
         /* build from signatures sorted index and hashes */          /* build from signatures sorted index and hashes */
   
        // init tags array        /* init first stage tags array index */
         for (i = 0; i < TABLESIZ; i++)          for (i = 0; i < TABLESIZ; i++)
                 tags[i] = NULL_TAG;                  tags[i] = NULL_TAG;
   
        // build index from signature blocks        /* build second index from signature blocks */
         tag_table = (sync_tag_t*) calloc(cnt, sizeof(sync_tag_t));          tag_table = (sync_tag_t*) calloc(cnt, sizeof(sync_tag_t));
         if (!tag_table) {          if (!tag_table) {
                SETERR;                LOGERR;
                 munmap(chunks, sb.st_size);                  munmap(chunks, sb.st_size);
                 return -1;                  return -1;
         } else {          } else {
Line 266  syncDelta(const char *csInput, const char *csSig, cons Line 268  syncDelta(const char *csInput, const char *csSig, cons
                         tag_table[i].st_tag = GETTAG(chunks[i].sc_roll);                          tag_table[i].st_tag = GETTAG(chunks[i].sc_roll);
                 }                  }
   
                qsort(tag_table, cnt, sizeof(sync_tag_t), (int (*)(const void *, const void *)) func_comp);                qsort(tag_table, cnt, sizeof(sync_tag_t), 
                                 (int (*)(const void *, const void *)) func_comp);
         }          }
        // assign less id position in tag_table to tags        /* assign less id position in tag_table to tags. 
          * It made relation between 1st & 2nd indexes */
         for (i = cnt - 1; i > -1; i--)          for (i = cnt - 1; i > -1; i--)
                 tags[tag_table[i].st_tag] = i;                  tags[tag_table[i].st_tag] = i;
   
   
         /* build delta patch */          /* build delta patch */
   
        inf = syncOpen(csInput, O_RDONLY);        inf = sync_Open(csInput, O_RDONLY, 0);
         if (inf == -1) {          if (inf == -1) {
                 free(tag_table);                  free(tag_table);
                 munmap(chunks, sb.st_size);                  munmap(chunks, sb.st_size);
                 return inf;                  return inf;
         }          }
         if (compress & 1)          if (compress & 1)
                f = syncTemp(szTemp, MAXPATHLEN);                f = sync_Temp(szTemp, sizeof szTemp);
         else          else
                f = syncOpen(csDelta, O_WRONLY);                f = sync_Open(csDelta, O_WRONLY, 0);
         if (f == -1) {          if (f == -1) {
                syncClose(inf);                sync_Close(inf);
                 free(tag_table);                  free(tag_table);
                 munmap(chunks, sb.st_size);                  munmap(chunks, sb.st_size);
                 return f;                  return f;
         }          }
   
        for (i = 0, off = 0ll, ret = -1, blk = 0; (ret = read(inf, buf, CHUNK_MAX)); i++, off += ret) {        for (i = 0, off = 0ll, ret = -1, blk = 0; 
                         (ret = read(inf, buf, CHUNK_MAX)); i++, off += ret) {
                 if (ret == -1) {                  if (ret == -1) {
                        SETERR;                        LOGERR;
                         break;                          break;
                 }                  }
                 find = NULL;                  find = NULL;
   
                // printf("+ find=%p off=%llu i=%d blk=%d\n", find, off, i, blk);#if 0
                 printf("+ find=%p off=%llu i=%d blk=%d\n", find, off, i, blk);
 #endif
   
                // check chunk for differences with signature                /* check chunk for differences with signature */
                 sync_mksig(i, off, buf, ret, &sc);                  sync_mksig(i, off, buf, ret, &sc);
                 cx = GETTAG(sc.sc_roll);                  cx = GETTAG(sc.sc_roll);
                // find in hash -> hash_sorted_table                /* find in hash -> hash_sorted_table */
                 if (NULL_TAG != tags[cx] && tag_table[tags[cx]].st_tag == cx) {                  if (NULL_TAG != tags[cx] && tag_table[tags[cx]].st_tag == cx) {
                        // find in hash_sorted_table crc == -> real chunks id                        /* find in hash_sorted_table crc == -> real chunks id */
                        for (j = 0, c = tag_table[tags[cx]].st_id; tag_table[tags[cx] + j].st_tag == cx;                         for (j = 0, c = tag_table[tags[cx]].st_id; 
                                         tag_table[tags[cx] + j].st_tag == cx; 
                                         j++, c = tag_table[tags[cx] + j].st_id) {                                          j++, c = tag_table[tags[cx] + j].st_id) {
                                if (chunks[c].sc_magic == sc.sc_magic && chunks[c].sc_len == sc.sc_len &&                                 if (chunks[c].sc_magic == sc.sc_magic && 
                                                 chunks[c].sc_len == sc.sc_len && 
                                                 chunks[c].sc_roll == sc.sc_roll &&                                                   chunks[c].sc_roll == sc.sc_roll && 
                                                 !memcmp(chunks[c].sc_cksum, sc.sc_cksum, MD5_DIGEST_LENGTH)) {                                                  !memcmp(chunks[c].sc_cksum, sc.sc_cksum, MD5_DIGEST_LENGTH)) {
                                         find = &chunks[c];                                          find = &chunks[c];
Line 317  syncDelta(const char *csInput, const char *csSig, cons Line 327  syncDelta(const char *csInput, const char *csSig, cons
                         }                          }
                 }                  }
   
                // printf("+ find=%p off=%llu i=%d blk=%d\n", find, off, i, blk);#if 0
                 printf("+ find=%p off=%llu i=%d blk=%d\n", find, off, i, blk);
 #endif
   
                // if match chunk, check for previous match                /* if match chunk, check for previous match */
                 if (!blk && find)                  if (!blk && find)
                         continue;                          continue;
                // if not find chunk in signature skip write to delta patch                /* if not find chunk in signature skip write to delta patch */
                 if (!find) {                  if (!find) {
                        /* different piece, write it! */                        /* different piece, write it! 
                        // write signature of current chunk                         * Write signature of current chunk */
                         ret = write(f, &sc, sizeof sc);                          ret = write(f, &sc, sizeof sc);
                         if (-1 == ret) {                          if (-1 == ret) {
                                SETERR;                                LOGERR;
                                 break;                                  break;
                         }                          }
                        // if write chunk len is differnt from requested len                        /* if write chunk len is differnt from requested len */
                         if (ret != sizeof sc) {                          if (ret != sizeof sc) {
                                syncSetErr(ENOEXEC, "Error:: delta file signature is broken!\n");                                sync_SetErr(ENOEXEC, "Error:: delta file signature is broken!\n");
                                 ret = -1;                                  ret = -1;
                                 break;                                  break;
                         }                          }
                        // write current chunk ...                        /* write current chunk data ... */
                         ret = write(f, buf, sc.sc_len);                          ret = write(f, buf, sc.sc_len);
                         if (-1 == ret) {                          if (-1 == ret) {
                                SETERR;                                LOGERR;
                                 break;                                  break;
                         }                          }
                        // if write chunk len is differnt from requested len                        /* if write chunk len is differnt from requested len */
                         if (ret != sc.sc_len) {                          if (ret != sc.sc_len) {
                                syncSetErr(ENOEXEC, "Error:: delta file data is broken!\n");                                sync_SetErr(ENOEXEC, "Error:: delta file data is broken!\n");
                                 ret = -1;                                  ret = -1;
                                 break;                                  break;
                         }                          }
Line 353  syncDelta(const char *csInput, const char *csSig, cons Line 365  syncDelta(const char *csInput, const char *csSig, cons
   
                         continue;                          continue;
                 }                  }
                // match 1st block after difference and copy signature from B                /* match 1st block after difference and copy signature from B */
                 memcpy(&sc, find, sizeof sc);                  memcpy(&sc, find, sizeof sc);
                 sc.sc_magic = SIGSYNC_MAGIC;                  sc.sc_magic = SIGSYNC_MAGIC;
                 sc.sc_len = blk;                  sc.sc_len = blk;
   
                // write signature from chunk B                /* write signature from chunk B */
                 blk = write(f, &sc, sizeof sc);                  blk = write(f, &sc, sizeof sc);
                 if (-1 == blk) {                  if (-1 == blk) {
                        SETERR;                        LOGERR;
                         break;                          break;
                 }                  }
                // if write chunk len is differnt from requested len                /* if write chunk len is differnt from requested len */
                 if (blk != sizeof sc) {                  if (blk != sizeof sc) {
                        syncSetErr(ENOEXEC, "Error:: delta file end signature is broken!\n");                        sync_SetErr(ENOEXEC, "Error:: delta file end signature is broken!\n");
                         ret = -1;                          ret = -1;
                         break;                          break;
                 }                  }
Line 374  syncDelta(const char *csInput, const char *csSig, cons Line 386  syncDelta(const char *csInput, const char *csSig, cons
                 blk ^= blk;                  blk ^= blk;
         }          }
   
        // check for error or empty delta file        /* check for error or empty delta file */
         if (ret == -1)          if (ret == -1)
                 goto end;                  goto end;
         fsync(f);          fsync(f);
         if (fstat(f, &sb_f) == -1) {          if (fstat(f, &sb_f) == -1) {
                SETERR;                LOGERR;
                 ret = -1;                  ret = -1;
                 goto end;                  goto end;
         }          }
   
        // No deferences, not needed delta.patch !!!        /* No deferences, not needed delta.patch !!! */
         if (!sb_f.st_size) {          if (!sb_f.st_size) {
                 ret = 1;                  ret = 1;
                 goto end;                  goto end;
Line 392  syncDelta(const char *csInput, const char *csSig, cons Line 404  syncDelta(const char *csInput, const char *csSig, cons
   
         /* Delta patch is READY */          /* Delta patch is READY */
   
        // build compressed delta file        /* build compressed delta file */
         if (compress & 1) {          if (compress & 1) {
                outf = syncOpen(csDelta, O_WRONLY);                outf = sync_Open(csDelta, O_WRONLY, 0);
                 if (outf == -1) {                  if (outf == -1) {
                         ret = outf;                          ret = outf;
                         goto end;                          goto end;
                 }                  }
                 if (sync_Deflate(f, outf, Z_DEFAULT_COMPRESSION) == -1) {                  if (sync_Deflate(f, outf, Z_DEFAULT_COMPRESSION) == -1) {
                        syncClose(outf);                        sync_Close(outf);
                         unlink(csDelta);                          unlink(csDelta);
                         ret = -1;                          ret = -1;
                         goto end;                          goto end;
                 }                  }
                syncClose(outf);                sync_Close(outf);
         }          }
   
 end:  end:
        syncClose(f);        sync_Close(f);
         if (compress & 1)          if (compress & 1)
                 unlink(szTemp);                  unlink(szTemp);
        sync_Close(inf);
        syncClose(inf); 
         free(tag_table);          free(tag_table);
         munmap(chunks, sb.st_size);          munmap(chunks, sb.st_size);
         return ret;          return ret;
 }  }
   
 /*  /*
 * syncPatch() Apply delta patch file to target * syncPatch() - Apply delta patch file to target
  *
  * @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
Line 441  syncPatch(const char *csInput, const char *csDelta, co Line 453  syncPatch(const char *csInput, const char *csDelta, co
         sync_chunk_t sc, *suffix;          sync_chunk_t sc, *suffix;
   
         if (compress & 1) {          if (compress & 1) {
                f = syncOpen(csDelta, O_RDONLY);                f = sync_Open(csDelta, O_RDONLY, 0);
                 if (f == -1)                  if (f == -1)
                         return f;                          return f;
                d = syncTemp(szTemp, MAXPATHLEN);                d = sync_Temp(szTemp, sizeof szTemp);
                 if (d == -1) {                  if (d == -1) {
                        syncClose(f);                        sync_Close(f);
                         return d;                          return d;
                 }                  }
                                   
                 if (sync_Inflate(f, d) == -1) {                  if (sync_Inflate(f, d) == -1) {
                        syncClose(d);                        sync_Close(d);
                        syncClose(f);                        sync_Close(f);
                         unlink(szTemp);                          unlink(szTemp);
                         return -1;                          return -1;
                 } else                  } else
                        syncClose(f);                        sync_Close(f);
         } else {          } else {
                d = syncOpen(csDelta, O_RDONLY);                d = sync_Open(csDelta, O_RDONLY, 0);
                 if (d == -1)                  if (d == -1)
                         return d;                          return d;
         }          }
   
         if (fstat(d, &sb) == -1) {          if (fstat(d, &sb) == -1) {
                SETERR;                LOGERR;
                syncClose(d);                sync_Close(d);
                 if (compress & 1)                  if (compress & 1)
                         unlink(szTemp);                          unlink(szTemp);
                 return -1;                  return -1;
         }          }
         delta = mmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, d, 0);          delta = mmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, d, 0);
         if (MAP_FAILED == delta) {          if (MAP_FAILED == delta) {
                SETERR;                LOGERR;
                syncClose(d);                sync_Close(d);
                 if (compress & 1)                  if (compress & 1)
                         unlink(szTemp);                          unlink(szTemp);
                 return -1;                  return -1;
         } else {          } else {
                syncClose(d);                sync_Close(d);
                 if (compress & 1)                  if (compress & 1)
                         unlink(szTemp);                          unlink(szTemp);
         }          }
   
         if (sync_buildPatch(delta, sb.st_size, &pieces) == -1 || !pieces) {          if (sync_buildPatch(delta, sb.st_size, &pieces) == -1 || !pieces) {
                syncSetErr(ENOEXEC, "Error:: patch file is broken!\n");                sync_SetErr(ENOEXEC, "Error:: patch file is broken!\n");
                 munmap(delta, sb.st_size);                  munmap(delta, sb.st_size);
                 return -1;                  return -1;
         }          }
   
        inf = syncOpen(csInput, O_RDONLY);        inf = sync_Open(csInput, O_RDONLY, 0);
         if (inf == -1) {          if (inf == -1) {
                 if (pieces)                  if (pieces)
                         free(pieces);                          free(pieces);
                 munmap(delta, sb.st_size);                  munmap(delta, sb.st_size);
                 return inf;                  return inf;
         }          }
        outf = syncOpen(csPatch, O_WRONLY);        outf = sync_Open(csPatch, O_WRONLY, 0);
         if (outf == -1) {          if (outf == -1) {
                syncClose(inf);                sync_Close(inf);
                 if (pieces)                  if (pieces)
                         free(pieces);                          free(pieces);
                 munmap(delta, sb.st_size);                  munmap(delta, sb.st_size);
Line 506  syncPatch(const char *csInput, const char *csDelta, co Line 518  syncPatch(const char *csInput, const char *csDelta, co
         }          }
   
         if (fstat(inf, &sb) == -1) {          if (fstat(inf, &sb) == -1) {
                SETERR;                LOGERR;
                 ret = -1;                  ret = -1;
                 goto end;                  goto end;
         } else {          } else {
Line 518  syncPatch(const char *csInput, const char *csDelta, co Line 530  syncPatch(const char *csInput, const char *csDelta, co
   
         ret = readlen = 0;          ret = readlen = 0;
         buffer = NULL;          buffer = NULL;
        for (i = 0, off = 0ll, suffix = NULL, piece = pieces; piece->pfx; i++, off += readlen) {        for (i = 0, off = 0ll, suffix = NULL, piece = pieces; piece->pfx; 
                         i++, off += readlen) {
 #if 0
                 printf("i=%d off=%llu sfx=%p piece=%p\n", i, off, suffix, piece);
 #endif
   
                // printf("i=%d off=%llu sfx=%p piece=%p\n", i, off, suffix, piece);                /* if input offset is less then input file size */
 
                // if input offset is less then input file size 
                 if (off < sb.st_size) {                  if (off < sb.st_size) {
                         readlen = read(inf, buf, CHUNK_MAX);                          readlen = read(inf, buf, CHUNK_MAX);
                         if (readlen == -1) {                          if (readlen == -1) {
                                SETERR;                                LOGERR;
                                 ret = -1;                                  ret = -1;
                                 break;                                  break;
                         }                          }
                        // if suffix find, check for correct patch                        /* if suffix find, check for correct patch */
                         if (suffix) {                          if (suffix) {
                                if (suffix->sc_len != readlen || suffix->sc_off != off) {                                if (suffix->sc_len != readlen || 
                                        syncSetErr(ENOEXEC, "Error:: patch file is broken! (wrong suffix pos)\n");                                                suffix->sc_off != off) {
                                         sync_SetErr(ENOEXEC, "Error:: patch file is broken! "
                                                         "(wrong suffix pos)\n");
                                         ret = -1;                                          ret = -1;
                                         break;                                          break;
                                 }                                  }
                                 sync_mksig(i, off, buf, readlen, &sc);                                  sync_mksig(i, off, buf, readlen, &sc);
                                 if (sc.sc_roll != suffix->sc_roll ||                                   if (sc.sc_roll != suffix->sc_roll || 
                                                memcmp(sc.sc_cksum, suffix->sc_cksum, MD5_DIGEST_LENGTH)) {                                                memcmp(sc.sc_cksum, suffix->sc_cksum, 
                                        syncSetErr(ENOEXEC, "Error:: patch file is broken! (wrong suffix crc)\n");                                                        MD5_DIGEST_LENGTH)) {
                                         sync_SetErr(ENOEXEC, "Error:: patch file is broken! "
                                                         "(wrong suffix crc)\n");
                                         ret = -1;                                          ret = -1;
                                         break;                                          break;
                                 }                                  }
Line 551  syncPatch(const char *csInput, const char *csDelta, co Line 569  syncPatch(const char *csInput, const char *csDelta, co
                         buffer = buf;                          buffer = buf;
                 }                  }
   
                // printf("i=%d off=%llu sfx=%p piece=%p pfx=%p pfx_off=%llu\n", i, off, suffix, piece, #if 0
                //                piece ? piece->pfx : 0l, piece->pfx ? piece->pfx->sc_off : 0l);                printf("i=%d off=%llu sfx=%p piece=%p pfx=%p pfx_off=%llu\n", i, off, 
                                 suffix, piece, piece ? piece->pfx : 0l, 
                                 piece->pfx ? piece->pfx->sc_off : 0l);
 #endif
   
                // if delta chunk match!                /* if delta chunk match! */
                 if (piece->pfx && piece->pfx->sc_off == off) {                  if (piece->pfx && piece->pfx->sc_off == off) {
                         if (!piece->buf) {                          if (!piece->buf) {
                                syncSetErr(ENOEXEC, "Error:: patch file is broken! (missing data)\n");                                sync_SetErr(ENOEXEC, "Error:: patch file is broken! "
                                                 "(missing data)\n");
                                 ret = -1;                                  ret = -1;
                                 break;                                  break;
                         }                          }
Line 569  syncPatch(const char *csInput, const char *csDelta, co Line 591  syncPatch(const char *csInput, const char *csDelta, co
                         piece++;                          piece++;
   
                         if (suffix && off >= sb.st_size) {                          if (suffix && off >= sb.st_size) {
                                syncSetErr(ENOEXEC, "Error:: patch file is broken! (after eof find suffix)\n");                                sync_SetErr(ENOEXEC, "Error:: patch file is broken! "
                                                 "(after eof find suffix)\n");
                                 ret = -1;                                  ret = -1;
                                 break;                                  break;
                         }                          }
                } else                } else if (off >= sb.st_size) {
                        if (off >= sb.st_size) {                       if (piece->pfx) {
                               if (piece->pfx) {                                sync_SetErr(ENOEXEC, "Error:: patch file is broken! "
                                        syncSetErr(ENOEXEC, "Error:: patch file is broken! (after eof find prefix)\n");                                                "(after eof find prefix)\n");
                                        ret = -1;                                ret = -1;
                                } 
 
                                break; 
                         }                          }
   
                           break;
                   }
   
                 ret = write(outf, buffer, readlen);                  ret = write(outf, buffer, readlen);
                 if (ret == -1 || ret != readlen) {                  if (ret == -1 || ret != readlen) {
                        SETERR;                        LOGERR;
                         break;                          break;
                 }                  }
         }          }
   
 end:  end:
        syncClose(inf);        sync_Close(inf);
        syncClose(outf);        sync_Close(outf);
         if (pieces)          if (pieces)
                 free(pieces);                  free(pieces);
         munmap(delta, sb.st_size);          munmap(delta, sb.st_size);
Removed from v.1.3  
changed lines
  Added in v.1.4

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