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

version 1.3, 2012/07/22 22:09:47 version 1.3.2.2, 2012/11/13 10:30:44
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;
   
Line 91  syncSetErr(int eno, char *estr, ...) Line 91  syncSetErr(int eno, char *estr, ...)
         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 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, MAXPATHLEN);
         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 is 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;
 }  }
   
Line 190  syncDelta(const char *csInput, const char *csSig, cons Line 191  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, MAXPATHLEN);
                 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 229  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 238  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);
         }          }
Line 257  syncDelta(const char *csInput, const char *csSig, cons Line 258  syncDelta(const char *csInput, const char *csSig, cons
         // build index from signature blocks          // build 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 274  syncDelta(const char *csInput, const char *csSig, cons Line 275  syncDelta(const char *csInput, const char *csSig, cons
   
         /* 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, MAXPATHLEN);
         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;
Line 293  syncDelta(const char *csInput, const char *csSig, cons Line 294  syncDelta(const char *csInput, const char *csSig, cons
   
         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;
Line 328  syncDelta(const char *csInput, const char *csSig, cons Line 329  syncDelta(const char *csInput, const char *csSig, cons
                         // 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 ...
                         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 361  syncDelta(const char *csInput, const char *csSig, cons Line 362  syncDelta(const char *csInput, const char *csSig, cons
                 // 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 379  syncDelta(const char *csInput, const char *csSig, cons Line 380  syncDelta(const char *csInput, const char *csSig, cons
                 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;
         }          }
Line 394  syncDelta(const char *csInput, const char *csSig, cons Line 395  syncDelta(const char *csInput, const char *csSig, cons
   
         // 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);
   
        syncClose(inf);        sync_Close(inf);
         free(tag_table);          free(tag_table);
         munmap(chunks, sb.st_size);          munmap(chunks, sb.st_size);
         return ret;          return ret;
Line 441  syncPatch(const char *csInput, const char *csDelta, co Line 442  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, MAXPATHLEN);
                 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 507  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 526  syncPatch(const char *csInput, const char *csDelta, co Line 527  syncPatch(const char *csInput, const char *csDelta, co
                 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 || suffix->sc_off != off) {
                                        syncSetErr(ENOEXEC, "Error:: patch file is broken! (wrong suffix pos)\n");                                        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, MD5_DIGEST_LENGTH)) {
                                        syncSetErr(ENOEXEC, "Error:: patch file is broken! (wrong suffix crc)\n");                                        sync_SetErr(ENOEXEC, "Error:: patch file is broken! (wrong suffix crc)\n");
                                         ret = -1;                                          ret = -1;
                                         break;                                          break;
                                 }                                  }
Line 557  syncPatch(const char *csInput, const char *csDelta, co Line 558  syncPatch(const char *csInput, const char *csDelta, co
                 // 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 570  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) {
                                        syncSetErr(ENOEXEC, "Error:: patch file is broken! (after eof find prefix)\n");                                        sync_SetErr(ENOEXEC, "Error:: patch file is broken! (after eof find prefix)\n");
                                         ret = -1;                                          ret = -1;
                                 }                                  }
   
Line 585  syncPatch(const char *csInput, const char *csDelta, co Line 586  syncPatch(const char *csInput, const char *csDelta, co
   
                 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.3.2.2

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