git.oblomov.eu Git - wine/blob - dlls/cabinet/fci.c

   1 /*
   2  * File Compression Interface
   3  *
   4  * Copyright 2002 Patrik Stridvall
   5  * Copyright 2005 Gerold Jens Wucherpfennig
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 /*
  23
  24 There is still some work to be done:
  25
  26 - no real compression yet
  27 - unknown behaviour if files>=2GB or cabinet >=4GB
  28 - check if the maximum size for a cabinet is too small to store any data
  29 - call pfnfcignc on exactly the same position as MS FCIAddFile in every case
  30 - probably check err
  31
  32 */
  33
  34
  35
  36 #include "config.h"
  37
  38 #include <stdarg.h>
  39 #include <stdio.h>
  40 #include <string.h>
  41
  42 #include "windef.h"
  43 #include "winbase.h"
  44 #include "winerror.h"
  45 #include "winternl.h"
  46 #include "fci.h"
  47 #include "cabinet.h"
  48 #include "wine/debug.h"
  49
  50
  51 #ifdef WORDS_BIGENDIAN
  52 #define fci_endian_ulong(x) RtlUlongByteSwap(x)
  53 #define fci_endian_uword(x) RtlUshortByteSwap(x)
  54 #else
  55 #define fci_endian_ulong(x) (x)
  56 #define fci_endian_uword(x) (x)
  57 #endif
  58
  59
  60 #define fci_set_error(A,B,C) do {      \
  61     p_fci_internal->perf->erfOper = A; \
  62     p_fci_internal->perf->erfType = B; \
  63     p_fci_internal->perf->fError =  C; \
  64     if (B) SetLastError(B); } while(0)
  65
  66
  67 typedef struct {
  68   cab_UBYTE signature[4]; /* !CAB for unfinished cabinets else MSCF */
  69   cab_ULONG reserved1;
  70   cab_ULONG cbCabinet;    /*  size of the cabinet file in bytes*/
  71   cab_ULONG reserved2;
  72   cab_ULONG coffFiles;    /* offset to first CFFILE section */
  73   cab_ULONG reserved3;
  74   cab_UBYTE versionMinor; /* 3 */
  75   cab_UBYTE versionMajor; /* 1 */
  76   cab_UWORD cFolders;     /* number of CFFOLDER entries in the cabinet*/
  77   cab_UWORD cFiles;       /* number of CFFILE entries in the cabinet*/
  78   cab_UWORD flags;        /* 1=prev cab, 2=next cabinet, 4=reserved setions*/
  79   cab_UWORD setID;        /* identification number of all cabinets in a set*/
  80   cab_UWORD iCabinet;     /* number of the cabinet in a set */
  81   /* additional area if "flags" were set*/
  82 } CFHEADER; /* minimum 36 bytes */
  83
  84 typedef struct {
  85   cab_ULONG coffCabStart; /* offset to the folder's first CFDATA section */
  86   cab_UWORD cCFData;      /* number of this folder's CFDATA sections */
  87   cab_UWORD typeCompress; /* compression type of data in CFDATA section*/
  88   /* additional area if reserve flag was set */
  89 } CFFOLDER; /* minumum 8 bytes */
  90
  91 typedef struct {
  92   cab_ULONG cbFile;          /* size of the uncompressed file in bytes */
  93   cab_ULONG uoffFolderStart; /* offset of the uncompressed file in the folder */
  94   cab_UWORD iFolder;         /* number of folder in the cabinet 0=first  */
  95                              /* for special values see below this structure*/
  96   cab_UWORD date;            /* last modification date*/
  97   cab_UWORD time;            /* last modification time*/
  98   cab_UWORD attribs;         /* DOS fat attributes and UTF indicator */
  99   /* ... and a C string with the name of the file */
 100 } CFFILE; /* 16 bytes + name of file */
 101
 102
 103 typedef struct {
 104   cab_ULONG csum;          /* checksum of this entry*/
 105   cab_UWORD cbData;        /* number of compressed bytes  */
 106   cab_UWORD cbUncomp;      /* number of bytes when data is uncompressed */
 107   /* optional reserved area */
 108   /* compressed data */
 109 } CFDATA;
 110
 111
 112 /***********************************************************************
 113  *              FCICreate (CABINET.10)
 114  *
 115  * FCICreate is provided with several callbacks and
 116  * returns a handle which can be used to create cabinet files.
 117  *
 118  * PARAMS
 119  *   perf       [IO]  A pointer to an ERF structure.  When FCICreate
 120  *                    returns an error condition, error information may
 121  *                    be found here as well as from GetLastError.
 122  *   pfnfiledest [I]  A pointer to a function which is called when a file
 123  *                    is placed. Only useful for subsequent cabinet files.
 124  *   pfnalloc    [I]  A pointer to a function which allocates ram.  Uses
 125  *                    the same interface as malloc.
 126  *   pfnfree     [I]  A pointer to a function which frees ram.  Uses the
 127  *                    same interface as free.
 128  *   pfnopen     [I]  A pointer to a function which opens a file.  Uses
 129  *                    the same interface as _open.
 130  *   pfnread     [I]  A pointer to a function which reads from a file into
 131  *                    a caller-provided buffer.  Uses the same interface
 132  *                    as _read.
 133  *   pfnwrite    [I]  A pointer to a function which writes to a file from
 134  *                    a caller-provided buffer.  Uses the same interface
 135  *                    as _write.
 136  *   pfnclose    [I]  A pointer to a function which closes a file handle.
 137  *                    Uses the same interface as _close.
 138  *   pfnseek     [I]  A pointer to a function which seeks in a file.
 139  *                    Uses the same interface as _lseek.
 140  *   pfndelete   [I]  A pointer to a function which deletes a file.
 141  *   pfnfcigtf   [I]  A pointer to a function which gets the name of a
 142  *                    temporary file.
 143  *   pccab       [I]  A pointer to an initialized CCAB structure.
 144  *   pv          [I]  A pointer to an application-defined notification
 145  *                    function which will be passed to other FCI functions
 146  *                    as a parameter.
 147  *
 148  * RETURNS
 149  *   On success, returns an FCI handle of type HFCI.
 150  *   On failure, the NULL file handle is returned. Error
 151  *   info can be retrieved from perf.
 152  *
 153  * INCLUDES
 154  *   fci.h
 155  *
 156  */
 157 HFCI __cdecl FCICreate(
 158         PERF perf,
 159         PFNFCIFILEPLACED   pfnfiledest,
 160         PFNFCIALLOC        pfnalloc,
 161         PFNFCIFREE         pfnfree,
 162         PFNFCIOPEN         pfnopen,
 163         PFNFCIREAD         pfnread,
 164         PFNFCIWRITE        pfnwrite,
 165         PFNFCICLOSE        pfnclose,
 166         PFNFCISEEK         pfnseek,
 167         PFNFCIDELETE       pfndelete,
 168         PFNFCIGETTEMPFILE  pfnfcigtf,
 169         PCCAB              pccab,
 170         void *pv)
 171 {
 172   HFCI hfci;
 173   int err;
 174   PFCI_Int p_fci_internal;
 175
 176   if ((!perf) || (!pfnalloc) || (!pfnfree) || (!pfnopen) || (!pfnread) ||
 177       (!pfnwrite) || (!pfnclose) || (!pfnseek) || (!pfndelete) ||
 178       (!pfnfcigtf) || (!pccab)) {
 179     perf->erfOper = FCIERR_NONE;
 180     perf->erfType = ERROR_BAD_ARGUMENTS;
 181     perf->fError = TRUE;
 182
 183     SetLastError(ERROR_BAD_ARGUMENTS);
 184     return NULL;
 185   }
 186
 187   if (!((hfci = ((HFCI) (*pfnalloc)(sizeof(FCI_Int)))))) {
 188     perf->erfOper = FCIERR_ALLOC_FAIL;
 189     perf->erfType = ERROR_NOT_ENOUGH_MEMORY;
 190     perf->fError = TRUE;
 191
 192     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 193     return NULL;
 194   }
 195
 196   p_fci_internal=((PFCI_Int)(hfci));
 197   p_fci_internal->FCI_Intmagic = FCI_INT_MAGIC;
 198   p_fci_internal->perf = perf;
 199   p_fci_internal->pfnfiledest = pfnfiledest;
 200   p_fci_internal->pfnalloc = pfnalloc;
 201   p_fci_internal->pfnfree = pfnfree;
 202   p_fci_internal->pfnopen = pfnopen;
 203   p_fci_internal->pfnread = pfnread;
 204   p_fci_internal->pfnwrite = pfnwrite;
 205   p_fci_internal->pfnclose = pfnclose;
 206   p_fci_internal->pfnseek = pfnseek;
 207   p_fci_internal->pfndelete = pfndelete;
 208   p_fci_internal->pfnfcigtf = pfnfcigtf;
 209   p_fci_internal->pccab = pccab;
 210   p_fci_internal->fPrevCab = FALSE;
 211   p_fci_internal->fNextCab = FALSE;
 212   p_fci_internal->fSplitFolder = FALSE;
 213   p_fci_internal->fGetNextCabInVain = FALSE;
 214   p_fci_internal->pv = pv;
 215   p_fci_internal->data_in  = NULL;
 216   p_fci_internal->cdata_in = 0;
 217   p_fci_internal->data_out = NULL;
 218   p_fci_internal->cCompressedBytesInFolder = 0;
 219   p_fci_internal->cFolders = 0;
 220   p_fci_internal->cFiles = 0;
 221   p_fci_internal->cDataBlocks = 0;
 222   p_fci_internal->sizeFileCFDATA1 = 0;
 223   p_fci_internal->sizeFileCFFILE1 = 0;
 224   p_fci_internal->sizeFileCFDATA2 = 0;
 225   p_fci_internal->sizeFileCFFILE2 = 0;
 226   p_fci_internal->sizeFileCFFOLDER = 0;
 227   p_fci_internal->sizeFileCFFOLDER = 0;
 228   p_fci_internal->fNewPrevious = FALSE;
 229   p_fci_internal->estimatedCabinetSize = 0;
 230   p_fci_internal->statusFolderTotal = 0;
 231
 232   memcpy(p_fci_internal->szPrevCab, pccab->szCab, CB_MAX_CABINET_NAME);
 233   memcpy(p_fci_internal->szPrevDisk, pccab->szDisk, CB_MAX_DISK_NAME);
 234
 235   /* CFDATA */
 236   if( !PFCI_GETTEMPFILE(hfci,p_fci_internal->szFileNameCFDATA1,
 237       CB_MAX_FILENAME)) {
 238     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
 239     return FALSE;
 240   }
 241   /* safety */
 242   if ( strlen(p_fci_internal->szFileNameCFDATA1) >= CB_MAX_FILENAME ) {
 243     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
 244     return FALSE;
 245   }
 246
 247   p_fci_internal->handleCFDATA1 = PFCI_OPEN(hfci,
 248     p_fci_internal->szFileNameCFDATA1, 34050, 384, &err, pv);
 249   if(p_fci_internal->handleCFDATA1==0){
 250     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE );
 251     return FALSE;
 252   }
 253   /* TODO error checking of err */
 254
 255   /* array of all CFFILE in a folder */
 256   if( !PFCI_GETTEMPFILE(hfci,p_fci_internal->szFileNameCFFILE1,
 257       CB_MAX_FILENAME)) {
 258     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
 259     return FALSE;
 260   }
 261   /* safety */
 262   if ( strlen(p_fci_internal->szFileNameCFFILE1) >= CB_MAX_FILENAME ) {
 263     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
 264     return FALSE;
 265   }
 266   p_fci_internal->handleCFFILE1 = PFCI_OPEN(hfci,
 267     p_fci_internal->szFileNameCFFILE1, 34050, 384, &err, pv);
 268   if(p_fci_internal->handleCFFILE1==0){
 269     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE );
 270     return FALSE;
 271   }
 272   /* TODO error checking of err */
 273
 274   /* CFDATA with checksum and ready to be copied into cabinet */
 275   if( !PFCI_GETTEMPFILE(hfci,p_fci_internal->szFileNameCFDATA2,
 276       CB_MAX_FILENAME)) {
 277     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE);
 278     return FALSE;
 279   }
 280   /* safety */
 281   if ( strlen(p_fci_internal->szFileNameCFDATA2) >= CB_MAX_FILENAME ) {
 282     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
 283     return FALSE;
 284   }
 285   p_fci_internal->handleCFDATA2 = PFCI_OPEN(hfci,
 286     p_fci_internal->szFileNameCFDATA2, 34050, 384, &err, pv);
 287   if(p_fci_internal->handleCFDATA2==0){
 288     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE );
 289     return FALSE;
 290   }
 291   /* TODO error checking of err */
 292
 293   /* array of all CFFILE in a folder, ready to be copied into cabinet */
 294   if( !PFCI_GETTEMPFILE(hfci,p_fci_internal->szFileNameCFFILE2,
 295       CB_MAX_FILENAME)) {
 296     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
 297     return FALSE;
 298   }
 299   /* safety */
 300   if ( strlen(p_fci_internal->szFileNameCFFILE2) >= CB_MAX_FILENAME ) {
 301     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
 302     return FALSE;
 303   }
 304   p_fci_internal->handleCFFILE2 = PFCI_OPEN(hfci,
 305     p_fci_internal->szFileNameCFFILE2, 34050, 384, &err, pv);
 306   if(p_fci_internal->handleCFFILE2==0){
 307     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE );
 308     return FALSE;
 309   }
 310   /* TODO error checking of err */
 311
 312   /* array of all CFFILE in a folder, ready to be copied into cabinet */
 313   if( !PFCI_GETTEMPFILE(hfci,p_fci_internal->szFileNameCFFOLDER,
 314       CB_MAX_FILENAME)) {
 315     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
 316     return FALSE;
 317   }
 318   /* safety */
 319   if ( strlen(p_fci_internal->szFileNameCFFOLDER) >= CB_MAX_FILENAME ) {
 320     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
 321     return FALSE;
 322   }
 323   p_fci_internal->handleCFFOLDER = PFCI_OPEN(hfci,
 324     p_fci_internal->szFileNameCFFOLDER, 34050, 384, &err, pv);
 325   if(p_fci_internal->handleCFFOLDER==0) {
 326     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE);
 327     return FALSE;
 328   }
 329
 330   /* TODO close and delete new files when return FALSE */
 331   /* TODO error checking of err */
 332
 333   return hfci;
 334 } /* end of FCICreate */
 335
 336
 337
 338
 339
 340
 341 static BOOL fci_flush_data_block (HFCI hfci, int* err,
 342     PFNFCISTATUS pfnfcis) {
 343
 344   /* attention no hfci checks!!! */
 345   /* attention no checks if there is data available!!! */
 346   CFDATA data;
 347   CFDATA* cfdata=&data;
 348   char* reserved;
 349   PFCI_Int p_fci_internal=((PFCI_Int)(hfci));
 350   UINT cbReserveCFData=p_fci_internal->pccab->cbReserveCFData;
 351   UINT i;
 352
 353   /* TODO compress the data of p_fci_internal->data_in */
 354   /* and write it to p_fci_internal->data_out */
 355   memcpy(p_fci_internal->data_out, p_fci_internal->data_in,
 356     p_fci_internal->cdata_in /* number of bytes to copy */);
 357
 358   cfdata->csum=0; /* checksum has to be set later */
 359   /* TODO set realsize of compressed data */
 360   cfdata->cbData   = p_fci_internal->cdata_in;
 361   cfdata->cbUncomp = p_fci_internal->cdata_in;
 362
 363   /* write cfdata to p_fci_internal->handleCFDATA1 */
 364   if( PFCI_WRITE(hfci, p_fci_internal->handleCFDATA1, /* file handle */
 365       cfdata, sizeof(*cfdata), err, p_fci_internal->pv)
 366       != sizeof(*cfdata) ) {
 367     fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 368     return FALSE;
 369   }
 370   /* TODO error handling of err */
 371
 372   p_fci_internal->sizeFileCFDATA1 += sizeof(*cfdata);
 373
 374   /* add optional reserved area */
 375
 376   /* This allocation and freeing at each CFData block is a bit */
 377   /* inefficent, but it's harder to forget about freeing the buffer :-). */
 378   /* Reserved areas are used seldom besides that... */
 379   if (cbReserveCFData!=0) {
 380     if(!(reserved = (char*)PFCI_ALLOC(hfci, cbReserveCFData))) {
 381       fci_set_error( FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY, TRUE );
 382       return FALSE;
 383     }
 384     for(i=0;i<cbReserveCFData;) {
 385       reserved[i++]='\0';
 386     }
 387     if( PFCI_WRITE(hfci, p_fci_internal->handleCFDATA1, /* file handle */
 388         reserved, /* memory buffer */
 389         cbReserveCFData, /* number of bytes to copy */
 390         err, p_fci_internal->pv) != cbReserveCFData ) {
 391       PFCI_FREE(hfci, reserved);
 392       fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 393       return FALSE;
 394     }
 395     /* TODO error handling of err PFCI_FREE(hfci, reserved)*/
 396
 397     p_fci_internal->sizeFileCFDATA1 += cbReserveCFData;
 398     PFCI_FREE(hfci, reserved);
 399   }
 400
 401   /* write p_fci_internal->data_out to p_fci_internal->handleCFDATA1 */
 402   if( PFCI_WRITE(hfci, p_fci_internal->handleCFDATA1, /* file handle */
 403       p_fci_internal->data_out, /* memory buffer */
 404       cfdata->cbData, /* number of bytes to copy */
 405       err, p_fci_internal->pv) != cfdata->cbData) {
 406     fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 407     return FALSE;
 408   }
 409   /* TODO error handling of err */
 410
 411   p_fci_internal->sizeFileCFDATA1 += cfdata->cbData;
 412
 413   /* reset the offset */
 414   p_fci_internal->cdata_in = 0;
 415   p_fci_internal->cCompressedBytesInFolder += cfdata->cbData;
 416
 417   /* report status with pfnfcis about uncompressed and compressed file data */
 418   if( (*pfnfcis)(statusFile, cfdata->cbData, cfdata->cbUncomp,
 419       p_fci_internal->pv) == -1) {
 420     fci_set_error( FCIERR_USER_ABORT, 0, TRUE );
 421     return FALSE;
 422   }
 423
 424   ++(p_fci_internal->cDataBlocks);
 425
 426   return TRUE;
 427 } /* end of fci_flush_data_block */
 428
 429
 430
 431
 432
 433 static cab_ULONG fci_get_checksum(void *pv, UINT cb, CHECKSUM seed)
 434 {
 435   cab_ULONG csum;
 436   cab_ULONG ul;
 437   int       cUlong;
 438   BYTE      *pb;
 439
 440   csum = seed;
 441   cUlong = cb / 4;
 442   pb = pv;
 443
 444   while (cUlong-- > 0) {
 445     ul = *pb++;
 446     ul |= (((cab_ULONG)(*pb++)) <<  8);
 447     ul |= (((cab_ULONG)(*pb++)) << 16);
 448     ul |= (((cab_ULONG)(*pb++)) << 24);
 449
 450     csum ^= ul;
 451   }
 452
 453   ul = 0;
 454   switch (cb % 4) {
 455     case 3:
 456       ul |= (((ULONG)(*pb++)) << 16);
 457     case 2:
 458       ul |= (((ULONG)(*pb++)) <<  8);
 459     case 1:
 460       ul |= *pb++;
 461     default:
 462       break;
 463   }
 464   csum ^= ul;
 465
 466   return csum;
 467 } /* end of fci_get_checksum */
 468
 469
 470
 471 static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveCFData,
 472   PFNFCISTATUS pfnfcis, int* err, int handleCFDATA1new,
 473   cab_ULONG* psizeFileCFDATA1new, cab_ULONG* payload)
 474 {
 475   cab_ULONG read_result;
 476   CFDATA* pcfdata=(CFDATA*)buffer;
 477   BOOL split_block=FALSE;
 478   cab_UWORD savedUncomp=0;
 479   PFCI_Int p_fci_internal=((PFCI_Int)(hfci));
 480
 481   *payload=0;
 482
 483   /* while not all CFDATAs have been copied do */
 484   while(!FALSE) {
 485     if( p_fci_internal->fNextCab ) {
 486       if( split_block ) {
 487         /* internal error should never happen */
 488         fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
 489         return FALSE;
 490       }
 491     }
 492     /* REUSE the variable read_result */
 493     if ( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
 494         p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
 495         p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
 496       read_result=4;
 497     } else {
 498       read_result=0;
 499     }
 500     if (p_fci_internal->fPrevCab) {
 501       read_result+=strlen(p_fci_internal->szPrevCab)+1 +
 502         strlen(p_fci_internal->szPrevDisk)+1;
 503     }
 504     /* No more CFDATA fits into the cabinet under construction */
 505     /* So don't try to store more data into it */
 506     if( p_fci_internal->fNextCab &&
 507         (p_fci_internal->oldCCAB.cb <= sizeof(CFDATA) + cbReserveCFData +
 508         p_fci_internal->sizeFileCFFILE1 + p_fci_internal->sizeFileCFDATA2 +
 509         p_fci_internal->sizeFileCFFILE2 + p_fci_internal->sizeFileCFFOLDER +
 510         sizeof(CFHEADER) +
 511         read_result +
 512         p_fci_internal->oldCCAB.cbReserveCFHeader +
 513         sizeof(CFFOLDER) +
 514         p_fci_internal->oldCCAB.cbReserveCFFolder +
 515         strlen(p_fci_internal->pccab->szCab)+1 +
 516         strlen(p_fci_internal->pccab->szDisk)+1
 517     )) {
 518       /* This may never be run for the first time the while loop is entered.
 519       Pray that the code that calls fci_flushfolder_copy_cfdata handles this.*/
 520       split_block=TRUE;  /* In this case split_block is abused to store */
 521       /* the complete data block into the next cabinet and not into the */
 522       /* current one. Originally split_block is the indicator that a */
 523       /* data block has been splitted across different cabinets. */
 524     } else {
 525
 526       /* read CFDATA from p_fci_internal->handleCFDATA1 to cfdata*/
 527       read_result= PFCI_READ(hfci, p_fci_internal->handleCFDATA1,/*file handle*/
 528           buffer, /* memory buffer */
 529           sizeof(CFDATA)+cbReserveCFData, /* number of bytes to copy */
 530           err, p_fci_internal->pv);
 531       if (read_result!=sizeof(CFDATA)+cbReserveCFData) {
 532         if (read_result==0) break; /* ALL DATA has been copied */
 533         /* read error */
 534         fci_set_error( FCIERR_NONE, ERROR_READ_FAULT, TRUE );
 535         return FALSE;
 536       }
 537       /* TODO error handling of err */
 538
 539       /* REUSE buffer p_fci_internal->data_out !!! */
 540       /* read data from p_fci_internal->handleCFDATA1 to */
 541       /*      p_fci_internal->data_out */
 542       if( PFCI_READ(hfci, p_fci_internal->handleCFDATA1 /* file handle */,
 543           p_fci_internal->data_out /* memory buffer */,
 544           pcfdata->cbData /* number of bytes to copy */,
 545           err, p_fci_internal->pv) != pcfdata->cbData ) {
 546         /* read error */
 547         fci_set_error( FCIERR_NONE, ERROR_READ_FAULT, TRUE );
 548         return FALSE;
 549       }
 550       /* TODO error handling of err */
 551
 552       /* if cabinet size is too large */
 553
 554       /* REUSE the variable read_result */
 555       if ( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
 556           p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
 557           p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
 558         read_result=4;
 559       } else {
 560         read_result=0;
 561       }
 562       if (p_fci_internal->fPrevCab) {
 563         read_result+=strlen(p_fci_internal->szPrevCab)+1 +
 564           strlen(p_fci_internal->szPrevDisk)+1;
 565       }
 566
 567       /* Is cabinet with new CFDATA too large? Then data block has to be split */
 568       if( p_fci_internal->fNextCab &&
 569           (p_fci_internal->oldCCAB.cb < sizeof(CFDATA) + cbReserveCFData +
 570           pcfdata->cbData +
 571           p_fci_internal->sizeFileCFFILE1 + p_fci_internal->sizeFileCFDATA2 +
 572           p_fci_internal->sizeFileCFFILE2 + p_fci_internal->sizeFileCFFOLDER +
 573           sizeof(CFHEADER) +
 574           read_result +
 575           p_fci_internal->oldCCAB.cbReserveCFHeader +
 576           sizeof(CFFOLDER) + /* size of new CFFolder entry */
 577           p_fci_internal->oldCCAB.cbReserveCFFolder +
 578           strlen(p_fci_internal->pccab->szCab)+1 + /* name of next cabinet */
 579           strlen(p_fci_internal->pccab->szDisk)+1  /* name of next disk */
 580       )) {
 581         /* REUSE read_result to save the size of the compressed data */
 582         read_result=pcfdata->cbData;
 583         /* Modify the size of the compressed data to store only a part of the */
 584         /* data block into the current cabinet. This is done to prevent */
 585         /* that the maximum cabinet size will be exceeded. The remainder */
 586         /* will be stored into the next following cabinet. */
 587
 588         /* The cabinet will be of size "p_fci_internal->oldCCAB.cb". */
 589         /* Substract everything except the size of the block of data */
 590         /* to get it's actual size */
 591         pcfdata->cbData = p_fci_internal->oldCCAB.cb - (
 592           sizeof(CFDATA) + cbReserveCFData +
 593           p_fci_internal->sizeFileCFFILE1 + p_fci_internal->sizeFileCFDATA2 +
 594           p_fci_internal->sizeFileCFFILE2 + p_fci_internal->sizeFileCFFOLDER +
 595           sizeof(CFHEADER) +
 596           p_fci_internal->oldCCAB.cbReserveCFHeader +
 597           sizeof(CFFOLDER) + /* set size of new CFFolder entry */
 598           p_fci_internal->oldCCAB.cbReserveCFFolder );
 599         /* substract the size of special header fields */
 600         if ( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
 601             p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
 602             p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
 603           pcfdata->cbData-=4;
 604         }
 605         if (p_fci_internal->fPrevCab) {
 606           pcfdata->cbData-=strlen(p_fci_internal->szPrevCab)+1 +
 607             strlen(p_fci_internal->szPrevDisk)+1;
 608         }
 609         pcfdata->cbData-=strlen(p_fci_internal->pccab->szCab)+1 +
 610           strlen(p_fci_internal->pccab->szDisk)+1;
 611
 612         savedUncomp = pcfdata->cbUncomp;
 613         pcfdata->cbUncomp = 0; /* on splitted blocks of data this is zero */
 614
 615         /* if split_block==TRUE then the above while loop won't */
 616         /* be executed again */
 617         split_block=TRUE; /* split_block is the indicator that */
 618                           /* a data block has been splitted across */
 619                           /* diffentent cabinets.*/
 620       }
 621
 622       /* This should never happen !!! */
 623       if (pcfdata->cbData==0) {
 624         /* set error */
 625         fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
 626         return FALSE;
 627       }
 628
 629       /* set little endian */
 630       pcfdata->cbData=fci_endian_uword(pcfdata->cbData);
 631       pcfdata->cbUncomp=fci_endian_uword(pcfdata->cbUncomp);
 632
 633       /* get checksum and write to cfdata.csum */
 634       pcfdata->csum = fci_get_checksum( &(pcfdata->cbData),
 635         sizeof(CFDATA)+cbReserveCFData -
 636         sizeof(pcfdata->csum), fci_get_checksum( p_fci_internal->data_out, /*buffer*/
 637         pcfdata->cbData, 0 ) );
 638
 639       /* set little endian */
 640       pcfdata->csum=fci_endian_ulong(pcfdata->csum);
 641
 642       /* write cfdata with checksum to p_fci_internal->handleCFDATA2 */
 643       if( PFCI_WRITE(hfci, p_fci_internal->handleCFDATA2, /* file handle */
 644           buffer, /* memory buffer */
 645           sizeof(CFDATA)+cbReserveCFData, /* number of bytes to copy */
 646           err, p_fci_internal->pv) != sizeof(CFDATA)+cbReserveCFData ) {
 647          fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 648          return FALSE;
 649       }
 650       /* TODO error handling of err */
 651
 652       p_fci_internal->sizeFileCFDATA2 += sizeof(CFDATA)+cbReserveCFData;
 653
 654       /* reset little endian */
 655       pcfdata->cbData=fci_endian_uword(pcfdata->cbData);
 656       pcfdata->cbUncomp=fci_endian_uword(pcfdata->cbUncomp);
 657       pcfdata->csum=fci_endian_ulong(pcfdata->csum);
 658
 659       /* write compressed data into p_fci_internal->handleCFDATA2 */
 660       if( PFCI_WRITE(hfci, p_fci_internal->handleCFDATA2, /* file handle */
 661           p_fci_internal->data_out, /* memory buffer */
 662           pcfdata->cbData, /* number of bytes to copy */
 663           err, p_fci_internal->pv) != pcfdata->cbData) {
 664         fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 665         return FALSE;
 666       }
 667       /* TODO error handling of err */
 668
 669       p_fci_internal->sizeFileCFDATA2 += pcfdata->cbData;
 670       ++(p_fci_internal->cDataBlocks);
 671       p_fci_internal->statusFolderCopied += pcfdata->cbData;
 672       (*payload)+=pcfdata->cbUncomp;
 673       /* if cabinet size too large and data has been split */
 674       /* write the remainder of the data block to the new CFDATA1 file */
 675       if( split_block  ) { /* This does not include the */
 676                                   /* abused one (just search for "abused" )*/
 677       /* copy all CFDATA structures from handleCFDATA1 to handleCFDATA1new */
 678         if (p_fci_internal->fNextCab==FALSE ) {
 679           /* internal error */
 680           fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
 681           return FALSE;
 682         }
 683
 684         /* set cbData to the size of the remainder of the data block */
 685         pcfdata->cbData = read_result - pcfdata->cbData;
 686         /*recover former value of cfdata.cbData; read_result will be the offset*/
 687         read_result -= pcfdata->cbData;
 688         pcfdata->cbUncomp = savedUncomp;
 689
 690         /* reset checksum, it will be computed later */
 691         pcfdata->csum=0;
 692
 693         /* write cfdata WITHOUT checksum to handleCFDATA1new */
 694         if( PFCI_WRITE(hfci, handleCFDATA1new, /* file handle */
 695             buffer, /* memory buffer */
 696             sizeof(CFDATA)+cbReserveCFData, /* number of bytes to copy */
 697             err, p_fci_internal->pv) != sizeof(CFDATA)+cbReserveCFData ) {
 698           fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 699           return FALSE;
 700         }
 701         /* TODO error handling of err don't forget PFCI_FREE(hfci, reserved) */
 702
 703         *psizeFileCFDATA1new += sizeof(CFDATA)+cbReserveCFData;
 704
 705         /* write compressed data into handleCFDATA1new */
 706         if( PFCI_WRITE(hfci, handleCFDATA1new, /* file handle */
 707             p_fci_internal->data_out + read_result, /* memory buffer + offset */
 708                                                 /* to last part of split data */
 709             pcfdata->cbData, /* number of bytes to copy */
 710             err, p_fci_internal->pv) != pcfdata->cbData) {
 711           fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 712           return FALSE;
 713         }
 714         /* TODO error handling of err */
 715
 716         p_fci_internal->statusFolderCopied += pcfdata->cbData;
 717
 718         *psizeFileCFDATA1new += pcfdata->cbData;
 719         /* the two blocks of the split data block have been written */
 720         /* don't reset split_data yet, because it is still needed see below */
 721       }
 722
 723       /* report status with pfnfcis about copied size of folder */
 724       if( (*pfnfcis)(statusFolder,
 725           p_fci_internal->statusFolderCopied, /*cfdata.cbData(+previous ones)*/
 726           p_fci_internal->statusFolderTotal, /* total folder size */
 727           p_fci_internal->pv) == -1) {
 728         fci_set_error( FCIERR_USER_ABORT, 0, TRUE );
 729         return FALSE;
 730       }
 731     }
 732
 733     /* if cabinet size too large */
 734     /* write the remaining data blocks to the new CFDATA1 file */
 735     if ( split_block ) { /* This does include the */
 736                                /* abused one (just search for "abused" )*/
 737       if (p_fci_internal->fNextCab==FALSE ) {
 738         /* internal error */
 739         fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
 740         return FALSE;
 741       }
 742       /* copy all CFDATA structures from handleCFDATA1 to handleCFDATA1new */
 743       while(!FALSE) {
 744         /* read CFDATA from p_fci_internal->handleCFDATA1 to cfdata*/
 745         read_result= PFCI_READ(hfci, p_fci_internal->handleCFDATA1,/* handle */
 746             buffer, /* memory buffer */
 747             sizeof(CFDATA)+cbReserveCFData, /* number of bytes to copy */
 748             err, p_fci_internal->pv);
 749         if (read_result!=sizeof(CFDATA)+cbReserveCFData) {
 750           if (read_result==0) break; /* ALL DATA has been copied */
 751           /* read error */
 752           fci_set_error(FCIERR_NONE, ERROR_READ_FAULT, TRUE );
 753           return FALSE;
 754         }
 755         /* TODO error handling of err */
 756
 757         /* REUSE buffer p_fci_internal->data_out !!! */
 758         /* read data from p_fci_internal->handleCFDATA1 to */
 759         /*      p_fci_internal->data_out */
 760         if( PFCI_READ(hfci, p_fci_internal->handleCFDATA1 /* file handle */,
 761             p_fci_internal->data_out /* memory buffer */,
 762             pcfdata->cbData /* number of bytes to copy */,
 763             err, p_fci_internal->pv) != pcfdata->cbData ) {
 764           /* read error */
 765           fci_set_error( FCIERR_NONE, ERROR_READ_FAULT, TRUE);
 766           return FALSE;
 767         }
 768         /* TODO error handling of err don't forget PFCI_FREE(hfci, reserved) */
 769
 770         /* write cfdata with checksum to handleCFDATA1new */
 771         if( PFCI_WRITE(hfci, handleCFDATA1new, /* file handle */
 772             buffer, /* memory buffer */
 773             sizeof(CFDATA)+cbReserveCFData, /* number of bytes to copy */
 774             err, p_fci_internal->pv) != sizeof(CFDATA)+cbReserveCFData ) {
 775           fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 776           return FALSE;
 777         }
 778         /* TODO error handling of err don't forget PFCI_FREE(hfci, reserved) */
 779
 780         *psizeFileCFDATA1new += sizeof(CFDATA)+cbReserveCFData;
 781
 782         /* write compressed data into handleCFDATA1new */
 783         if( PFCI_WRITE(hfci, handleCFDATA1new, /* file handle */
 784             p_fci_internal->data_out, /* memory buffer */
 785             pcfdata->cbData, /* number of bytes to copy */
 786             err, p_fci_internal->pv) != pcfdata->cbData) {
 787           fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 788           return FALSE;
 789         }
 790         /* TODO error handling of err */
 791
 792         *psizeFileCFDATA1new += pcfdata->cbData;
 793         p_fci_internal->statusFolderCopied += pcfdata->cbData;
 794
 795         /* report status with pfnfcis about copied size of folder */
 796         if( (*pfnfcis)(statusFolder,
 797             p_fci_internal->statusFolderCopied,/*cfdata.cbData(+revious ones)*/
 798             p_fci_internal->statusFolderTotal, /* total folder size */
 799             p_fci_internal->pv) == -1) {
 800           fci_set_error( FCIERR_USER_ABORT, 0, TRUE );
 801           return FALSE;
 802         }
 803
 804       } /* end of WHILE */
 805       break; /* jump out of the next while loop */
 806     } /* end of if( split_data  ) */
 807   } /* end of WHILE */
 808   return TRUE;
 809 } /* end of fci_flushfolder_copy_cfdata */
 810
 811
 812
 813
 814
 815 static BOOL fci_flushfolder_copy_cffolder(HFCI hfci, int* err, UINT cbReserveCFFolder,
 816   cab_ULONG sizeFileCFDATA2old)
 817 {
 818   CFFOLDER cffolder;
 819   UINT i;
 820   char* reserved;
 821   PFCI_Int p_fci_internal=((PFCI_Int)(hfci));
 822
 823   /* absolute offset cannot be set yet, because the size of cabinet header, */
 824   /* the number of CFFOLDERs and the number of CFFILEs may change. */
 825   /* Instead the size of all previous data blocks will be stored and */
 826   /* the remainder of the offset will be added when the cabinet will be */
 827   /* flushed to disk. */
 828   /* This is exactly the way the original CABINET.DLL works!!! */
 829   cffolder.coffCabStart=sizeFileCFDATA2old;
 830
 831   /* set the number of this folder's CFDATA sections */
 832   cffolder.cCFData=p_fci_internal->cDataBlocks;
 833   /* TODO set compression type */
 834   cffolder.typeCompress = tcompTYPE_NONE;
 835
 836   /* write cffolder to p_fci_internal->handleCFFOLDER */
 837   if( PFCI_WRITE(hfci, p_fci_internal->handleCFFOLDER, /* file handle */
 838       &cffolder, /* memory buffer */
 839       sizeof(cffolder), /* number of bytes to copy */
 840       err, p_fci_internal->pv) != sizeof(cffolder) ) {
 841     fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 842     return FALSE;
 843   }
 844   /* TODO error handling of err */
 845
 846   p_fci_internal->sizeFileCFFOLDER += sizeof(cffolder);
 847
 848   /* add optional reserved area */
 849   if (cbReserveCFFolder!=0) {
 850     if(!(reserved = (char*)PFCI_ALLOC(hfci, cbReserveCFFolder))) {
 851       fci_set_error( FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY, TRUE );
 852       return FALSE;
 853     }
 854     for(i=0;i<cbReserveCFFolder;) {
 855       reserved[i++]='\0';
 856     }
 857     if( PFCI_WRITE(hfci, p_fci_internal->handleCFFOLDER, /* file handle */
 858         reserved, /* memory buffer */
 859         cbReserveCFFolder, /* number of bytes to copy */
 860         err, p_fci_internal->pv) != cbReserveCFFolder ) {
 861       PFCI_FREE(hfci, reserved);
 862       fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
 863       return FALSE;
 864     }
 865     /* TODO error handling of err */
 866
 867     p_fci_internal->sizeFileCFFOLDER += cbReserveCFFolder;
 868
 869     PFCI_FREE(hfci, reserved);
 870   }
 871   return TRUE;
 872 } /* end of fci_flushfolder_copy_cffolder */
 873
 874
 875
 876
 877
 878 static BOOL fci_flushfolder_copy_cffile(HFCI hfci, int* err, int handleCFFILE1new,
 879   cab_ULONG *psizeFileCFFILE1new, cab_ULONG payload)
 880 {
 881   CFFILE cffile;
 882   cab_ULONG read_result;
 883   cab_ULONG seek=0;
 884   cab_ULONG sizeOfFiles=0, sizeOfFilesPrev;
 885   BOOL may_be_prev=TRUE;
 886   cab_ULONG cbFileRemainer=0;
 887   PFCI_Int p_fci_internal=((PFCI_Int)(hfci));
 888   /* set seek of p_fci_internal->handleCFFILE1 to 0 */
 889   if( PFCI_SEEK(hfci,p_fci_internal->handleCFFILE1,0,SEEK_SET,err,
 890     p_fci_internal->pv) !=0 ) {
 891     /* wrong return value */
 892     fci_set_error( FCIERR_NONE, ERROR_SEEK, TRUE );
 893     return FALSE;
 894   }
 895   /* TODO error handling of err */
 896
 897   /* while not all CFFILE structures have been copied do */
 898   while(!FALSE) {
 899     /* REUSE the variable read_result */
 900     /* read data from p_fci_internal->handleCFFILE1 to cffile */
 901     read_result = PFCI_READ(hfci,p_fci_internal->handleCFFILE1/* file handle */,
 902       &cffile, /* memory buffer */
 903       sizeof(cffile), /* number of bytes to copy */
 904       err, p_fci_internal->pv);
 905     if( read_result != sizeof(cffile) ) {
 906       if( read_result == 0 ) break; /* ALL CFFILE structures have been copied */
 907       /* read error */
 908       fci_set_error( FCIERR_NONE, ERROR_READ_FAULT, TRUE );
 909       return FALSE;
 910     }
 911     /* TODO error handling of err */
 912
 913     /* Microsoft's(R) CABINET.DLL would do a seek to the current! */
 914     /* position. I don't know why so I'll just omit it */
 915
 916     /* read the filename from p_fci_internal->handleCFFILE1 */
 917     /* REUSE the variable read_result AGAIN */
 918     /* REUSE the memory buffer PFCI(hfci)->data_out */
 919     if( PFCI_READ(hfci, p_fci_internal->handleCFFILE1 /*file handle*/,
 920         p_fci_internal->data_out, /* memory buffer */
 921         CB_MAX_FILENAME, /* number of bytes to copy */
 922         err, p_fci_internal->pv) <2) {
 923       /* read error */
 924       fci_set_error( FCIERR_NONE, ERROR_READ_FAULT, TRUE );
 925       return FALSE;
 926     }
 927     /* TODO maybe other checks of read_result */
 928     /* TODO error handling of err */
 929
 930     /* safety */
 931     if( strlen(p_fci_internal->data_out)>=CB_MAX_FILENAME ) {
 932       /* set error code internal error */
 933       fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
 934       return FALSE;
 935     }
 936
 937     seek+=sizeof(cffile) + strlen(p_fci_internal->data_out)+1;
 938
 939     /* set seek of p_fci_internal->handleCFFILE1 to end of file name */
 940     /* i.e. seek to the next CFFILE area */
 941     if( PFCI_SEEK(hfci,p_fci_internal->handleCFFILE1,
 942         seek, /* seek position*/
 943         SEEK_SET ,err,
 944         p_fci_internal->pv)
 945         != seek) {
 946       /* wrong return value */
 947       fci_set_error( FCIERR_NONE, ERROR_SEEK, TRUE );
 948       return FALSE;
 949     }
 950     /* TODO error handling of err */
 951
 952     /* fnfilfnfildest: placed file on cabinet */
 953     if (p_fci_internal->fNextCab ||
 954         p_fci_internal->fGetNextCabInVain) {
 955       PFCI_FILEPLACED( hfci, &(p_fci_internal->oldCCAB),
 956         p_fci_internal->data_out, /* the file name*/
 957         cffile.cbFile, /* file size */
 958         (cffile.iFolder==cffileCONTINUED_FROM_PREV),
 959         p_fci_internal->pv
 960       );
 961     } else {
 962       PFCI_FILEPLACED( hfci, p_fci_internal->pccab,
 963         p_fci_internal->data_out, /* the file name*/
 964         cffile.cbFile, /* file size */
 965         (cffile.iFolder==cffileCONTINUED_FROM_PREV),
 966         p_fci_internal->pv
 967       );
 968     }
 969
 970     /* Check special iFolder values */
 971     if( cffile.iFolder==cffileCONTINUED_FROM_PREV &&
 972         p_fci_internal->fPrevCab==FALSE ) {
 973       /* THIS MAY NEVER HAPPEN */
 974       /* set error code */
 975       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
 976       return FALSE;
 977     }
 978     if( cffile.iFolder==cffileCONTINUED_PREV_AND_NEXT ||
 979         cffile.iFolder==cffileCONTINUED_TO_NEXT ) {
 980       /* THIS MAY NEVER HAPPEN */
 981       /* set error code */
 982       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
 983       return FALSE;
 984     }
 985     if( may_be_prev && cffile.iFolder!=cffileCONTINUED_FROM_PREV ) {
 986       may_be_prev=FALSE;
 987     }
 988     if( cffile.iFolder==cffileCONTINUED_FROM_PREV && may_be_prev==FALSE ) {
 989       /* THIS MAY NEVER HAPPEN */
 990       /* set error code */
 991       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
 992       return FALSE;
 993     }
 994     if( cffile.iFolder!=cffileCONTINUED_FROM_PREV ) {
 995       may_be_prev=FALSE;
 996     }
 997
 998     sizeOfFilesPrev=sizeOfFiles;
 999     /* Set complete size of all processed files */
1000     if( cffile.iFolder==cffileCONTINUED_FROM_PREV &&
1001         p_fci_internal->cbFileRemainer!=0
1002     ) {
1003       sizeOfFiles+=p_fci_internal->cbFileRemainer;
1004       p_fci_internal->cbFileRemainer=0;
1005     } else {
1006       sizeOfFiles+=cffile.cbFile;
1007     }
1008
1009     /* Check if spanned file fits into this cabinet folder */
1010     if( cffile.iFolder==cffileCONTINUED_FROM_PREV && sizeOfFiles>payload ) {
1011       cffile.iFolder=cffileCONTINUED_PREV_AND_NEXT;
1012     } else
1013
1014     /* Check if file doesn't fit into this cabinet folder */
1015     if( sizeOfFiles>payload ) {
1016       cffile.iFolder=cffileCONTINUED_TO_NEXT;
1017     }
1018
1019     /* set little endian */
1020     cffile.cbFile=fci_endian_ulong(cffile.cbFile);
1021     cffile.uoffFolderStart=fci_endian_ulong(cffile.uoffFolderStart);
1022     cffile.iFolder=fci_endian_uword(cffile.iFolder);
1023     cffile.date=fci_endian_uword(cffile.date);
1024     cffile.time=fci_endian_uword(cffile.time);
1025     cffile.attribs=fci_endian_uword(cffile.attribs);
1026
1027     /* write cffile to p_fci_internal->handleCFFILE2 */
1028     if( PFCI_WRITE(hfci, p_fci_internal->handleCFFILE2, /* file handle */
1029         &cffile, /* memory buffer */
1030         sizeof(cffile), /* number of bytes to copy */
1031         err, p_fci_internal->pv) != sizeof(cffile) ) {
1032       fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
1033       return FALSE;
1034     }
1035     /* TODO error handling of err */
1036
1037     p_fci_internal->sizeFileCFFILE2 += sizeof(cffile);
1038
1039     /* reset little endian */
1040     cffile.cbFile=fci_endian_ulong(cffile.cbFile);
1041     cffile.uoffFolderStart=fci_endian_ulong(cffile.uoffFolderStart);
1042     cffile.iFolder=fci_endian_uword(cffile.iFolder);
1043     cffile.date=fci_endian_uword(cffile.date);
1044     cffile.time=fci_endian_uword(cffile.time);
1045     cffile.attribs=fci_endian_uword(cffile.attribs);
1046
1047     /* write file name to p_fci_internal->handleCFFILE2 */
1048     if( PFCI_WRITE(hfci, p_fci_internal->handleCFFILE2, /* file handle */
1049         p_fci_internal->data_out, /* memory buffer */
1050         strlen(p_fci_internal->data_out)+1, /* number of bytes to copy */
1051         err, p_fci_internal->pv) != strlen(p_fci_internal->data_out)+1 ) {
1052       fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
1053       return FALSE;
1054     }
1055     /* TODO error handling of err */
1056
1057     p_fci_internal->sizeFileCFFILE2 += strlen(p_fci_internal->data_out)+1;
1058
1059     /* cFiles is used to count all files of a cabinet */
1060     ++(p_fci_internal->cFiles);
1061
1062     /* This is only true for files which will be written into the */
1063     /* next cabinet of the spanning folder */
1064     if( sizeOfFiles>payload ) {
1065
1066       /* Files which data will be partially written into the current cabinet */
1067       if( cffile.iFolder==cffileCONTINUED_PREV_AND_NEXT ||
1068           cffile.iFolder==cffileCONTINUED_TO_NEXT
1069         ) {
1070         if( sizeOfFilesPrev<=payload ) {
1071           /* The size of the uncompressed, data of a spanning file in a */
1072           /* spanning data */
1073           cbFileRemainer=sizeOfFiles-payload;
1074         }
1075         cffile.iFolder=cffileCONTINUED_FROM_PREV;
1076       } else {
1077         cffile.iFolder=0;
1078       }
1079
1080       /* write cffile into handleCFFILE1new */
1081       if( PFCI_WRITE(hfci, handleCFFILE1new, /* file handle */
1082           &cffile, /* memory buffer */
1083           sizeof(cffile), /* number of bytes to copy */
1084           err, p_fci_internal->pv) != sizeof(cffile) ) {
1085         fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
1086         return FALSE;
1087       }
1088       /* TODO error handling of err */
1089
1090       *psizeFileCFFILE1new += sizeof(cffile);
1091       /* write name of file into handleCFFILE1new */
1092       if( PFCI_WRITE(hfci, handleCFFILE1new, /* file handle */
1093           p_fci_internal->data_out, /* memory buffer */
1094           strlen(p_fci_internal->data_out)+1, /* number of bytes to copy */
1095           err, p_fci_internal->pv) != strlen(p_fci_internal->data_out)+1 ) {
1096         fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
1097         return FALSE;
1098       }
1099       /* TODO error handling of err */
1100
1101       *psizeFileCFFILE1new += strlen(p_fci_internal->data_out)+1;
1102     }
1103
1104   } /* END OF while */
1105   p_fci_internal->cbFileRemainer=cbFileRemainer;
1106   return TRUE;
1107 } /* end of fci_flushfolder_copy_cffile */
1108
1109
1110
1111
1112 static BOOL fci_flush_folder(
1113         HFCI                  hfci,
1114         BOOL                  fGetNextCab,
1115         PFNFCIGETNEXTCABINET  pfnfcignc,
1116         PFNFCISTATUS          pfnfcis)
1117 {
1118   int err;
1119   int handleCFDATA1new;                         /* handle for new  temp file */
1120   char szFileNameCFDATA1new[CB_MAX_FILENAME];  /* name buffer for temp file */
1121   int handleCFFILE1new;                         /* handle for new  temp file */
1122   char szFileNameCFFILE1new[CB_MAX_FILENAME];  /* name buffer for temp file */
1123   UINT cbReserveCFData, cbReserveCFFolder;
1124   char* reserved;
1125   cab_ULONG sizeFileCFDATA1new=0;
1126   cab_ULONG sizeFileCFFILE1new=0;
1127   cab_ULONG sizeFileCFDATA2old;
1128   cab_ULONG payload;
1129   cab_ULONG read_result;
1130   PFCI_Int p_fci_internal=((PFCI_Int)(hfci));
1131
1132   /* test hfci */
1133   if (!REALLY_IS_FCI(hfci)) {
1134     SetLastError(ERROR_INVALID_HANDLE);
1135     return FALSE;
1136   }
1137
1138   if ((!pfnfcignc) || (!pfnfcis)) {
1139     fci_set_error( FCIERR_NONE, ERROR_BAD_ARGUMENTS, TRUE );
1140     return FALSE;
1141   }
1142
1143   if( p_fci_internal->fGetNextCabInVain &&
1144       p_fci_internal->fNextCab ){
1145     /* internal error */
1146     fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
1147     return FALSE;
1148   }
1149
1150   /* If there was no FCIAddFile or FCIFlushFolder has already been called */
1151   /* this function will return TRUE */
1152   if( p_fci_internal->sizeFileCFFILE1 == 0 ) {
1153     if ( p_fci_internal->sizeFileCFDATA1 != 0 ) {
1154       /* error handling */
1155       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
1156       return FALSE;
1157     }
1158     return TRUE;
1159   }
1160
1161   if (p_fci_internal->data_in==NULL || p_fci_internal->data_out==NULL ) {
1162     /* error handling */
1163     fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
1164     return FALSE;
1165   }
1166
1167   /* FCIFlushFolder has already been called... */
1168   if (p_fci_internal->fSplitFolder && p_fci_internal->sizeFileCFFILE2!=0) {
1169     return TRUE;
1170   }
1171
1172   /* This can be set already, because it makes only a difference */
1173   /* when the current function exits with return FALSE */
1174   p_fci_internal->fSplitFolder=FALSE;
1175
1176
1177   if( p_fci_internal->fGetNextCabInVain ||
1178       p_fci_internal->fNextCab ){
1179     cbReserveCFData   = p_fci_internal->oldCCAB.cbReserveCFData;
1180     cbReserveCFFolder = p_fci_internal->oldCCAB.cbReserveCFFolder;
1181   } else {
1182     cbReserveCFData   = p_fci_internal->pccab->cbReserveCFData;
1183     cbReserveCFFolder = p_fci_internal->pccab->cbReserveCFFolder;
1184   }
1185
1186   /* START of COPY */
1187   /* if there is data in p_fci_internal->data_in */
1188   if (p_fci_internal->cdata_in!=0) {
1189
1190     if( !fci_flush_data_block(hfci, &err, pfnfcis) ) return FALSE;
1191
1192   }
1193   /* reset to get the number of data blocks of this folder which are */
1194   /* actually in this cabinet ( at least partially ) */
1195   p_fci_internal->cDataBlocks=0;
1196
1197   if ( p_fci_internal->fNextCab ||
1198        p_fci_internal->fGetNextCabInVain ) {
1199     read_result= p_fci_internal->oldCCAB.cbReserveCFHeader+
1200                  p_fci_internal->oldCCAB.cbReserveCFFolder;
1201     if ( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
1202         p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
1203         p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
1204       read_result+=4;
1205     }
1206   } else {
1207     read_result= p_fci_internal->pccab->cbReserveCFHeader+
1208                  p_fci_internal->pccab->cbReserveCFFolder;
1209     if ( p_fci_internal->pccab->cbReserveCFHeader != 0 ||
1210         p_fci_internal->pccab->cbReserveCFFolder != 0 ||
1211         p_fci_internal->pccab->cbReserveCFData   != 0 ) {
1212       read_result+=4;
1213     }
1214   }
1215   if (p_fci_internal->fPrevCab) {
1216     read_result+=strlen(p_fci_internal->szPrevCab)+1 +
1217       strlen(p_fci_internal->szPrevDisk)+1;
1218   }
1219   if (p_fci_internal->fNextCab) {
1220     read_result+=strlen(p_fci_internal->pccab->szCab)+1 +
1221       strlen(p_fci_internal->pccab->szDisk)+1;
1222   }
1223
1224   p_fci_internal->statusFolderTotal = sizeof(CFHEADER)+read_result+
1225       sizeof(CFFOLDER) + p_fci_internal->sizeFileCFFILE2+
1226       p_fci_internal->sizeFileCFDATA2 + p_fci_internal->sizeFileCFFILE1+
1227       p_fci_internal->sizeFileCFDATA1 + p_fci_internal->sizeFileCFFOLDER;
1228   p_fci_internal->statusFolderCopied = 0;
1229
1230   /* report status with pfnfcis about copied size of folder */
1231   if( (*pfnfcis)(statusFolder, p_fci_internal->statusFolderCopied,
1232       p_fci_internal->statusFolderTotal, /* TODO total folder size */
1233       p_fci_internal->pv) == -1) {
1234     fci_set_error( FCIERR_USER_ABORT, 0, TRUE );
1235     return FALSE;
1236   }
1237
1238   /* get a new temp file */
1239   if(!PFCI_GETTEMPFILE(hfci,szFileNameCFDATA1new,CB_MAX_FILENAME)) {
1240     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
1241     return FALSE;
1242   }
1243   /* safety */
1244   if ( strlen(szFileNameCFDATA1new) >= CB_MAX_FILENAME ) {
1245     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
1246     return FALSE;
1247   }
1248   handleCFDATA1new = PFCI_OPEN(hfci,szFileNameCFDATA1new,34050,384,&err,
1249     p_fci_internal->pv);
1250   if(handleCFDATA1new==0){
1251     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE );
1252     return FALSE;
1253   }
1254   /* TODO error handling of err */
1255
1256
1257
1258   /* get a new temp file */
1259   if(!PFCI_GETTEMPFILE(hfci,szFileNameCFFILE1new,CB_MAX_FILENAME)) {
1260     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
1261     PFCI_CLOSE(hfci,handleCFDATA1new,&err,p_fci_internal->pv);
1262     /* TODO error handling of err */
1263     return FALSE;
1264   }
1265   /* safety */
1266   if ( strlen(szFileNameCFFILE1new) >= CB_MAX_FILENAME ) {
1267     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
1268     PFCI_CLOSE(hfci,handleCFDATA1new,&err,p_fci_internal->pv);
1269     /* TODO error handling of err */
1270     return FALSE;
1271   }
1272   handleCFFILE1new = PFCI_OPEN(hfci,szFileNameCFFILE1new,34050,384,&err,
1273     p_fci_internal->pv);
1274   if(handleCFFILE1new==0){
1275     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE );
1276     return FALSE;
1277   }
1278   /* TODO error handling of err */
1279
1280   /* USE the variable read_result */
1281   if ( p_fci_internal->fNextCab ||
1282        p_fci_internal->fGetNextCabInVain ) {
1283     read_result= p_fci_internal->oldCCAB.cbReserveCFHeader;
1284     if ( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
1285         p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
1286         p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
1287       read_result+=4;
1288     }
1289   } else {
1290     read_result= p_fci_internal->pccab->cbReserveCFHeader;
1291     if ( p_fci_internal->pccab->cbReserveCFHeader != 0 ||
1292         p_fci_internal->pccab->cbReserveCFFolder != 0 ||
1293         p_fci_internal->pccab->cbReserveCFData   != 0 ) {
1294       read_result+=4;
1295     }
1296   }
1297   if (p_fci_internal->fPrevCab) {
1298     read_result+=strlen(p_fci_internal->szPrevCab)+1 +
1299       strlen(p_fci_internal->szPrevDisk)+1;
1300   }
1301   read_result+= sizeof(CFHEADER) + p_fci_internal->sizeFileCFDATA2 +
1302     p_fci_internal->sizeFileCFFILE2 + p_fci_internal->sizeFileCFFOLDER;
1303
1304   if(p_fci_internal->sizeFileCFFILE1!=0) {
1305     read_result+= sizeof(CFFOLDER)+p_fci_internal->pccab->cbReserveCFFolder;
1306   }
1307
1308   /* Check if multiple cabinets have to be created. */
1309
1310   /* Might be too much data for the maximum allowed cabinet size.*/
1311   /* When any further data will be added later, it might not */
1312   /* be possible to flush the cabinet, because there might */
1313   /* not be enough space to store the name of the following */
1314   /* cabinet and name of the corresponding disk. */
1315   /* So take care of this and get the name of the next cabinet */
1316   if( p_fci_internal->fGetNextCabInVain==FALSE &&
1317       p_fci_internal->fNextCab==FALSE &&
1318       (
1319         (
1320           p_fci_internal->pccab->cb < read_result +
1321           p_fci_internal->sizeFileCFDATA1 +
1322           p_fci_internal->sizeFileCFFILE1 +
1323           CB_MAX_CABINET_NAME +   /* next cabinet name */
1324           CB_MAX_DISK_NAME        /* next disk name */
1325         ) || fGetNextCab
1326       )
1327   ) {
1328     /* save CCAB */
1329     memcpy(&(p_fci_internal->oldCCAB), p_fci_internal->pccab, sizeof(CCAB));
1330     /* increment cabinet index */
1331     ++(p_fci_internal->pccab->iCab);
1332     /* get name of next cabinet */
1333     p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
1334     if (!(*pfnfcignc)(p_fci_internal->pccab,
1335         p_fci_internal->estimatedCabinetSize, /* estimated size of cab */
1336         p_fci_internal->pv)) {
1337       /* error handling */
1338       fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
1339       PFCI_CLOSE(hfci,handleCFDATA1new,&err,p_fci_internal->pv);
1340       /* TODO error handling of err */
1341       PFCI_CLOSE(hfci,handleCFFILE1new,&err,p_fci_internal->pv);
1342       /* TODO error handling of err */
1343       return FALSE;
1344     }
1345
1346     /* Skip a few lines of code. This is caught by the next if. */
1347     p_fci_internal->fGetNextCabInVain=TRUE;
1348   }
1349
1350   /* too much data for cabinet */
1351   if( (p_fci_internal->fGetNextCabInVain ||
1352         p_fci_internal->fNextCab ) &&
1353       (
1354         (
1355           p_fci_internal->oldCCAB.cb < read_result +
1356           p_fci_internal->sizeFileCFDATA1 +
1357           p_fci_internal->sizeFileCFFILE1 +
1358           strlen(p_fci_internal->pccab->szCab)+1 +   /* next cabinet name */
1359           strlen(p_fci_internal->pccab->szDisk)+1    /* next disk name */
1360         ) || fGetNextCab
1361       )
1362   ) {
1363     p_fci_internal->fGetNextCabInVain=FALSE;
1364     p_fci_internal->fNextCab=TRUE;
1365
1366     /* return FALSE if there is not enough space left*/
1367     /* this should never happen */
1368     if (p_fci_internal->oldCCAB.cb <=
1369         p_fci_internal->sizeFileCFFILE1 +
1370         read_result +
1371         strlen(p_fci_internal->pccab->szCab)+1 + /* next cabinet name */
1372         strlen(p_fci_internal->pccab->szDisk)+1  /* next disk name */
1373     ) {
1374
1375       PFCI_CLOSE(hfci,handleCFDATA1new,&err,p_fci_internal->pv);
1376       /* TODO error handling of err */
1377       PFCI_DELETE(hfci,szFileNameCFDATA1new,&err,p_fci_internal->pv);
1378       /* TODO error handling of err */
1379
1380       /* close and delete p_fci_internal->handleCFFILE1 */
1381       PFCI_CLOSE(hfci,handleCFFILE1new,&err,p_fci_internal->pv);
1382       /* TODO error handling of err */
1383       PFCI_DELETE(hfci,szFileNameCFFILE1new,&err,p_fci_internal->pv);
1384       /* TODO error handling of err */
1385
1386       return FALSE;
1387     }
1388
1389     /* the folder will be split across cabinets */
1390     p_fci_internal->fSplitFolder=TRUE;
1391
1392   } else {
1393     /* this should never happen */
1394     if (p_fci_internal->fNextCab) {
1395       /* internal error */
1396       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
1397       return FALSE;
1398     }
1399   }
1400
1401   /* set seek of p_fci_internal->handleCFDATA1 to 0 */
1402   if( PFCI_SEEK(hfci,p_fci_internal->handleCFDATA1,0,SEEK_SET,&err,
1403     p_fci_internal->pv) !=0 ) {
1404     /* wrong return value */
1405     fci_set_error( FCIERR_NONE, ERROR_SEEK, TRUE );
1406     PFCI_CLOSE(hfci,handleCFDATA1new,&err,p_fci_internal->pv);
1407     /* TODO error handling of err */
1408     PFCI_CLOSE(hfci,handleCFFILE1new,&err,p_fci_internal->pv);
1409     /* TODO error handling of err */
1410     return FALSE;
1411   }
1412   /* TODO error handling of err */
1413
1414   /* save size of file CFDATA2 - required for the folder's offset to data */
1415   sizeFileCFDATA2old = p_fci_internal->sizeFileCFDATA2;
1416
1417   if(!(reserved = (char*)PFCI_ALLOC(hfci, cbReserveCFData+sizeof(CFDATA)))) {
1418     fci_set_error( FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY, TRUE );
1419     PFCI_CLOSE(hfci,handleCFDATA1new,&err,p_fci_internal->pv);
1420     /* TODO error handling of err */
1421     PFCI_CLOSE(hfci,handleCFFILE1new,&err,p_fci_internal->pv);
1422     /* TODO error handling of err */
1423     return FALSE;
1424   }
1425
1426   if(!fci_flushfolder_copy_cfdata(hfci, reserved, cbReserveCFData, pfnfcis, &err,
1427       handleCFDATA1new, &sizeFileCFDATA1new, &payload
1428   )) {
1429     PFCI_CLOSE(hfci,handleCFDATA1new,&err,p_fci_internal->pv);
1430     /* TODO error handling of err */
1431     PFCI_DELETE(hfci,szFileNameCFDATA1new,&err,p_fci_internal->pv);
1432     /* TODO error handling of err */
1433     PFCI_CLOSE(hfci,handleCFFILE1new,&err,p_fci_internal->pv);
1434     /* TODO error handling of err */
1435     PFCI_FREE(hfci,reserved);
1436     return FALSE;
1437   }
1438
1439   PFCI_FREE(hfci,reserved);
1440
1441   if(!fci_flushfolder_copy_cffolder(hfci, &err, cbReserveCFFolder,
1442        sizeFileCFDATA2old )) {
1443     PFCI_CLOSE(hfci,handleCFDATA1new,&err,p_fci_internal->pv);
1444     /* TODO error handling of err */
1445     PFCI_DELETE(hfci,szFileNameCFDATA1new,&err,p_fci_internal->pv);
1446     /* TODO error handling of err */
1447     PFCI_CLOSE(hfci,handleCFFILE1new,&err,p_fci_internal->pv);
1448     /* TODO error handling of err */
1449     return FALSE;
1450   }
1451
1452   if(!fci_flushfolder_copy_cffile(hfci, &err, handleCFFILE1new,
1453       &sizeFileCFFILE1new, payload)) {
1454     PFCI_CLOSE(hfci,handleCFDATA1new,&err,p_fci_internal->pv);
1455     /* TODO error handling of err */
1456     PFCI_DELETE(hfci,szFileNameCFDATA1new,&err,p_fci_internal->pv);
1457     /* TODO error handling of err */
1458     PFCI_CLOSE(hfci,handleCFFILE1new,&err,p_fci_internal->pv);
1459     /* TODO error handling of err */
1460     PFCI_DELETE(hfci,szFileNameCFFILE1new,&err,p_fci_internal->pv);
1461     /* TODO error handling of err */
1462     return FALSE;
1463   }
1464
1465   /* close and delete p_fci_internal->handleCFDATA1 */
1466   PFCI_CLOSE(hfci,p_fci_internal->handleCFDATA1,&err,p_fci_internal->pv);
1467   /* TODO error handling of err */
1468   PFCI_DELETE(hfci,p_fci_internal->szFileNameCFDATA1,&err,p_fci_internal->pv);
1469   /* TODO error handling of err */
1470
1471   /* put new CFDATA1 into hfci */
1472   memcpy(p_fci_internal->szFileNameCFDATA1,szFileNameCFDATA1new,
1473     CB_MAX_FILENAME);
1474
1475   /* put CFDATA1 file handle */
1476   PFCI_INT(hfci)->handleCFDATA1 = handleCFDATA1new;
1477   /* set file size */
1478   PFCI_INT(hfci)->sizeFileCFDATA1 = sizeFileCFDATA1new;
1479
1480   /* close and delete PFCI_INT(hfci)->handleCFFILE1 */
1481   PFCI_CLOSE(hfci,p_fci_internal->handleCFFILE1,&err,PFCI_INT(hfci)->pv);
1482   /* TODO error handling of err */
1483   PFCI_DELETE(hfci,p_fci_internal->szFileNameCFFILE1,&err,p_fci_internal->pv);
1484   /* TODO error handling of err */
1485
1486   /* put new CFFILE1 into hfci */
1487   memcpy(p_fci_internal->szFileNameCFFILE1,szFileNameCFFILE1new,
1488     CB_MAX_FILENAME);
1489
1490   /* put CFFILE1 file handle */
1491   p_fci_internal->handleCFFILE1 = handleCFFILE1new;
1492   /* set file size */
1493   p_fci_internal->sizeFileCFFILE1 = sizeFileCFFILE1new;
1494
1495   ++(p_fci_internal->cFolders);
1496
1497   /* reset CFFolder specific information */
1498   p_fci_internal->cDataBlocks=0;
1499   p_fci_internal->cCompressedBytesInFolder=0;
1500
1501   return TRUE;
1502 }  /* end of fci_flush_folder */
1503
1504
1505
1506
1507 static BOOL fci_flush_cabinet(
1508         HFCI                  hfci,
1509         BOOL                  fGetNextCab,
1510         PFNFCIGETNEXTCABINET  pfnfcignc,
1511         PFNFCISTATUS          pfnfcis)
1512 {
1513   int err;
1514   CFHEADER cfheader;
1515   struct {
1516     cab_UWORD  cbCFHeader;
1517     cab_UBYTE  cbCFFolder;
1518     cab_UBYTE  cbCFData;
1519   } cfreserved;
1520   CFFOLDER cffolder;
1521   cab_ULONG read_result=0;
1522   int handleCABINET;                            /* file handle for cabinet   */
1523   char szFileNameCABINET[CB_MAX_CAB_PATH+CB_MAX_CABINET_NAME];/* name buffer */
1524   UINT cbReserveCFHeader, cbReserveCFFolder, i;
1525   char* reserved;
1526   BOOL returntrue=FALSE;
1527   PFCI_Int p_fci_internal=((PFCI_Int)(hfci));
1528
1529   /* TODO test if fci_flush_cabinet really aborts if there was no FCIAddFile */
1530
1531   /* when FCIFlushCabinet was or FCIAddFile hasn't been called */
1532   if( p_fci_internal->sizeFileCFFILE1==0 && fGetNextCab ) {
1533     returntrue=TRUE;
1534   }
1535
1536   if (!fci_flush_folder(hfci,fGetNextCab,pfnfcignc,pfnfcis)){
1537     /* TODO set error */
1538     return FALSE;
1539   }
1540
1541   if(returntrue) return TRUE;
1542
1543   if ( (p_fci_internal->fSplitFolder && p_fci_internal->fNextCab==FALSE)||
1544        (p_fci_internal->sizeFileCFFOLDER==0 &&
1545          (p_fci_internal->sizeFileCFFILE1!=0 ||
1546           p_fci_internal->sizeFileCFFILE2!=0 )
1547      ) )
1548   {
1549       /* error */
1550       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
1551       return FALSE;
1552   }
1553
1554   if( p_fci_internal->fNextCab ||
1555       p_fci_internal->fGetNextCabInVain ) {
1556     cbReserveCFFolder=p_fci_internal->oldCCAB.cbReserveCFFolder;
1557     cbReserveCFHeader=p_fci_internal->oldCCAB.cbReserveCFHeader;
1558     /* safety */
1559     if (strlen(p_fci_internal->oldCCAB.szCabPath)>=CB_MAX_CAB_PATH ||
1560         strlen(p_fci_internal->oldCCAB.szCab)>=CB_MAX_CABINET_NAME) {
1561       /* set error */
1562       fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
1563       return FALSE;
1564     }
1565     /* get the full name of the cabinet */
1566     memcpy(szFileNameCABINET,p_fci_internal->oldCCAB.szCabPath,
1567       CB_MAX_CAB_PATH);
1568     memcpy(szFileNameCABINET+strlen(szFileNameCABINET),
1569       p_fci_internal->oldCCAB.szCab, CB_MAX_CABINET_NAME);
1570   } else {
1571     cbReserveCFFolder=p_fci_internal->pccab->cbReserveCFFolder;
1572     cbReserveCFHeader=p_fci_internal->pccab->cbReserveCFHeader;
1573     /* safety */
1574     if (strlen(p_fci_internal->pccab->szCabPath)>=CB_MAX_CAB_PATH ||
1575         strlen(p_fci_internal->pccab->szCab)>=CB_MAX_CABINET_NAME) {
1576       /* set error */
1577       fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
1578       return FALSE;
1579     }
1580     /* get the full name of the cabinet */
1581     memcpy(szFileNameCABINET,p_fci_internal->pccab->szCabPath,
1582       CB_MAX_CAB_PATH);
1583     memcpy(szFileNameCABINET+strlen(szFileNameCABINET),
1584       p_fci_internal->pccab->szCab, CB_MAX_CABINET_NAME);
1585   }
1586
1587   memcpy(cfheader.signature,"!CAB",4);
1588   cfheader.reserved1=0;
1589   cfheader.cbCabinet=   /* size of the cabinet file in bytes */
1590     sizeof(CFHEADER) +
1591     p_fci_internal->sizeFileCFFOLDER +
1592     p_fci_internal->sizeFileCFFILE2 +
1593     p_fci_internal->sizeFileCFDATA2;
1594
1595   if (p_fci_internal->fPrevCab) {
1596     cfheader.cbCabinet+=strlen(p_fci_internal->szPrevCab)+1 +
1597       strlen(p_fci_internal->szPrevDisk)+1;
1598   }
1599   if (p_fci_internal->fNextCab) {
1600     cfheader.cbCabinet+=strlen(p_fci_internal->pccab->szCab)+1 +
1601       strlen(p_fci_internal->pccab->szDisk)+1;
1602   }
1603   if( p_fci_internal->fNextCab ||
1604       p_fci_internal->fGetNextCabInVain ) {
1605     cfheader.cbCabinet+=p_fci_internal->oldCCAB.cbReserveCFHeader;
1606     if ( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
1607         p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
1608         p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
1609       cfheader.cbCabinet+=4;
1610     }
1611   } else {
1612     cfheader.cbCabinet+=p_fci_internal->pccab->cbReserveCFHeader;
1613     if ( p_fci_internal->pccab->cbReserveCFHeader != 0 ||
1614         p_fci_internal->pccab->cbReserveCFFolder != 0 ||
1615         p_fci_internal->pccab->cbReserveCFData   != 0 ) {
1616       cfheader.cbCabinet+=4;
1617     }
1618   }
1619
1620   if( ( ( p_fci_internal->fNextCab ||
1621           p_fci_internal->fGetNextCabInVain ) &&
1622         cfheader.cbCabinet > p_fci_internal->oldCCAB.cb
1623       ) ||
1624       ( ( p_fci_internal->fNextCab==FALSE &&
1625           p_fci_internal->fGetNextCabInVain==FALSE ) &&
1626         cfheader.cbCabinet > p_fci_internal->pccab->cb
1627       )
1628     )
1629   {
1630     fci_set_error( FCIERR_NONE, ERROR_MORE_DATA, TRUE );
1631     return FALSE;
1632   }
1633
1634
1635   cfheader.reserved2=0;
1636   cfheader.coffFiles=    /* offset to first CFFILE section */
1637    cfheader.cbCabinet - p_fci_internal->sizeFileCFFILE2 -
1638    p_fci_internal->sizeFileCFDATA2;
1639
1640   cfheader.reserved3=0;
1641   cfheader.versionMinor=3;
1642   cfheader.versionMajor=1;
1643   /* number of CFFOLDER entries in the cabinet */
1644   cfheader.cFolders=p_fci_internal->cFolders;
1645   /* number of CFFILE entries in the cabinet */
1646   cfheader.cFiles=p_fci_internal->cFiles;
1647   cfheader.flags=0;    /* 1=prev cab, 2=next cabinet, 4=reserved setions */
1648
1649   if( p_fci_internal->fPrevCab ) {
1650     cfheader.flags = cfheadPREV_CABINET;
1651   }
1652
1653   if( p_fci_internal->fNextCab ) {
1654     cfheader.flags |= cfheadNEXT_CABINET;
1655   }
1656
1657   if( p_fci_internal->fNextCab ||
1658       p_fci_internal->fGetNextCabInVain ) {
1659     if( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
1660         p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
1661         p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
1662       cfheader.flags |= cfheadRESERVE_PRESENT;
1663     }
1664     cfheader.setID = p_fci_internal->oldCCAB.setID;
1665     cfheader.iCabinet = p_fci_internal->oldCCAB.iCab-1;
1666   } else {
1667     if( p_fci_internal->pccab->cbReserveCFHeader != 0 ||
1668         p_fci_internal->pccab->cbReserveCFFolder != 0 ||
1669         p_fci_internal->pccab->cbReserveCFData   != 0 ) {
1670       cfheader.flags |= cfheadRESERVE_PRESENT;
1671     }
1672     cfheader.setID = p_fci_internal->pccab->setID;
1673     cfheader.iCabinet = p_fci_internal->pccab->iCab-1;
1674   }
1675
1676   /* create the cabinet */
1677   handleCABINET = PFCI_OPEN(hfci, szFileNameCABINET,
1678     33538, 384, &err, p_fci_internal->pv );
1679   if(handleCABINET==0){
1680     fci_set_error( FCIERR_CAB_FILE, ERROR_OPEN_FAILED, TRUE );
1681     return FALSE;
1682   }
1683   /* TODO error checking of err */
1684
1685   /* set little endian */
1686   cfheader.reserved1=fci_endian_ulong(cfheader.reserved1);
1687   cfheader.cbCabinet=fci_endian_ulong(cfheader.cbCabinet);
1688   cfheader.reserved2=fci_endian_ulong(cfheader.reserved2);
1689   cfheader.coffFiles=fci_endian_ulong(cfheader.coffFiles);
1690   cfheader.reserved3=fci_endian_ulong(cfheader.reserved3);
1691   cfheader.cFolders=fci_endian_uword(cfheader.cFolders);
1692   cfheader.cFiles=fci_endian_uword(cfheader.cFiles);
1693   cfheader.flags=fci_endian_uword(cfheader.flags);
1694   cfheader.setID=fci_endian_uword(cfheader.setID);
1695   cfheader.iCabinet=fci_endian_uword(cfheader.iCabinet);
1696
1697   /* write CFHEADER into cabinet file */
1698   if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1699       &cfheader, /* memory buffer */
1700       sizeof(cfheader), /* number of bytes to copy */
1701       &err, p_fci_internal->pv) != sizeof(cfheader) ) {
1702     /* write error */
1703     fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1704     return FALSE;
1705   }
1706   /* TODO error handling of err */
1707
1708   /* reset little endian */
1709   cfheader.reserved1=fci_endian_ulong(cfheader.reserved1);
1710   cfheader.cbCabinet=fci_endian_ulong(cfheader.cbCabinet);
1711   cfheader.reserved2=fci_endian_ulong(cfheader.reserved2);
1712   cfheader.coffFiles=fci_endian_ulong(cfheader.coffFiles);
1713   cfheader.reserved3=fci_endian_ulong(cfheader.reserved3);
1714   cfheader.cFolders=fci_endian_uword(cfheader.cFolders);
1715   cfheader.cFiles=fci_endian_uword(cfheader.cFiles);
1716   cfheader.flags=fci_endian_uword(cfheader.flags);
1717   cfheader.setID=fci_endian_uword(cfheader.setID);
1718   cfheader.iCabinet=fci_endian_uword(cfheader.iCabinet);
1719
1720   if( cfheader.flags & cfheadRESERVE_PRESENT ) {
1721     /* NOTE: No checks for maximum value overflows as designed by MS!!! */
1722     cfreserved.cbCFHeader = cbReserveCFHeader;
1723     cfreserved.cbCFFolder = cbReserveCFFolder;
1724     if( p_fci_internal->fNextCab ||
1725         p_fci_internal->fGetNextCabInVain ) {
1726       cfreserved.cbCFData = p_fci_internal->oldCCAB.cbReserveCFData;
1727     } else {
1728       cfreserved.cbCFData = p_fci_internal->pccab->cbReserveCFData;
1729     }
1730
1731     /* set little endian */
1732     cfreserved.cbCFHeader=fci_endian_uword(cfreserved.cbCFHeader);
1733
1734     /* write reserved info into cabinet file */
1735     if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1736         &cfreserved, /* memory buffer */
1737         sizeof(cfreserved), /* number of bytes to copy */
1738         &err, p_fci_internal->pv) != sizeof(cfreserved) ) {
1739       /* write error */
1740       fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1741       return FALSE;
1742     }
1743     /* TODO error handling of err */
1744
1745     /* reset little endian */
1746     cfreserved.cbCFHeader=fci_endian_uword(cfreserved.cbCFHeader);
1747   }
1748
1749   /* add optional reserved area */
1750   if (cbReserveCFHeader!=0) {
1751     if(!(reserved = (char*)PFCI_ALLOC(hfci, cbReserveCFHeader))) {
1752       fci_set_error( FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY, TRUE );
1753       return FALSE;
1754     }
1755     for(i=0;i<cbReserveCFHeader;) {
1756       reserved[i++]='\0';
1757     }
1758     if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1759         reserved, /* memory buffer */
1760         cbReserveCFHeader, /* number of bytes to copy */
1761         &err, p_fci_internal->pv) != cbReserveCFHeader ) {
1762       PFCI_FREE(hfci, reserved);
1763       /* write error */
1764       fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1765       return FALSE;
1766     }
1767     /* TODO error handling of err */
1768     PFCI_FREE(hfci, reserved);
1769   }
1770
1771   if( cfheader.flags & cfheadPREV_CABINET ) {
1772     if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1773         p_fci_internal->szPrevCab, /* memory buffer */
1774         strlen(p_fci_internal->szPrevCab)+1, /* number of bytes to copy */
1775         &err, p_fci_internal->pv) != strlen(p_fci_internal->szPrevCab)+1 ) {
1776       /* write error */
1777       fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1778       return FALSE;
1779     }
1780     /* TODO error handling of err */
1781
1782     if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1783         p_fci_internal->szPrevDisk, /* memory buffer */
1784         strlen(p_fci_internal->szPrevDisk)+1, /* number of bytes to copy */
1785         &err, p_fci_internal->pv) != strlen(p_fci_internal->szPrevDisk)+1 ) {
1786       /* write error */
1787       fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1788       return FALSE;
1789     }
1790     /* TODO error handling of err */
1791   }
1792
1793   if( cfheader.flags & cfheadNEXT_CABINET ) {
1794     if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1795         p_fci_internal->pccab->szCab, /* memory buffer */
1796         strlen(p_fci_internal->pccab->szCab)+1, /* number of bytes to copy */
1797         &err, p_fci_internal->pv) != strlen(p_fci_internal->pccab->szCab)+1 ) {
1798       /* write error */
1799       fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1800       return FALSE;
1801     }
1802     /* TODO error handling of err */
1803
1804     if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1805         p_fci_internal->pccab->szDisk, /* memory buffer */
1806         strlen(p_fci_internal->pccab->szDisk)+1, /* number of bytes to copy */
1807         &err, p_fci_internal->pv) != strlen(p_fci_internal->pccab->szDisk)+1 ) {
1808       /* write error */
1809       fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1810       return FALSE;
1811     }
1812     /* TODO error handling of err */
1813   }
1814
1815   /* set seek of p_fci_internal->handleCFFOLDER to 0 */
1816   if( PFCI_SEEK(hfci,p_fci_internal->handleCFFOLDER,
1817       0, SEEK_SET, &err, p_fci_internal->pv) != 0 ) {
1818     /* wrong return value */
1819     fci_set_error( FCIERR_NONE, ERROR_SEEK, TRUE );
1820     return FALSE;
1821   }
1822   /* TODO error handling of err */
1823
1824   /* while not all CFFOLDER structures have been copied into the cabinet do */
1825   while(!FALSE) {
1826     /* use the variable read_result */
1827     /* read cffolder of p_fci_internal->handleCFFOLDER */
1828     read_result = PFCI_READ(hfci, p_fci_internal->handleCFFOLDER, /* handle */
1829         &cffolder, /* memory buffer */
1830         sizeof(cffolder), /* number of bytes to copy */
1831         &err, p_fci_internal->pv);
1832     if( read_result != sizeof(cffolder) ) {
1833       if( read_result == 0 ) break;/*ALL CFFOLDER structures have been copied*/
1834       /* read error */
1835       fci_set_error( FCIERR_NONE, ERROR_READ_FAULT, TRUE );
1836       return FALSE;
1837     }
1838     /* TODO error handling of err */
1839
1840     /* add size of header size of all CFFOLDERs and size of all CFFILEs */
1841     cffolder.coffCabStart +=
1842       p_fci_internal->sizeFileCFFILE2 + p_fci_internal->sizeFileCFFOLDER +
1843       sizeof(CFHEADER);
1844     if( p_fci_internal->fNextCab ||
1845         p_fci_internal->fGetNextCabInVain ) {
1846       cffolder.coffCabStart+=p_fci_internal->oldCCAB.cbReserveCFHeader;
1847     } else {
1848       cffolder.coffCabStart+=p_fci_internal->pccab->cbReserveCFHeader;
1849     }
1850
1851     if (p_fci_internal->fPrevCab) {
1852       cffolder.coffCabStart += strlen(p_fci_internal->szPrevCab)+1 +
1853         strlen(p_fci_internal->szPrevDisk)+1;
1854     }
1855
1856     if (p_fci_internal->fNextCab) {
1857       cffolder.coffCabStart += strlen(p_fci_internal->oldCCAB.szCab)+1 +
1858         strlen(p_fci_internal->oldCCAB.szDisk)+1;
1859     }
1860
1861     if( p_fci_internal->fNextCab ||
1862         p_fci_internal->fGetNextCabInVain ) {
1863       cffolder.coffCabStart += p_fci_internal->oldCCAB.cbReserveCFHeader;
1864       if( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
1865           p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
1866           p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
1867         cffolder.coffCabStart += 4;
1868       }
1869     } else {
1870       cffolder.coffCabStart += p_fci_internal->pccab->cbReserveCFHeader;
1871       if( p_fci_internal->pccab->cbReserveCFHeader != 0 ||
1872           p_fci_internal->pccab->cbReserveCFFolder != 0 ||
1873           p_fci_internal->pccab->cbReserveCFData   != 0 ) {
1874         cffolder.coffCabStart += 4;
1875       }
1876     }
1877
1878     /* set little endian */
1879     cffolder.coffCabStart=fci_endian_ulong(cffolder.coffCabStart);
1880     cffolder.cCFData=fci_endian_uword(cffolder.cCFData);
1881     cffolder.typeCompress=fci_endian_uword(cffolder.typeCompress);
1882
1883     /* write cffolder to cabinet file */
1884     if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1885         &cffolder, /* memory buffer */
1886         sizeof(cffolder), /* number of bytes to copy */
1887         &err, p_fci_internal->pv) != sizeof(cffolder) ) {
1888       /* write error */
1889       fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1890       return FALSE;
1891     }
1892     /* TODO error handling of err */
1893
1894     /* reset little endian */
1895     cffolder.coffCabStart=fci_endian_ulong(cffolder.coffCabStart);
1896     cffolder.cCFData=fci_endian_uword(cffolder.cCFData);
1897     cffolder.typeCompress=fci_endian_uword(cffolder.typeCompress);
1898
1899     /* add optional reserved area */
1900
1901     /* This allocation and freeing at each CFFolder block is a bit */
1902     /* inefficent, but it's harder to forget about freeing the buffer :-). */
1903     /* Reserved areas are used seldom besides that... */
1904     if (cbReserveCFFolder!=0) {
1905       if(!(reserved = PFCI_ALLOC(hfci, cbReserveCFFolder))) {
1906         fci_set_error( FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY, TRUE );
1907         return FALSE;
1908       }
1909
1910       if( PFCI_READ(hfci, p_fci_internal->handleCFFOLDER, /* file handle */
1911           reserved, /* memory buffer */
1912           cbReserveCFFolder, /* number of bytes to copy */
1913           &err, p_fci_internal->pv) != cbReserveCFFolder ) {
1914         PFCI_FREE(hfci, reserved);
1915         /* read error */
1916         fci_set_error( FCIERR_NONE, ERROR_READ_FAULT, TRUE );
1917         return FALSE;
1918       }
1919       /* TODO error handling of err */
1920
1921       if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1922           reserved, /* memory buffer */
1923           cbReserveCFFolder, /* number of bytes to copy */
1924           &err, p_fci_internal->pv) != cbReserveCFFolder ) {
1925         PFCI_FREE(hfci, reserved);
1926         /* write error */
1927         fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1928         return FALSE;
1929       }
1930       /* TODO error handling of err */
1931
1932       PFCI_FREE(hfci, reserved);
1933     }
1934
1935   } /* END OF while */
1936
1937   /* set seek of p_fci_internal->handleCFFILE2 to 0 */
1938   if( PFCI_SEEK(hfci,p_fci_internal->handleCFFILE2,
1939       0, SEEK_SET, &err, p_fci_internal->pv) != 0 ) {
1940     /* wrong return value */
1941     fci_set_error( FCIERR_NONE, ERROR_SEEK, TRUE );
1942     return FALSE;
1943   }
1944   /* TODO error handling of err */
1945
1946   /* while not all CFFILE structures have been copied to the cabinet do */
1947   while(!FALSE) {
1948     /* REUSE the variable read_result */
1949     /* REUSE the buffer p_fci_internal->data_out AGAIN */
1950     /* read a block from p_fci_internal->handleCFFILE2 */
1951     read_result = PFCI_READ(hfci, p_fci_internal->handleCFFILE2 /* handle */,
1952         p_fci_internal->data_out, /* memory buffer */
1953         CB_MAX_CHUNK, /* number of bytes to copy */
1954         &err, p_fci_internal->pv);
1955     if( read_result == 0 ) break; /* ALL CFFILE structures have been copied */
1956     /* TODO error handling of err */
1957
1958     /* write the block to the cabinet file */
1959     if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
1960         p_fci_internal->data_out, /* memory buffer */
1961         read_result, /* number of bytes to copy */
1962         &err, p_fci_internal->pv) != read_result ) {
1963       /* write error */
1964       fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
1965       return FALSE;
1966     }
1967     /* TODO error handling of err */
1968
1969     if (p_fci_internal->fSplitFolder==FALSE) {
1970       p_fci_internal->statusFolderCopied = 0;
1971       /* TODO TEST THIS further */
1972       p_fci_internal->statusFolderTotal = p_fci_internal->sizeFileCFDATA2+
1973         p_fci_internal->sizeFileCFFILE2;
1974     }
1975     p_fci_internal->statusFolderCopied += read_result;
1976
1977     /* report status with pfnfcis about copied size of folder */
1978     if( (*pfnfcis)(statusFolder,
1979         p_fci_internal->statusFolderCopied, /* length of copied blocks */
1980         p_fci_internal->statusFolderTotal, /* total size of folder */
1981         p_fci_internal->pv) == -1) {
1982       fci_set_error( FCIERR_USER_ABORT, 0, TRUE );
1983       return FALSE;
1984     }
1985
1986   } /* END OF while */
1987
1988   /* set seek of p_fci_internal->handleCFDATA2 to 0 */
1989   if( PFCI_SEEK(hfci,p_fci_internal->handleCFDATA2,
1990       0, SEEK_SET, &err, p_fci_internal->pv) != 0 ) {
1991     /* wrong return value */
1992     fci_set_error( FCIERR_NONE, ERROR_SEEK, TRUE );
1993     return FALSE;
1994   }
1995   /* TODO error handling of err */
1996
1997   /* reset the number of folders for the next cabinet */
1998   p_fci_internal->cFolders=0;
1999   /* reset the number of files for the next cabinet */
2000   p_fci_internal->cFiles=0;
2001
2002   /* while not all CFDATA structures have been copied to the cabinet do */
2003   while(!FALSE) {
2004     /* REUSE the variable read_result AGAIN */
2005     /* REUSE the buffer p_fci_internal->data_out AGAIN */
2006     /* read a block from p_fci_internal->handleCFDATA2 */
2007     read_result = PFCI_READ(hfci, p_fci_internal->handleCFDATA2 /* handle */,
2008         p_fci_internal->data_out, /* memory buffer */
2009         CB_MAX_CHUNK, /* number of bytes to copy */
2010         &err, p_fci_internal->pv);
2011     if( read_result == 0 ) break; /* ALL CFDATA structures have been copied */
2012     /* TODO error handling of err */
2013
2014     /* write the block to the cabinet file */
2015     if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
2016         p_fci_internal->data_out, /* memory buffer */
2017         read_result, /* number of bytes to copy */
2018         &err, p_fci_internal->pv) != read_result ) {
2019       /* write error */
2020       fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
2021       return FALSE;
2022     }
2023     /* TODO error handling of err */
2024
2025     p_fci_internal->statusFolderCopied += read_result;
2026     /* report status with pfnfcis about copied size of folder */
2027     if( (*pfnfcis)(statusFolder,
2028         p_fci_internal->statusFolderCopied, /* length of copied blocks */
2029         p_fci_internal->statusFolderTotal, /* total size of folder */
2030         p_fci_internal->pv) == -1) {
2031       /* set error code and abort */
2032       fci_set_error( FCIERR_USER_ABORT, 0, TRUE );
2033       return FALSE;
2034     }
2035   } /* END OF while */
2036
2037   /* set seek of the cabinet file to 0 */
2038   if( PFCI_SEEK(hfci, handleCABINET,
2039       0, SEEK_SET, &err, p_fci_internal->pv) != 0 ) {
2040     /* wrong return value */
2041     fci_set_error( FCIERR_NONE, ERROR_SEEK, TRUE );
2042     return FALSE;
2043   }
2044   /* TODO error handling of err */
2045
2046   /* write the signature "MSCF" into the cabinet file */
2047   memcpy( cfheader.signature, "MSCF", 4 );
2048   if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
2049       &cfheader, /* memory buffer */
2050       4, /* number of bytes to copy */
2051       &err, p_fci_internal->pv) != 4 ) {
2052     /* wrtie error */
2053     fci_set_error( FCIERR_CAB_FILE, ERROR_WRITE_FAULT, TRUE );
2054     return FALSE;
2055   }
2056   /* TODO error handling of err */
2057
2058   /* close the cabinet file */
2059   PFCI_CLOSE(hfci,handleCABINET,&err,p_fci_internal->pv);
2060   /* TODO error handling of err */
2061
2062
2063 /* COPIED FROM FCIDestroy */
2064
2065   PFCI_CLOSE (hfci, p_fci_internal->handleCFDATA2,&err,p_fci_internal->pv);
2066   /* TODO error handling of err */
2067   PFCI_DELETE(hfci, p_fci_internal->szFileNameCFDATA2, &err,
2068     p_fci_internal->pv);
2069   /* TODO error handling of err */
2070   PFCI_CLOSE (hfci, p_fci_internal->handleCFFILE2,&err,p_fci_internal->pv);
2071   /* TODO error handling of err */
2072   PFCI_DELETE(hfci, p_fci_internal->szFileNameCFFILE2, &err,
2073     p_fci_internal->pv);
2074   /* TODO error handling of err */
2075   PFCI_CLOSE (hfci, p_fci_internal->handleCFFOLDER,&err,p_fci_internal->pv);
2076   /* TODO error handling of err */
2077   PFCI_DELETE(hfci, p_fci_internal->szFileNameCFFOLDER, &err,
2078     p_fci_internal->pv);
2079   /* TODO error handling of err */
2080
2081 /* END OF copied from FCIDestroy */
2082
2083   /* get 3 temporary files and open them */
2084   /* write names and handles to hfci */
2085
2086
2087   p_fci_internal->sizeFileCFDATA2  = 0;
2088   p_fci_internal->sizeFileCFFILE2  = 0;
2089   p_fci_internal->sizeFileCFFOLDER = 0;
2090
2091 /* COPIED FROM FCICreate */
2092
2093   /* CFDATA with checksum and ready to be copied into cabinet */
2094   if( !PFCI_GETTEMPFILE(hfci, p_fci_internal->szFileNameCFDATA2,
2095       CB_MAX_FILENAME)) {
2096     /* error handling */
2097     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
2098     return FALSE;
2099   }
2100   /* safety */
2101   if ( strlen(p_fci_internal->szFileNameCFDATA2) >= CB_MAX_FILENAME ) {
2102     /* set error code and abort */
2103     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
2104     return FALSE;
2105   }
2106   p_fci_internal->handleCFDATA2 = PFCI_OPEN(hfci,
2107     p_fci_internal->szFileNameCFDATA2, 34050, 384, &err, p_fci_internal->pv);
2108   /* check handle */
2109   if(p_fci_internal->handleCFDATA2==0){
2110     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE );
2111     return FALSE;
2112   }
2113   /* TODO error checking of err */
2114
2115   /* array of all CFFILE in a folder, ready to be copied into cabinet */
2116   if( !PFCI_GETTEMPFILE(hfci,p_fci_internal->szFileNameCFFILE2,
2117       CB_MAX_FILENAME)) {
2118     /* error handling */
2119     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
2120     return FALSE;
2121   }
2122   /* safety */
2123   if ( strlen(p_fci_internal->szFileNameCFFILE2) >= CB_MAX_FILENAME ) {
2124     /* set error code and abort */
2125     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
2126     return FALSE;
2127   }
2128   p_fci_internal->handleCFFILE2 = PFCI_OPEN(hfci,
2129     p_fci_internal->szFileNameCFFILE2, 34050, 384, &err, p_fci_internal->pv);
2130   /* check handle */
2131   if(p_fci_internal->handleCFFILE2==0){
2132     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE);
2133     return FALSE;
2134   }
2135   /* TODO error checking of err */
2136
2137   /* array of all CFFILE in a folder, ready to be copied into cabinet */
2138   if (!PFCI_GETTEMPFILE(hfci,p_fci_internal->szFileNameCFFOLDER,CB_MAX_FILENAME)) {
2139     /* error handling */
2140     fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
2141     return FALSE;
2142   }
2143   /* safety */
2144   if ( strlen(p_fci_internal->szFileNameCFFOLDER) >= CB_MAX_FILENAME ) {
2145     /* set error code and abort */
2146     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
2147     return FALSE;
2148   }
2149   p_fci_internal->handleCFFOLDER = PFCI_OPEN(hfci,
2150     p_fci_internal->szFileNameCFFOLDER, 34050, 384, &err, p_fci_internal->pv);
2151   /* check handle */
2152   if(p_fci_internal->handleCFFOLDER==0){
2153     fci_set_error( FCIERR_TEMP_FILE, ERROR_OPEN_FAILED, TRUE );
2154     return FALSE;
2155   }
2156   /* TODO error checking of err */
2157
2158 /* END OF copied from FCICreate */
2159
2160
2161   /* TODO close and delete new files when return FALSE */
2162
2163
2164   /* report status with pfnfcis about copied size of folder */
2165   (*pfnfcis)(statusCabinet,
2166     p_fci_internal->estimatedCabinetSize, /* estimated cabinet file size */
2167     cfheader.cbCabinet /* real cabinet file size */, p_fci_internal->pv);
2168
2169   p_fci_internal->fPrevCab=TRUE;
2170   /* The sections szPrevCab and szPrevDisk are not being updated, because */
2171   /* MS CABINET.DLL always puts the first cabinet name and disk into them */
2172
2173   if (p_fci_internal->fNextCab) {
2174     p_fci_internal->fNextCab=FALSE;
2175
2176     if (p_fci_internal->sizeFileCFFILE1==0 && p_fci_internal->sizeFileCFDATA1!=0) {
2177       /* THIS CAN NEVER HAPPEN */
2178       /* set error code */
2179       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2180       return FALSE;
2181     }
2182
2183 /* COPIED FROM FCIAddFile and modified */
2184
2185     /* REUSE the variable read_result */
2186     if (p_fci_internal->fGetNextCabInVain) {
2187       read_result=p_fci_internal->oldCCAB.cbReserveCFHeader;
2188       if(p_fci_internal->sizeFileCFFILE1!=0) {
2189         read_result+=p_fci_internal->oldCCAB.cbReserveCFFolder;
2190       }
2191       if ( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
2192           p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
2193           p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
2194         read_result+=4;
2195       }
2196     } else {
2197       read_result=p_fci_internal->pccab->cbReserveCFHeader;
2198       if(p_fci_internal->sizeFileCFFILE1!=0) {
2199         read_result+=p_fci_internal->pccab->cbReserveCFFolder;
2200       }
2201       if ( p_fci_internal->pccab->cbReserveCFHeader != 0 ||
2202           p_fci_internal->pccab->cbReserveCFFolder != 0 ||
2203           p_fci_internal->pccab->cbReserveCFData   != 0 ) {
2204         read_result+=4;
2205       }
2206     }
2207     if ( p_fci_internal->fPrevCab ) {
2208       read_result+= strlen(p_fci_internal->szPrevCab)+1+
2209         strlen(p_fci_internal->szPrevDisk)+1;
2210     }
2211     read_result+= p_fci_internal->sizeFileCFDATA1 +
2212       p_fci_internal->sizeFileCFFILE1 + p_fci_internal->sizeFileCFDATA2 +
2213       p_fci_internal->sizeFileCFFILE2 + p_fci_internal->sizeFileCFFOLDER +
2214       sizeof(CFHEADER) +
2215       sizeof(CFFOLDER); /* set size of new CFFolder entry */
2216
2217     if( p_fci_internal->fNewPrevious ) {
2218       memcpy(p_fci_internal->szPrevCab, p_fci_internal->oldCCAB.szCab,
2219         CB_MAX_CABINET_NAME);
2220       memcpy(p_fci_internal->szPrevDisk, p_fci_internal->oldCCAB.szDisk,
2221         CB_MAX_DISK_NAME);
2222       p_fci_internal->fNewPrevious=FALSE;
2223     }
2224
2225     /* too much data for the maximum size of a cabinet */
2226     if( p_fci_internal->fGetNextCabInVain==FALSE &&
2227         p_fci_internal->pccab->cb < read_result ) {
2228       return fci_flush_cabinet( hfci, FALSE, pfnfcignc, pfnfcis);
2229     }
2230
2231     /* Might be too much data for the maximum size of a cabinet.*/
2232     /* When any further data will be added later, it might not */
2233     /* be possible to flush the cabinet, because there might */
2234     /* not be enough space to store the name of the following */
2235     /* cabinet and name of the corresponding disk. */
2236     /* So take care of this and get the name of the next cabinet */
2237     if (p_fci_internal->fGetNextCabInVain==FALSE && (
2238       p_fci_internal->pccab->cb < read_result +
2239       CB_MAX_CABINET_NAME + CB_MAX_DISK_NAME
2240     )) {
2241       /* save CCAB */
2242       memcpy(&(p_fci_internal->oldCCAB), p_fci_internal->pccab, sizeof(CCAB));
2243       /* increment cabinet index */
2244       ++(p_fci_internal->pccab->iCab);
2245       /* get name of next cabinet */
2246       p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
2247       if (!(*pfnfcignc)(p_fci_internal->pccab,
2248           p_fci_internal->estimatedCabinetSize, /* estimated size of cab */
2249           p_fci_internal->pv)) {
2250         /* error handling */
2251         fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
2252         return FALSE;
2253       }
2254       /* Skip a few lines of code. This is caught by the next if. */
2255       p_fci_internal->fGetNextCabInVain=TRUE;
2256     }
2257
2258     /* too much data for cabinet */
2259     if (p_fci_internal->fGetNextCabInVain && (
2260         p_fci_internal->oldCCAB.cb < read_result +
2261         strlen(p_fci_internal->oldCCAB.szCab)+1+
2262         strlen(p_fci_internal->oldCCAB.szDisk)+1
2263     )) {
2264       p_fci_internal->fGetNextCabInVain=FALSE;
2265       p_fci_internal->fNextCab=TRUE;
2266       return fci_flush_cabinet( hfci, FALSE, pfnfcignc, pfnfcis);
2267     }
2268
2269     /* if the FolderThreshold has been reached flush the folder automatically */
2270     if( p_fci_internal->fGetNextCabInVain ) {
2271       if( p_fci_internal->cCompressedBytesInFolder >=
2272           p_fci_internal->oldCCAB.cbFolderThresh) {
2273         return FCIFlushFolder(hfci, pfnfcignc, pfnfcis);
2274       }
2275     } else {
2276       if( p_fci_internal->cCompressedBytesInFolder >=
2277           p_fci_internal->pccab->cbFolderThresh) {
2278         return FCIFlushFolder(hfci, pfnfcignc, pfnfcis);
2279       }
2280     }
2281
2282 /* END OF COPIED FROM FCIAddFile and modified */
2283
2284     if( p_fci_internal->sizeFileCFFILE1>0 ) {
2285       if( !FCIFlushFolder(hfci, pfnfcignc, pfnfcis) ) return FALSE;
2286       p_fci_internal->fNewPrevious=TRUE;
2287     }
2288   } else {
2289     p_fci_internal->fNewPrevious=FALSE;
2290     if( p_fci_internal->sizeFileCFFILE1>0 || p_fci_internal->sizeFileCFDATA1) {
2291       /* THIS MAY NEVER HAPPEN */
2292       /* set error structures */
2293       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2294       return FALSE;
2295     }
2296   }
2297
2298   return TRUE;
2299 } /* end of fci_flush_cabinet */
2300
2301
2302
2303
2304
2305 /***********************************************************************
2306  *              FCIAddFile (CABINET.11)
2307  *
2308  * FCIAddFile adds a file to the to be created cabinet file
2309  *
2310  * PARAMS
2311  *   hfci          [I]  An HFCI from FCICreate
2312  *   pszSourceFile [I]  A pointer to a C string which contains the name and
2313  *                      location of the file which will be added to the cabinet
2314  *   pszFileName   [I]  A pointer to a C string which contains the name under
2315  *                      which the file will be stored in the cabinet
2316  *   fExecute      [I]  A boolean value which indicates if the file should be
2317  *                      executed after extraction of self extracting
2318  *                      executables
2319  *   pfnfcignc     [I]  A pointer to a function which gets information about
2320  *                      the next cabinet
2321  *   pfnfcis      [IO]  A pointer to a function which will report status
2322  *                      information about the compression process
2323  *   pfnfcioi      [I]  A pointer to a function which reports file attributes
2324  *                      and time and date information
2325  *   typeCompress  [I]  Compression type
2326  *
2327  * RETURNS
2328  *   On success, returns TRUE
2329  *   On failure, returns FALSE
2330  *
2331  * INCLUDES
2332  *   fci.h
2333  *
2334  */
2335 BOOL __cdecl FCIAddFile(
2336         HFCI                  hfci,
2337         char                 *pszSourceFile,
2338         char                 *pszFileName,
2339         BOOL                  fExecute,
2340         PFNFCIGETNEXTCABINET  pfnfcignc,
2341         PFNFCISTATUS          pfnfcis,
2342         PFNFCIGETOPENINFO     pfnfcigoi,
2343         TCOMP                 typeCompress)
2344 {
2345   int err;
2346   CFFILE cffile;
2347   cab_ULONG read_result;
2348   int file_handle;
2349   PFCI_Int p_fci_internal=((PFCI_Int)(hfci));
2350
2351   /* test hfci */
2352   if (!REALLY_IS_FCI(hfci)) {
2353     SetLastError(ERROR_INVALID_HANDLE);
2354     return FALSE;
2355   }
2356
2357   if ((!pszSourceFile) || (!pszFileName) || (!pfnfcignc) || (!pfnfcis) ||
2358       (!pfnfcigoi) || strlen(pszFileName)>=CB_MAX_FILENAME) {
2359     fci_set_error( FCIERR_NONE, ERROR_BAD_ARGUMENTS, TRUE );
2360     return FALSE;
2361   }
2362
2363   /* TODO check if pszSourceFile??? */
2364
2365   if(p_fci_internal->fGetNextCabInVain && p_fci_internal->fNextCab) {
2366     /* internal error */
2367     fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2368     return FALSE;
2369   }
2370
2371   if(p_fci_internal->fNextCab) {
2372     /* internal error */
2373     fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2374     return FALSE;
2375   }
2376
2377   cffile.cbFile=0; /* size of the to be added file*/
2378   /* offset of the uncompressed file in the folder */
2379   cffile.uoffFolderStart=p_fci_internal->cDataBlocks*CAB_BLOCKMAX + p_fci_internal->cdata_in;
2380   /* number of folder in the cabinet or special 0=first  */
2381   cffile.iFolder = p_fci_internal->cFolders;
2382
2383   /* allocation of memory */
2384   if (p_fci_internal->data_in==NULL) {
2385     if (p_fci_internal->cdata_in!=0) {
2386       /* error handling */
2387       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2388       return FALSE;
2389     }
2390     if (p_fci_internal->data_out!=NULL) {
2391       /* error handling */
2392       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2393       return FALSE;
2394     }
2395     if(!(p_fci_internal->data_in = (char*)PFCI_ALLOC(hfci,CB_MAX_CHUNK))) {
2396       fci_set_error( FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY, TRUE );
2397       return FALSE;
2398     }
2399     if (p_fci_internal->data_out==NULL) {
2400       if(!(p_fci_internal->data_out = PFCI_ALLOC(hfci, 2 * CB_MAX_CHUNK))){
2401         fci_set_error( FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY, TRUE );
2402         return FALSE;
2403       }
2404     }
2405   }
2406
2407   if (p_fci_internal->data_out==NULL) {
2408     PFCI_FREE(hfci,p_fci_internal->data_in);
2409     /* error handling */
2410     fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2411     return FALSE;
2412   }
2413
2414   /* get information about the file */
2415   file_handle=(*pfnfcigoi)(pszSourceFile, &(cffile.date), &(cffile.time),
2416     &(cffile.attribs), &err, p_fci_internal->pv);
2417   /* check file_handle */
2418   if(file_handle==0){
2419     fci_set_error( FCIERR_OPEN_SRC, ERROR_OPEN_FAILED, TRUE );
2420   }
2421   /* TODO error handling of err */
2422
2423   if (fExecute) { cffile.attribs |= _A_EXEC; }
2424
2425   /* REUSE the variable read_result */
2426   if (p_fci_internal->fGetNextCabInVain) {
2427     read_result=p_fci_internal->oldCCAB.cbReserveCFHeader +
2428       p_fci_internal->oldCCAB.cbReserveCFFolder;
2429     if ( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
2430         p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
2431         p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
2432       read_result+=4;
2433     }
2434   } else {
2435     read_result=p_fci_internal->pccab->cbReserveCFHeader +
2436       p_fci_internal->pccab->cbReserveCFFolder;
2437     if ( p_fci_internal->pccab->cbReserveCFHeader != 0 ||
2438         p_fci_internal->pccab->cbReserveCFFolder != 0 ||
2439         p_fci_internal->pccab->cbReserveCFData   != 0 ) {
2440       read_result+=4;
2441     }
2442   }
2443   if ( p_fci_internal->fPrevCab ) {
2444     read_result+= strlen(p_fci_internal->szPrevCab)+1+
2445       strlen(p_fci_internal->szPrevDisk)+1;
2446   }
2447   if ( p_fci_internal->fNextCab ) { /* this is never the case */
2448     read_result+= strlen(p_fci_internal->pccab->szCab)+1+
2449       strlen(p_fci_internal->pccab->szDisk)+1;
2450   }
2451
2452   read_result+= sizeof(CFFILE) + strlen(pszFileName)+1 +
2453     p_fci_internal->sizeFileCFFILE1 + p_fci_internal->sizeFileCFDATA2 +
2454     p_fci_internal->sizeFileCFFILE2 + p_fci_internal->sizeFileCFFOLDER +
2455     sizeof(CFHEADER) +
2456     sizeof(CFFOLDER); /* size of new CFFolder entry */
2457
2458   /* Might be too much data for the maximum size of a cabinet.*/
2459   /* When any further data will be added later, it might not */
2460   /* be possible to flush the cabinet, because there might */
2461   /* not be enough space to store the name of the following */
2462   /* cabinet and name of the corresponding disk. */
2463   /* So take care of this and get the name of the next cabinet */
2464   if( p_fci_internal->fGetNextCabInVain==FALSE &&
2465       p_fci_internal->fNextCab==FALSE &&
2466       ( p_fci_internal->pccab->cb < read_result +
2467         CB_MAX_CABINET_NAME + CB_MAX_DISK_NAME
2468       )
2469   ) {
2470     /* save CCAB */
2471     memcpy(&(p_fci_internal->oldCCAB), p_fci_internal->pccab, sizeof(CCAB));
2472     /* increment cabinet index */
2473     ++(p_fci_internal->pccab->iCab);
2474     /* get name of next cabinet */
2475     p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
2476     if (!(*pfnfcignc)(p_fci_internal->pccab,
2477         p_fci_internal->estimatedCabinetSize, /* estimated size of cab */
2478         p_fci_internal->pv)) {
2479       /* error handling */
2480       fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
2481       return FALSE;
2482     }
2483     /* Skip a few lines of code. This is caught by the next if. */
2484     p_fci_internal->fGetNextCabInVain=TRUE;
2485   }
2486
2487   if( p_fci_internal->fGetNextCabInVain &&
2488       p_fci_internal->fNextCab
2489   ) {
2490     /* THIS CAN NEVER HAPPEN */
2491     /* set error code */
2492     fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2493     return FALSE;
2494   }
2495
2496   /* too much data for cabinet */
2497   if( p_fci_internal->fGetNextCabInVain &&
2498      (
2499       p_fci_internal->oldCCAB.cb < read_result +
2500       strlen(p_fci_internal->pccab->szCab)+1+
2501       strlen(p_fci_internal->pccab->szDisk)+1
2502   )) {
2503     p_fci_internal->fGetNextCabInVain=FALSE;
2504     p_fci_internal->fNextCab=TRUE;
2505     if(!fci_flush_cabinet( hfci, FALSE, pfnfcignc, pfnfcis)) return FALSE;
2506   }
2507
2508   if( p_fci_internal->fNextCab ) {
2509     /* THIS MAY NEVER HAPPEN */
2510     /* set error code */
2511     fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2512     return FALSE;
2513   }
2514
2515   /* read the contents of the file blockwise */
2516   while (!FALSE) {
2517     if (p_fci_internal->cdata_in > CAB_BLOCKMAX) {
2518       /* internal error */
2519       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2520       return FALSE;
2521     }
2522
2523     read_result = PFCI_READ(hfci, file_handle /* file handle */,
2524       (p_fci_internal->data_in + p_fci_internal->cdata_in) /* memory buffer */,
2525       (CAB_BLOCKMAX - p_fci_internal->cdata_in) /* number of bytes to copy */,
2526       &err, p_fci_internal->pv);
2527     /* TODO error handling of err */
2528
2529     if( read_result==0 ) break;
2530
2531     /* increment the block size */
2532     p_fci_internal->cdata_in += read_result;
2533
2534     /* increment the file size */
2535     cffile.cbFile += read_result;
2536
2537     if ( p_fci_internal->cdata_in > CAB_BLOCKMAX ) {
2538       /* report internal error */
2539       fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2540       return FALSE;
2541     }
2542     /* write a whole block */
2543     if ( p_fci_internal->cdata_in == CAB_BLOCKMAX ) {
2544
2545       if( !fci_flush_data_block(hfci, &err, pfnfcis) ) return FALSE;
2546     }
2547   }
2548
2549   /* close the file from FCIAddFile */
2550   PFCI_CLOSE(hfci,file_handle,&err,p_fci_internal->pv);
2551   /* TODO error handling of err */
2552
2553   /* write cffile to p_fci_internal->handleCFFILE1 */
2554   if( PFCI_WRITE(hfci, p_fci_internal->handleCFFILE1, /* file handle */
2555       &cffile, sizeof(cffile),&err, p_fci_internal->pv) != sizeof(cffile) ) {
2556     /* write error */
2557     fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
2558     return FALSE;
2559   }
2560   /* TODO error handling of err */
2561
2562   p_fci_internal->sizeFileCFFILE1 += sizeof(cffile);
2563
2564   /* append the name of file */
2565   if (strlen(pszFileName)>=CB_MAX_FILENAME) {
2566     /* IMPOSSIBLE */
2567     /* set error code */
2568     fci_set_error( FCIERR_NONE, ERROR_INVALID_DATA, TRUE );
2569     return FALSE;
2570   }
2571   if( PFCI_WRITE(hfci, p_fci_internal->handleCFFILE1, /* file handle */
2572       pszFileName, strlen(pszFileName)+1, &err, p_fci_internal->pv)
2573       != strlen(pszFileName)+1 ) {
2574     /* write error */
2575     fci_set_error( FCIERR_TEMP_FILE, ERROR_WRITE_FAULT, TRUE );
2576     return FALSE;
2577   }
2578   /* TODO error handling of err */
2579
2580   p_fci_internal->sizeFileCFFILE1 += strlen(pszFileName)+1;
2581
2582   /* REUSE the variable read_result */
2583   if (p_fci_internal->fGetNextCabInVain ||
2584       p_fci_internal->fNextCab
2585      ) {
2586     read_result=p_fci_internal->oldCCAB.cbReserveCFHeader +
2587       p_fci_internal->oldCCAB.cbReserveCFFolder;
2588     if ( p_fci_internal->oldCCAB.cbReserveCFHeader != 0 ||
2589         p_fci_internal->oldCCAB.cbReserveCFFolder != 0 ||
2590         p_fci_internal->oldCCAB.cbReserveCFData   != 0 ) {
2591       read_result+=4;
2592     }
2593   } else {
2594     read_result=p_fci_internal->pccab->cbReserveCFHeader +
2595       p_fci_internal->pccab->cbReserveCFFolder;
2596     if ( p_fci_internal->pccab->cbReserveCFHeader != 0 ||
2597         p_fci_internal->pccab->cbReserveCFFolder != 0 ||
2598         p_fci_internal->pccab->cbReserveCFData   != 0 ) {
2599       read_result+=4;
2600     }
2601   }
2602   if ( p_fci_internal->fPrevCab ) {
2603     read_result+= strlen(p_fci_internal->szPrevCab)+1+
2604       strlen(p_fci_internal->szPrevDisk)+1;
2605   }
2606   if ( p_fci_internal->fNextCab ) { /* this is never the case */
2607     read_result+= strlen(p_fci_internal->pccab->szCab)+1+
2608       strlen(p_fci_internal->pccab->szDisk)+1;
2609   }
2610   read_result+= p_fci_internal->sizeFileCFDATA1 +
2611     p_fci_internal->sizeFileCFFILE1 + p_fci_internal->sizeFileCFDATA2 +
2612     p_fci_internal->sizeFileCFFILE2 + p_fci_internal->sizeFileCFFOLDER +
2613     sizeof(CFHEADER) +
2614     sizeof(CFFOLDER); /* set size of new CFFolder entry */
2615
2616   /* too much data for the maximum size of a cabinet */
2617   /* (ignoring the unflushed data block) */
2618   if( p_fci_internal->fGetNextCabInVain==FALSE &&
2619       p_fci_internal->fNextCab==FALSE && /* this is always the case */
2620       p_fci_internal->pccab->cb < read_result ) {
2621     return fci_flush_cabinet( hfci, FALSE, pfnfcignc, pfnfcis);
2622   }
2623
2624   /* Might be too much data for the maximum size of a cabinet.*/
2625   /* When any further data will be added later, it might not */
2626   /* be possible to flush the cabinet, because there might */
2627   /* not be enough space to store the name of the following */
2628   /* cabinet and name of the corresponding disk. */
2629   /* So take care of this and get the name of the next cabinet */
2630   /* (ignoring the unflushed data block) */
2631   if( p_fci_internal->fGetNextCabInVain==FALSE &&
2632       p_fci_internal->fNextCab==FALSE &&
2633       ( p_fci_internal->pccab->cb < read_result +
2634         CB_MAX_CABINET_NAME + CB_MAX_DISK_NAME
2635       )
2636   ) {
2637     /* save CCAB */
2638     memcpy(&(p_fci_internal->oldCCAB), p_fci_internal->pccab, sizeof(CCAB));
2639     /* increment cabinet index */
2640     ++(p_fci_internal->pccab->iCab);
2641     /* get name of next cabinet */
2642     p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
2643     if (!(*pfnfcignc)(p_fci_internal->pccab,
2644         p_fci_internal->estimatedCabinetSize,/* estimated size of cab */
2645         p_fci_internal->pv)) {
2646       /* error handling */
2647       fci_set_error( FCIERR_NONE, ERROR_FUNCTION_FAILED, TRUE );
2648       return FALSE;
2649     }
2650     /* Skip a few lines of code. This is caught by the next if. */
2651     p_fci_internal->fGetNextCabInVain=TRUE;
2652   }
2653
2654   if( p_fci_internal->fGetNextCabInVain &&
2655       p_fci_internal->fNextCab
2656   ) {
2657     /* THIS CAN NEVER HAPPEN */
2658     fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2659     return FALSE;
2660   }
2661
2662   /* too much data for cabinet */
2663   if( (p_fci_internal->fGetNextCabInVain ||
2664       p_fci_internal->fNextCab) && (
2665       p_fci_internal->oldCCAB.cb < read_result +
2666       strlen(p_fci_internal->pccab->szCab)+1+
2667       strlen(p_fci_internal->pccab->szDisk)+1
2668   )) {
2669
2670     p_fci_internal->fGetNextCabInVain=FALSE;
2671     p_fci_internal->fNextCab=TRUE;
2672     return fci_flush_cabinet( hfci, FALSE, pfnfcignc, pfnfcis);
2673   }
2674
2675   if( p_fci_internal->fNextCab ) {
2676     /* THIS MAY NEVER HAPPEN */
2677     /* set error code */
2678     fci_set_error( FCIERR_NONE, ERROR_GEN_FAILURE, TRUE );
2679     return FALSE;
2680   }
2681
2682   /* if the FolderThreshold has been reached flush the folder automatically */
2683   if( p_fci_internal->fGetNextCabInVain ) {
2684     if( p_fci_internal->cCompressedBytesInFolder >=
2685         p_fci_internal->oldCCAB.cbFolderThresh) {
2686       return FCIFlushFolder(hfci, pfnfcignc, pfnfcis);
2687     }
2688   } else {
2689     if( p_fci_internal->cCompressedBytesInFolder >=
2690         p_fci_internal->pccab->cbFolderThresh) {
2691       return FCIFlushFolder(hfci, pfnfcignc, pfnfcis);
2692     }
2693   }
2694
2695   return TRUE;
2696 } /* end of FCIAddFile */
2697
2698
2699
2700
2701
2702 /***********************************************************************
2703  *              FCIFlushFolder (CABINET.12)
2704  *
2705  * FCIFlushFolder completes the CFFolder structure under construction.
2706  *
2707  * All further data which is added by FCIAddFile will be associateed to
2708  * the next CFFolder structure.
2709  *
2710  * FCIFlushFolder will be called by FCIAddFile automatically if the
2711  * threshold (stored in the member cbFolderThresh of the CCAB structure
2712  * pccab passed to FCICreate) is exceeded.
2713  *
2714  * FCIFlushFolder will be called by FCIFlushFolder automatically before
2715  * any data will be written into the cabinet file.
2716  *
2717  * PARAMS
2718  *   hfci          [I]  An HFCI from FCICreate
2719  *   pfnfcignc     [I]  A pointer to a function which gets information about
2720  *                      the next cabinet
2721  *   pfnfcis      [IO]  A pointer to a function which will report status
2722  *                      information about the compression process
2723  *
2724  * RETURNS
2725  *   On success, returns TRUE
2726  *   On failure, returns FALSE
2727  *
2728  * INCLUDES
2729  *   fci.h
2730  *
2731  */
2732 BOOL __cdecl FCIFlushFolder(
2733         HFCI                  hfci,
2734         PFNFCIGETNEXTCABINET  pfnfcignc,
2735         PFNFCISTATUS          pfnfcis)
2736 {
2737   return fci_flush_folder(hfci,FALSE,pfnfcignc,pfnfcis);
2738 } /* end of FCIFlushFolder */
2739
2740
2741
2742 /***********************************************************************
2743  *              FCIFlushCabinet (CABINET.13)
2744  *
2745  * FCIFlushCabinet stores the data which has been added by FCIAddFile
2746  * into the cabinet file. If the maximum cabinet size (stored in the
2747  * member cb of the CCAB structure pccab passed to FCICreate) has been
2748  * exceeded FCIFlushCabinet will be called automatic by FCIAddFile.
2749  * The remaining data still has to be flushed manually by calling
2750  * FCIFlushCabinet.
2751  *
2752  * After FCIFlushCabinet has been called (manually) FCIAddFile must
2753  * NOT be called again. Then hfci has to be released by FCIDestroy.
2754  *
2755  * PARAMS
2756  *   hfci          [I]  An HFCI from FCICreate
2757  *   fGetNextCab   [I]  Whether you want to add additional files to a
2758  *                      cabinet set (TRUE) or whether you want to
2759  *                      finalize it (FALSE)
2760  *   pfnfcignc     [I]  A pointer to a function which gets information about
2761  *                      the next cabinet
2762  *   pfnfcis      [IO]  A pointer to a function which will report status
2763  *                      information about the compression process
2764  *
2765  * RETURNS
2766  *   On success, returns TRUE
2767  *   On failure, returns FALSE
2768  *
2769  * INCLUDES
2770  *   fci.h
2771  *
2772  */
2773 BOOL __cdecl FCIFlushCabinet(
2774         HFCI                  hfci,
2775         BOOL                  fGetNextCab,
2776         PFNFCIGETNEXTCABINET  pfnfcignc,
2777         PFNFCISTATUS          pfnfcis)
2778 {
2779   PFCI_Int p_fci_internal=((PFCI_Int)(hfci));
2780
2781   if(!fci_flush_cabinet(hfci,fGetNextCab,pfnfcignc,pfnfcis)) return FALSE;
2782
2783   while( p_fci_internal->sizeFileCFFILE1>0 ||
2784          p_fci_internal->sizeFileCFFILE2>0 ) {
2785     if(!fci_flush_cabinet(hfci,fGetNextCab,pfnfcignc,pfnfcis)) return FALSE;
2786   }
2787
2788   return TRUE;
2789 } /* end of FCIFlushCabinet */
2790
2791
2792 /***********************************************************************
2793  *              FCIDestroy (CABINET.14)
2794  *
2795  * Frees a handle created by FCICreate.
2796  * Only reason for failure would be an invalid handle.
2797  *
2798  * PARAMS
2799  *   hfci [I] The HFCI to free
2800  *
2801  * RETURNS
2802  *   TRUE for success
2803  *   FALSE for failure
2804  */
2805 BOOL __cdecl FCIDestroy(HFCI hfci)
2806 {
2807   int err;
2808   PFCI_Int p_fci_internal=((PFCI_Int)(hfci));
2809   if (REALLY_IS_FCI(hfci)) {
2810
2811     /* before hfci can be removed all temporary files must be closed */
2812     /* and deleted */
2813     p_fci_internal->FCI_Intmagic = 0;
2814
2815     PFCI_CLOSE (hfci, p_fci_internal->handleCFDATA1,&err,p_fci_internal->pv);
2816     /* TODO error handling of err */
2817     PFCI_DELETE(hfci, p_fci_internal->szFileNameCFDATA1, &err,
2818       p_fci_internal->pv);
2819     /* TODO error handling of err */
2820     PFCI_CLOSE (hfci, p_fci_internal->handleCFFILE1,&err,p_fci_internal->pv);
2821     /* TODO error handling of err */
2822     PFCI_DELETE(hfci, p_fci_internal->szFileNameCFFILE1, &err,
2823       p_fci_internal->pv);
2824     /* TODO error handling of err */
2825     PFCI_CLOSE (hfci, p_fci_internal->handleCFDATA2,&err,p_fci_internal->pv);
2826     /* TODO error handling of err */
2827     PFCI_DELETE(hfci, p_fci_internal->szFileNameCFDATA2, &err,
2828       p_fci_internal->pv);
2829     /* TODO error handling of err */
2830     PFCI_CLOSE (hfci, p_fci_internal->handleCFFILE2,&err,p_fci_internal->pv);
2831     /* TODO error handling of err */
2832     PFCI_DELETE(hfci, p_fci_internal->szFileNameCFFILE2, &err,
2833       p_fci_internal->pv);
2834     /* TODO error handling of err */
2835     PFCI_CLOSE (hfci, p_fci_internal->handleCFFOLDER,&err,p_fci_internal->pv);
2836     /* TODO error handling of err */
2837     PFCI_DELETE(hfci, p_fci_internal->szFileNameCFFOLDER, &err,
2838       p_fci_internal->pv);
2839     /* TODO error handling of err */
2840
2841     /* data in and out buffers have to be removed */
2842     if (p_fci_internal->data_in!=NULL)
2843       PFCI_FREE(hfci, p_fci_internal->data_in);
2844     if (p_fci_internal->data_out!=NULL)
2845       PFCI_FREE(hfci, p_fci_internal->data_out);
2846
2847     /* hfci can now be removed */
2848     PFCI_FREE(hfci, hfci);
2849     return TRUE;
2850   } else {
2851     SetLastError(ERROR_INVALID_HANDLE);
2852     return FALSE;
2853   }
2854
2855 } /* end of FCIDestroy */