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  * Copyright 2011 Alexandre Julliard
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 /*
  24
  25 There is still some work to be done:
  26
  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
  31 */
  32
  33
  34
  35 #include "config.h"
  36
  37 #include <assert.h>
  38 #include <stdarg.h>
  39 #include <stdio.h>
  40 #include <string.h>
  41 #ifdef HAVE_ZLIB
  42 # include <zlib.h>
  43 #endif
  44
  45 #include "windef.h"
  46 #include "winbase.h"
  47 #include "winerror.h"
  48 #include "winternl.h"
  49 #include "fci.h"
  50 #include "cabinet.h"
  51 #include "wine/list.h"
  52 #include "wine/debug.h"
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(cabinet);
  55
  56 #ifdef WORDS_BIGENDIAN
  57 #define fci_endian_ulong(x) RtlUlongByteSwap(x)
  58 #define fci_endian_uword(x) RtlUshortByteSwap(x)
  59 #else
  60 #define fci_endian_ulong(x) (x)
  61 #define fci_endian_uword(x) (x)
  62 #endif
  63
  64
  65 typedef struct {
  66   cab_UBYTE signature[4]; /* !CAB for unfinished cabinets else MSCF */
  67   cab_ULONG reserved1;
  68   cab_ULONG cbCabinet;    /*  size of the cabinet file in bytes*/
  69   cab_ULONG reserved2;
  70   cab_ULONG coffFiles;    /* offset to first CFFILE section */
  71   cab_ULONG reserved3;
  72   cab_UBYTE versionMinor; /* 3 */
  73   cab_UBYTE versionMajor; /* 1 */
  74   cab_UWORD cFolders;     /* number of CFFOLDER entries in the cabinet*/
  75   cab_UWORD cFiles;       /* number of CFFILE entries in the cabinet*/
  76   cab_UWORD flags;        /* 1=prev cab, 2=next cabinet, 4=reserved sections*/
  77   cab_UWORD setID;        /* identification number of all cabinets in a set*/
  78   cab_UWORD iCabinet;     /* number of the cabinet in a set */
  79   /* additional area if "flags" were set*/
  80 } CFHEADER; /* minimum 36 bytes */
  81
  82 typedef struct {
  83   cab_ULONG coffCabStart; /* offset to the folder's first CFDATA section */
  84   cab_UWORD cCFData;      /* number of this folder's CFDATA sections */
  85   cab_UWORD typeCompress; /* compression type of data in CFDATA section*/
  86   /* additional area if reserve flag was set */
  87 } CFFOLDER; /* minimum 8 bytes */
  88
  89 typedef struct {
  90   cab_ULONG cbFile;          /* size of the uncompressed file in bytes */
  91   cab_ULONG uoffFolderStart; /* offset of the uncompressed file in the folder */
  92   cab_UWORD iFolder;         /* number of folder in the cabinet 0=first  */
  93                              /* for special values see below this structure*/
  94   cab_UWORD date;            /* last modification date*/
  95   cab_UWORD time;            /* last modification time*/
  96   cab_UWORD attribs;         /* DOS fat attributes and UTF indicator */
  97   /* ... and a C string with the name of the file */
  98 } CFFILE; /* 16 bytes + name of file */
  99
 100
 101 typedef struct {
 102   cab_ULONG csum;          /* checksum of this entry*/
 103   cab_UWORD cbData;        /* number of compressed bytes  */
 104   cab_UWORD cbUncomp;      /* number of bytes when data is uncompressed */
 105   /* optional reserved area */
 106   /* compressed data */
 107 } CFDATA;
 108
 109 struct temp_file
 110 {
 111     INT_PTR   handle;
 112     char      name[CB_MAX_FILENAME];
 113 };
 114
 115 struct folder
 116 {
 117     struct list      entry;
 118     struct list      files_list;
 119     struct list      blocks_list;
 120     struct temp_file data;
 121     cab_ULONG        data_start;
 122     cab_UWORD        data_count;
 123     TCOMP            compression;
 124 };
 125
 126 struct file
 127 {
 128     struct list entry;
 129     cab_ULONG   size;    /* uncompressed size */
 130     cab_ULONG   offset;  /* offset in folder */
 131     cab_UWORD   folder;  /* index of folder */
 132     cab_UWORD   date;
 133     cab_UWORD   time;
 134     cab_UWORD   attribs;
 135     char        name[1];
 136 };
 137
 138 struct data_block
 139 {
 140     struct list entry;
 141     cab_UWORD   compressed;
 142     cab_UWORD   uncompressed;
 143 };
 144
 145 typedef struct FCI_Int
 146 {
 147   unsigned int       magic;
 148   PERF               perf;
 149   PFNFCIFILEPLACED   fileplaced;
 150   PFNFCIALLOC        alloc;
 151   PFNFCIFREE         free;
 152   PFNFCIOPEN         open;
 153   PFNFCIREAD         read;
 154   PFNFCIWRITE        write;
 155   PFNFCICLOSE        close;
 156   PFNFCISEEK         seek;
 157   PFNFCIDELETE       delete;
 158   PFNFCIGETTEMPFILE  gettemp;
 159   CCAB               ccab;
 160   PCCAB              pccab;
 161   BOOL               fPrevCab;
 162   BOOL               fNextCab;
 163   BOOL               fSplitFolder;
 164   cab_ULONG          statusFolderCopied;
 165   cab_ULONG          statusFolderTotal;
 166   BOOL               fGetNextCabInVain;
 167   void               *pv;
 168   char               szPrevCab[CB_MAX_CABINET_NAME]; /* previous cabinet name */
 169   char               szPrevDisk[CB_MAX_DISK_NAME];   /* disk name of previous cabinet */
 170   unsigned char      data_in[CAB_BLOCKMAX];          /* uncompressed data blocks */
 171   unsigned char      data_out[2 * CAB_BLOCKMAX];     /* compressed data blocks */
 172   cab_UWORD          cdata_in;
 173   ULONG              cCompressedBytesInFolder;
 174   cab_UWORD          cFolders;
 175   cab_UWORD          cFiles;
 176   cab_ULONG          cDataBlocks;
 177   cab_ULONG          cbFileRemainer; /* uncompressed, yet to be written data */
 178                /* of spanned file of a spanning folder of a spanning cabinet */
 179   struct temp_file   data;
 180   BOOL               fNewPrevious;
 181   cab_ULONG          estimatedCabinetSize;
 182   struct list        folders_list;
 183   struct list        files_list;
 184   struct list        blocks_list;
 185   cab_ULONG          folders_size;
 186   cab_ULONG          files_size;          /* size of files not yet assigned to a folder */
 187   cab_ULONG          placed_files_size;   /* size of files already placed into a folder */
 188   cab_ULONG          pending_data_size;   /* size of data not yet assigned to a folder */
 189   cab_ULONG          folders_data_size;   /* total size of data contained in the current folders */
 190   TCOMP              compression;
 191   cab_UWORD        (*compress)(struct FCI_Int *);
 192 } FCI_Int;
 193
 194 #define FCI_INT_MAGIC 0xfcfcfc05
 195
 196 static void set_error( FCI_Int *fci, int oper, int err )
 197 {
 198     fci->perf->erfOper = oper;
 199     fci->perf->erfType = err;
 200     fci->perf->fError = TRUE;
 201     if (err) SetLastError( err );
 202 }
 203
 204 static FCI_Int *get_fci_ptr( HFCI hfci )
 205 {
 206     FCI_Int *fci= (FCI_Int *)hfci;
 207
 208     if (!fci || fci->magic != FCI_INT_MAGIC)
 209     {
 210         SetLastError( ERROR_INVALID_HANDLE );
 211         return NULL;
 212     }
 213     return fci;
 214 }
 215
 216 /* compute the cabinet header size */
 217 static cab_ULONG get_header_size( FCI_Int *fci )
 218 {
 219     cab_ULONG ret = sizeof(CFHEADER) + fci->ccab.cbReserveCFHeader;
 220
 221     if (fci->ccab.cbReserveCFHeader || fci->ccab.cbReserveCFFolder || fci->ccab.cbReserveCFData)
 222         ret += 4;
 223
 224     if (fci->fPrevCab)
 225         ret += strlen( fci->szPrevCab ) + 1 + strlen( fci->szPrevDisk ) + 1;
 226
 227     if (fci->fNextCab)
 228         ret += strlen( fci->pccab->szCab ) + 1 + strlen( fci->pccab->szDisk ) + 1;
 229
 230     return ret;
 231 }
 232
 233 static BOOL create_temp_file( FCI_Int *fci, struct temp_file *file )
 234 {
 235     int err;
 236
 237     if (!fci->gettemp( file->name, CB_MAX_FILENAME, fci->pv ))
 238     {
 239         set_error( fci, FCIERR_TEMP_FILE, ERROR_FUNCTION_FAILED );
 240         return FALSE;
 241     }
 242     if ((file->handle = fci->open( file->name, _O_RDWR | _O_CREAT | _O_EXCL | _O_BINARY,
 243                                    _S_IREAD | _S_IWRITE, &err, fci->pv )) == -1)
 244     {
 245         set_error( fci, FCIERR_TEMP_FILE, err );
 246         return FALSE;
 247     }
 248     return TRUE;
 249 }
 250
 251 static BOOL close_temp_file( FCI_Int *fci, struct temp_file *file )
 252 {
 253     int err;
 254
 255     if (file->handle == -1) return TRUE;
 256     if (fci->close( file->handle, &err, fci->pv ) == -1)
 257     {
 258         set_error( fci, FCIERR_TEMP_FILE, err );
 259         return FALSE;
 260     }
 261     file->handle = -1;
 262     if (fci->delete( file->name, &err, fci->pv ) == -1)
 263     {
 264         set_error( fci, FCIERR_TEMP_FILE, err );
 265         return FALSE;
 266     }
 267     return TRUE;
 268 }
 269
 270 static struct file *add_file( FCI_Int *fci, const char *filename )
 271 {
 272     unsigned int size = FIELD_OFFSET( struct file, name[strlen(filename) + 1] );
 273     struct file *file = fci->alloc( size );
 274
 275     if (!file)
 276     {
 277         set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
 278         return NULL;
 279     }
 280     file->size    = 0;
 281     file->offset  = fci->cDataBlocks * CAB_BLOCKMAX + fci->cdata_in;
 282     file->folder  = fci->cFolders;
 283     file->date    = 0;
 284     file->time    = 0;
 285     file->attribs = 0;
 286     strcpy( file->name, filename );
 287     list_add_tail( &fci->files_list, &file->entry );
 288     fci->files_size += sizeof(CFFILE) + strlen(filename) + 1;
 289     return file;
 290 }
 291
 292 static struct file *copy_file( FCI_Int *fci, const struct file *orig )
 293 {
 294     unsigned int size = FIELD_OFFSET( struct file, name[strlen(orig->name) + 1] );
 295     struct file *file = fci->alloc( size );
 296
 297     if (!file)
 298     {
 299         set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
 300         return NULL;
 301     }
 302     memcpy( file, orig, size );
 303     return file;
 304 }
 305
 306 static void free_file( FCI_Int *fci, struct file *file )
 307 {
 308     list_remove( &file->entry );
 309     fci->free( file );
 310 }
 311
 312 /* create a new data block for the data in fci->data_in */
 313 static BOOL add_data_block( FCI_Int *fci, PFNFCISTATUS status_callback )
 314 {
 315     int err;
 316     struct data_block *block;
 317
 318     if (!fci->cdata_in) return TRUE;
 319
 320     if (fci->data.handle == -1 && !create_temp_file( fci, &fci->data )) return FALSE;
 321
 322     if (!(block = fci->alloc( sizeof(*block) )))
 323     {
 324         set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
 325         return FALSE;
 326     }
 327     block->uncompressed = fci->cdata_in;
 328     block->compressed   = fci->compress( fci );
 329
 330     if (fci->write( fci->data.handle, fci->data_out,
 331                     block->compressed, &err, fci->pv ) != block->compressed)
 332     {
 333         set_error( fci, FCIERR_TEMP_FILE, err );
 334         fci->free( block );
 335         return FALSE;
 336     }
 337
 338     fci->cdata_in = 0;
 339     fci->pending_data_size += sizeof(CFDATA) + fci->ccab.cbReserveCFData + block->compressed;
 340     fci->cCompressedBytesInFolder += block->compressed;
 341     fci->cDataBlocks++;
 342     list_add_tail( &fci->blocks_list, &block->entry );
 343
 344     if (status_callback( statusFile, block->compressed, block->uncompressed, fci->pv ) == -1)
 345     {
 346         set_error( fci, FCIERR_USER_ABORT, 0 );
 347         return FALSE;
 348     }
 349     return TRUE;
 350 }
 351
 352 /* add compressed blocks for all the data that can be read from the file */
 353 static BOOL add_file_data( FCI_Int *fci, char *sourcefile, char *filename, BOOL execute,
 354                            PFNFCIGETOPENINFO get_open_info, PFNFCISTATUS status_callback )
 355 {
 356     int err, len;
 357     INT_PTR handle;
 358     struct file *file;
 359
 360     if (!(file = add_file( fci, filename ))) return FALSE;
 361
 362     handle = get_open_info( sourcefile, &file->date, &file->time, &file->attribs, &err, fci->pv );
 363     if (handle == -1)
 364     {
 365         free_file( fci, file );
 366         set_error( fci, FCIERR_OPEN_SRC, err );
 367         return FALSE;
 368     }
 369     if (execute) file->attribs |= _A_EXEC;
 370
 371     for (;;)
 372     {
 373         len = fci->read( handle, fci->data_in + fci->cdata_in,
 374                          CAB_BLOCKMAX - fci->cdata_in, &err, fci->pv );
 375         if (!len) break;
 376
 377         if (len == -1)
 378         {
 379             set_error( fci, FCIERR_READ_SRC, err );
 380             return FALSE;
 381         }
 382         file->size += len;
 383         fci->cdata_in += len;
 384         if (fci->cdata_in == CAB_BLOCKMAX && !add_data_block( fci, status_callback )) return FALSE;
 385     }
 386     fci->close( handle, &err, fci->pv );
 387     return TRUE;
 388 }
 389
 390 static void free_data_block( FCI_Int *fci, struct data_block *block )
 391 {
 392     list_remove( &block->entry );
 393     fci->free( block );
 394 }
 395
 396 static struct folder *add_folder( FCI_Int *fci )
 397 {
 398     struct folder *folder = fci->alloc( sizeof(*folder) );
 399
 400     if (!folder)
 401     {
 402         set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
 403         return NULL;
 404     }
 405     folder->data.handle = -1;
 406     folder->data_start  = fci->folders_data_size;
 407     folder->data_count  = 0;
 408     folder->compression = fci->compression;
 409     list_init( &folder->files_list );
 410     list_init( &folder->blocks_list );
 411     list_add_tail( &fci->folders_list, &folder->entry );
 412     fci->folders_size += sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder;
 413     fci->cFolders++;
 414     return folder;
 415 }
 416
 417 static void free_folder( FCI_Int *fci, struct folder *folder )
 418 {
 419     struct file *file, *file_next;
 420     struct data_block *block, *block_next;
 421
 422     LIST_FOR_EACH_ENTRY_SAFE( file, file_next, &folder->files_list, struct file, entry )
 423         free_file( fci, file );
 424     LIST_FOR_EACH_ENTRY_SAFE( block, block_next, &folder->blocks_list, struct data_block, entry )
 425         free_data_block( fci, block );
 426     close_temp_file( fci, &folder->data );
 427     list_remove( &folder->entry );
 428     fci->free( folder );
 429 }
 430
 431 /* reset state for the next cabinet file once the current one has been flushed */
 432 static void reset_cabinet( FCI_Int *fci )
 433 {
 434     struct folder *folder, *folder_next;
 435
 436     LIST_FOR_EACH_ENTRY_SAFE( folder, folder_next, &fci->folders_list, struct folder, entry )
 437         free_folder( fci, folder );
 438
 439     fci->cFolders          = 0;
 440     fci->cFiles            = 0;
 441     fci->folders_size      = 0;
 442     fci->placed_files_size = 0;
 443     fci->folders_data_size = 0;
 444 }
 445
 446 static cab_ULONG fci_get_checksum( const void *pv, UINT cb, cab_ULONG seed )
 447 {
 448   cab_ULONG     csum;
 449   cab_ULONG     ul;
 450   int           cUlong;
 451   const BYTE    *pb;
 452
 453   csum = seed;
 454   cUlong = cb / 4;
 455   pb = pv;
 456
 457   while (cUlong-- > 0) {
 458     ul = *pb++;
 459     ul |= (((cab_ULONG)(*pb++)) <<  8);
 460     ul |= (((cab_ULONG)(*pb++)) << 16);
 461     ul |= (((cab_ULONG)(*pb++)) << 24);
 462     csum ^= ul;
 463   }
 464
 465   ul = 0;
 466   switch (cb % 4) {
 467     case 3:
 468       ul |= (((ULONG)(*pb++)) << 16);
 469       /* fall through */
 470     case 2:
 471       ul |= (((ULONG)(*pb++)) <<  8);
 472       /* fall through */
 473     case 1:
 474       ul |= *pb;
 475       /* fall through */
 476     default:
 477       break;
 478   }
 479   csum ^= ul;
 480
 481   return csum;
 482 }
 483
 484 /* copy all remaining data block to a new temp file */
 485 static BOOL copy_data_blocks( FCI_Int *fci, INT_PTR handle, cab_ULONG start_pos,
 486                               struct temp_file *temp, PFNFCISTATUS status_callback )
 487 {
 488     struct data_block *block;
 489     int err;
 490
 491     if (fci->seek( handle, start_pos, SEEK_SET, &err, fci->pv ) != start_pos)
 492     {
 493         set_error( fci, FCIERR_TEMP_FILE, err );
 494         return FALSE;
 495     }
 496     if (!create_temp_file( fci, temp )) return FALSE;
 497
 498     LIST_FOR_EACH_ENTRY( block, &fci->blocks_list, struct data_block, entry )
 499     {
 500         if (fci->read( handle, fci->data_out, block->compressed,
 501                        &err, fci->pv ) != block->compressed)
 502         {
 503             close_temp_file( fci, temp );
 504             set_error( fci, FCIERR_TEMP_FILE, err );
 505             return FALSE;
 506         }
 507         if (fci->write( temp->handle, fci->data_out, block->compressed,
 508                         &err, fci->pv ) != block->compressed)
 509         {
 510             close_temp_file( fci, temp );
 511             set_error( fci, FCIERR_TEMP_FILE, err );
 512             return FALSE;
 513         }
 514         fci->pending_data_size += sizeof(CFDATA) + fci->ccab.cbReserveCFData + block->compressed;
 515         fci->statusFolderCopied += block->compressed;
 516
 517         if (status_callback( statusFolder, fci->statusFolderCopied,
 518                              fci->statusFolderTotal, fci->pv) == -1)
 519         {
 520             close_temp_file( fci, temp );
 521             set_error( fci, FCIERR_USER_ABORT, 0 );
 522             return FALSE;
 523         }
 524     }
 525     return TRUE;
 526 }
 527
 528 /* write all folders to disk and remove them from the list */
 529 static BOOL write_folders( FCI_Int *fci, INT_PTR handle, cab_ULONG header_size, PFNFCISTATUS status_callback )
 530 {
 531     struct folder *folder;
 532     int err;
 533     CFFOLDER *cffolder = (CFFOLDER *)fci->data_out;
 534     cab_ULONG folder_size = sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder;
 535
 536     memset( cffolder, 0, folder_size );
 537
 538     /* write the folders */
 539     LIST_FOR_EACH_ENTRY( folder, &fci->folders_list, struct folder, entry )
 540     {
 541         cffolder->coffCabStart = fci_endian_ulong( folder->data_start + header_size );
 542         cffolder->cCFData      = fci_endian_uword( folder->data_count );
 543         cffolder->typeCompress = fci_endian_uword( folder->compression );
 544         if (fci->write( handle, cffolder, folder_size, &err, fci->pv ) != folder_size)
 545         {
 546             set_error( fci, FCIERR_CAB_FILE, err );
 547             return FALSE;
 548         }
 549     }
 550     return TRUE;
 551 }
 552
 553 /* write all the files to the cabinet file */
 554 static BOOL write_files( FCI_Int *fci, INT_PTR handle, PFNFCISTATUS status_callback )
 555 {
 556     cab_ULONG file_size;
 557     struct folder *folder;
 558     struct file *file;
 559     int err;
 560     CFFILE *cffile = (CFFILE *)fci->data_out;
 561
 562     LIST_FOR_EACH_ENTRY( folder, &fci->folders_list, struct folder, entry )
 563     {
 564         LIST_FOR_EACH_ENTRY( file, &folder->files_list, struct file, entry )
 565         {
 566             cffile->cbFile          = fci_endian_ulong( file->size );
 567             cffile->uoffFolderStart = fci_endian_ulong( file->offset );
 568             cffile->iFolder         = fci_endian_uword( file->folder );
 569             cffile->date            = fci_endian_uword( file->date );
 570             cffile->time            = fci_endian_uword( file->time );
 571             cffile->attribs         = fci_endian_uword( file->attribs );
 572             lstrcpynA( (char *)(cffile + 1), file->name, CB_MAX_FILENAME );
 573             file_size = sizeof(CFFILE) + strlen( (char *)(cffile + 1) ) + 1;
 574             if (fci->write( handle, cffile, file_size, &err, fci->pv ) != file_size)
 575             {
 576                 set_error( fci, FCIERR_CAB_FILE, err );
 577                 return FALSE;
 578             }
 579             if (!fci->fSplitFolder)
 580             {
 581                 fci->statusFolderCopied = 0;
 582                 /* TODO TEST THIS further */
 583                 fci->statusFolderTotal = fci->folders_data_size + fci->placed_files_size;
 584             }
 585             fci->statusFolderCopied += file_size;
 586             /* report status about copied size of folder */
 587             if (status_callback( statusFolder, fci->statusFolderCopied,
 588                                  fci->statusFolderTotal, fci->pv ) == -1)
 589             {
 590                 set_error( fci, FCIERR_USER_ABORT, 0 );
 591                 return FALSE;
 592             }
 593         }
 594     }
 595     return TRUE;
 596 }
 597
 598 /* write all data blocks to the cabinet file */
 599 static BOOL write_data_blocks( FCI_Int *fci, INT_PTR handle, PFNFCISTATUS status_callback )
 600 {
 601     struct folder *folder;
 602     struct data_block *block;
 603     int err, len;
 604     CFDATA *cfdata;
 605     void *data;
 606     cab_UWORD header_size;
 607
 608     header_size = sizeof(CFDATA) + fci->ccab.cbReserveCFData;
 609     cfdata = (CFDATA *)fci->data_out;
 610     memset( cfdata, 0, header_size );
 611     data = (char *)cfdata + header_size;
 612
 613     LIST_FOR_EACH_ENTRY( folder, &fci->folders_list, struct folder, entry )
 614     {
 615         if (fci->seek( folder->data.handle, 0, SEEK_SET, &err, fci->pv ) != 0)
 616         {
 617             set_error( fci, FCIERR_CAB_FILE, err );
 618             return FALSE;
 619         }
 620         LIST_FOR_EACH_ENTRY( block, &folder->blocks_list, struct data_block, entry )
 621         {
 622             len = fci->read( folder->data.handle, data, block->compressed, &err, fci->pv );
 623             if (len != block->compressed) return FALSE;
 624
 625             cfdata->cbData = fci_endian_uword( block->compressed );
 626             cfdata->cbUncomp = fci_endian_uword( block->uncompressed );
 627             cfdata->csum = fci_endian_ulong( fci_get_checksum( &cfdata->cbData,
 628                                                                header_size - FIELD_OFFSET(CFDATA, cbData),
 629                                                                fci_get_checksum( data, len, 0 )));
 630
 631             fci->statusFolderCopied += len;
 632             len += header_size;
 633             if (fci->write( handle, fci->data_out, len, &err, fci->pv ) != len)
 634             {
 635                 set_error( fci, FCIERR_CAB_FILE, err );
 636                 return FALSE;
 637             }
 638             if (status_callback( statusFolder, fci->statusFolderCopied, fci->statusFolderTotal, fci->pv) == -1)
 639             {
 640                 set_error( fci, FCIERR_USER_ABORT, 0 );
 641                 return FALSE;
 642             }
 643         }
 644     }
 645     return TRUE;
 646 }
 647
 648 /* write the cabinet file to disk */
 649 static BOOL write_cabinet( FCI_Int *fci, PFNFCISTATUS status_callback )
 650 {
 651     char filename[CB_MAX_CAB_PATH + CB_MAX_CABINET_NAME];
 652     int err;
 653     char *ptr;
 654     INT_PTR handle;
 655     CFHEADER *cfheader = (CFHEADER *)fci->data_out;
 656     cab_UWORD flags = 0;
 657     cab_ULONG header_size = get_header_size( fci );
 658     cab_ULONG total_size = header_size + fci->folders_size +
 659                            fci->placed_files_size + fci->folders_data_size;
 660
 661     assert( header_size <= sizeof(fci->data_out) );
 662     memset( cfheader, 0, header_size );
 663
 664     if (fci->fPrevCab) flags |= cfheadPREV_CABINET;
 665     if (fci->fNextCab) flags |= cfheadNEXT_CABINET;
 666     if (fci->ccab.cbReserveCFHeader || fci->ccab.cbReserveCFFolder || fci->ccab.cbReserveCFData)
 667       flags |= cfheadRESERVE_PRESENT;
 668
 669     memcpy( cfheader->signature, "!CAB", 4 );
 670     cfheader->cbCabinet    = fci_endian_ulong( total_size );
 671     cfheader->coffFiles    = fci_endian_ulong( header_size + fci->folders_size );
 672     cfheader->versionMinor = 3;
 673     cfheader->versionMajor = 1;
 674     cfheader->cFolders     = fci_endian_uword( fci->cFolders );
 675     cfheader->cFiles       = fci_endian_uword( fci->cFiles );
 676     cfheader->flags        = fci_endian_uword( flags );
 677     cfheader->setID        = fci_endian_uword( fci->ccab.setID );
 678     cfheader->iCabinet     = fci_endian_uword( fci->ccab.iCab );
 679     ptr = (char *)(cfheader + 1);
 680
 681     if (flags & cfheadRESERVE_PRESENT)
 682     {
 683         struct
 684         {
 685             cab_UWORD cbCFHeader;
 686             cab_UBYTE cbCFFolder;
 687             cab_UBYTE cbCFData;
 688         } *reserve = (void *)ptr;
 689
 690         reserve->cbCFHeader = fci_endian_uword( fci->ccab.cbReserveCFHeader );
 691         reserve->cbCFFolder = fci->ccab.cbReserveCFFolder;
 692         reserve->cbCFData   = fci->ccab.cbReserveCFData;
 693         ptr = (char *)(reserve + 1);
 694     }
 695     ptr += fci->ccab.cbReserveCFHeader;
 696
 697     if (flags & cfheadPREV_CABINET)
 698     {
 699         strcpy( ptr, fci->szPrevCab );
 700         ptr += strlen( ptr ) + 1;
 701         strcpy( ptr, fci->szPrevDisk );
 702         ptr += strlen( ptr ) + 1;
 703     }
 704
 705     if (flags & cfheadNEXT_CABINET)
 706     {
 707         strcpy( ptr, fci->pccab->szCab );
 708         ptr += strlen( ptr ) + 1;
 709         strcpy( ptr, fci->pccab->szDisk );
 710         ptr += strlen( ptr ) + 1;
 711     }
 712
 713     assert( ptr - (char *)cfheader == header_size );
 714
 715     strcpy( filename, fci->ccab.szCabPath );
 716     strcat( filename, fci->ccab.szCab );
 717
 718     if ((handle = fci->open( filename, _O_RDWR | _O_CREAT | _O_TRUNC | _O_BINARY,
 719                              _S_IREAD | _S_IWRITE, &err, fci->pv )) == -1)
 720     {
 721         set_error( fci, FCIERR_CAB_FILE, err );
 722         return FALSE;
 723     }
 724
 725     if (fci->write( handle, cfheader, header_size, &err, fci->pv ) != header_size)
 726     {
 727         set_error( fci, FCIERR_CAB_FILE, err );
 728         goto failed;
 729     }
 730
 731     /* add size of header size of all CFFOLDERs and size of all CFFILEs */
 732     header_size += fci->placed_files_size + fci->folders_size;
 733     if (!write_folders( fci, handle, header_size, status_callback )) goto failed;
 734     if (!write_files( fci, handle, status_callback )) goto failed;
 735     if (!write_data_blocks( fci, handle, status_callback )) goto failed;
 736
 737     /* update the signature */
 738     if (fci->seek( handle, 0, SEEK_SET, &err, fci->pv ) != 0 )
 739     {
 740         set_error( fci, FCIERR_CAB_FILE, err );
 741         goto failed;
 742     }
 743     memcpy( cfheader->signature, "MSCF", 4 );
 744     if (fci->write( handle, cfheader->signature, 4, &err, fci->pv ) != 4)
 745     {
 746         set_error( fci, FCIERR_CAB_FILE, err );
 747         goto failed;
 748     }
 749     fci->close( handle, &err, fci->pv );
 750
 751     reset_cabinet( fci );
 752     status_callback( statusCabinet, fci->estimatedCabinetSize, total_size, fci->pv );
 753     return TRUE;
 754
 755 failed:
 756     fci->close( handle, &err, fci->pv );
 757     fci->delete( filename, &err, fci->pv );
 758     return FALSE;
 759 }
 760
 761 /* add all pending data blocks folder */
 762 static BOOL add_data_to_folder( FCI_Int *fci, struct folder *folder, cab_ULONG *payload,
 763                                 PFNFCISTATUS status_callback )
 764 {
 765     struct data_block *block, *new, *next;
 766     BOOL split_block = FALSE;
 767     cab_ULONG current_size, start_pos = 0;
 768
 769     *payload = 0;
 770     current_size = get_header_size( fci ) + fci->folders_size +
 771                    fci->files_size + fci->placed_files_size + fci->folders_data_size;
 772
 773     /* move the temp file into the folder structure */
 774     folder->data = fci->data;
 775     fci->data.handle = -1;
 776     fci->pending_data_size = 0;
 777
 778     LIST_FOR_EACH_ENTRY_SAFE( block, next, &fci->blocks_list, struct data_block, entry )
 779     {
 780         /* No more CFDATA fits into the cabinet under construction */
 781         /* So don't try to store more data into it */
 782         if (fci->fNextCab && (fci->ccab.cb <= sizeof(CFDATA) + fci->ccab.cbReserveCFData +
 783                               current_size + sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder))
 784             break;
 785
 786         if (!(new = fci->alloc( sizeof(*new) )))
 787         {
 788             set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
 789             return FALSE;
 790         }
 791         /* Is cabinet with new CFDATA too large? Then data block has to be split */
 792         if( fci->fNextCab &&
 793             (fci->ccab.cb < sizeof(CFDATA) + fci->ccab.cbReserveCFData +
 794              block->compressed + current_size + sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder))
 795         {
 796             /* Modify the size of the compressed data to store only a part of the */
 797             /* data block into the current cabinet. This is done to prevent */
 798             /* that the maximum cabinet size will be exceeded. The remainder */
 799             /* will be stored into the next following cabinet. */
 800
 801             new->compressed = fci->ccab.cb - (sizeof(CFDATA) + fci->ccab.cbReserveCFData + current_size +
 802                                               sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder );
 803             new->uncompressed = 0; /* on split blocks of data this is zero */
 804             block->compressed -= new->compressed;
 805             split_block = TRUE;
 806         }
 807         else
 808         {
 809             new->compressed   = block->compressed;
 810             new->uncompressed = block->uncompressed;
 811         }
 812
 813         start_pos += new->compressed;
 814         current_size += sizeof(CFDATA) + fci->ccab.cbReserveCFData + new->compressed;
 815         fci->folders_data_size += sizeof(CFDATA) + fci->ccab.cbReserveCFData + new->compressed;
 816         fci->statusFolderCopied += new->compressed;
 817         (*payload) += new->uncompressed;
 818
 819         list_add_tail( &folder->blocks_list, &new->entry );
 820         folder->data_count++;
 821
 822         /* report status with pfnfcis about copied size of folder */
 823         if (status_callback( statusFolder, fci->statusFolderCopied,
 824                              fci->statusFolderTotal, fci->pv ) == -1)
 825         {
 826             set_error( fci, FCIERR_USER_ABORT, 0 );
 827             return FALSE;
 828         }
 829         if (split_block) break;
 830         free_data_block( fci, block );
 831         fci->cDataBlocks--;
 832     }
 833
 834     if (list_empty( &fci->blocks_list )) return TRUE;
 835     return copy_data_blocks( fci, folder->data.handle, start_pos, &fci->data, status_callback );
 836 }
 837
 838 /* add all pending files to folder */
 839 static BOOL add_files_to_folder( FCI_Int *fci, struct folder *folder, cab_ULONG payload )
 840 {
 841     cab_ULONG sizeOfFiles = 0, sizeOfFilesPrev;
 842     cab_ULONG cbFileRemainer = 0;
 843     struct file *file, *next;
 844
 845     LIST_FOR_EACH_ENTRY_SAFE( file, next, &fci->files_list, struct file, entry )
 846     {
 847         cab_ULONG size = sizeof(CFFILE) + strlen(file->name) + 1;
 848
 849         /* fnfilfnfildest: placed file on cabinet */
 850         fci->fileplaced( &fci->ccab, file->name, file->size,
 851                          (file->folder == cffileCONTINUED_FROM_PREV), fci->pv );
 852
 853         sizeOfFilesPrev = sizeOfFiles;
 854         /* set complete size of all processed files */
 855         if (file->folder == cffileCONTINUED_FROM_PREV && fci->cbFileRemainer != 0)
 856         {
 857             sizeOfFiles += fci->cbFileRemainer;
 858             fci->cbFileRemainer = 0;
 859         }
 860         else sizeOfFiles += file->size;
 861
 862         /* check if spanned file fits into this cabinet folder */
 863         if (sizeOfFiles > payload)
 864         {
 865             if (file->folder == cffileCONTINUED_FROM_PREV)
 866                 file->folder = cffileCONTINUED_PREV_AND_NEXT;
 867             else
 868                 file->folder = cffileCONTINUED_TO_NEXT;
 869         }
 870
 871         list_remove( &file->entry );
 872         list_add_tail( &folder->files_list, &file->entry );
 873         fci->placed_files_size += size;
 874         fci->cFiles++;
 875
 876         /* This is only true for files which will be written into the */
 877         /* next cabinet of the spanning folder */
 878         if (sizeOfFiles > payload)
 879         {
 880             /* add a copy back onto the list */
 881             if (!(file = copy_file( fci, file ))) return FALSE;
 882             list_add_before( &next->entry, &file->entry );
 883
 884             /* Files which data will be partially written into the current cabinet */
 885             if (file->folder == cffileCONTINUED_PREV_AND_NEXT || file->folder == cffileCONTINUED_TO_NEXT)
 886             {
 887                 if (sizeOfFilesPrev <= payload)
 888                 {
 889                     /* The size of the uncompressed, data of a spanning file in a */
 890                     /* spanning data */
 891                     cbFileRemainer = sizeOfFiles - payload;
 892                 }
 893                 file->folder = cffileCONTINUED_FROM_PREV;
 894             }
 895             else file->folder = 0;
 896         }
 897         else
 898         {
 899             fci->files_size -= size;
 900         }
 901     }
 902     fci->cbFileRemainer = cbFileRemainer;
 903     return TRUE;
 904 }
 905
 906 static cab_UWORD compress_NONE( FCI_Int *fci )
 907 {
 908     memcpy( fci->data_out, fci->data_in, fci->cdata_in );
 909     return fci->cdata_in;
 910 }
 911
 912 #ifdef HAVE_ZLIB
 913
 914 static void *zalloc( void *opaque, unsigned int items, unsigned int size )
 915 {
 916     FCI_Int *fci = opaque;
 917     return fci->alloc( items * size );
 918 }
 919
 920 static void zfree( void *opaque, void *ptr )
 921 {
 922     FCI_Int *fci = opaque;
 923     fci->free( ptr );
 924 }
 925
 926 static cab_UWORD compress_MSZIP( FCI_Int *fci )
 927 {
 928     z_stream stream;
 929
 930     stream.zalloc = zalloc;
 931     stream.zfree  = zfree;
 932     stream.opaque = fci;
 933     if (deflateInit2( &stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY ) != Z_OK)
 934     {
 935         set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
 936         return 0;
 937     }
 938     stream.next_in   = fci->data_in;
 939     stream.avail_in  = fci->cdata_in;
 940     stream.next_out  = fci->data_out + 2;
 941     stream.avail_out = sizeof(fci->data_out) - 2;
 942     /* insert the signature */
 943     fci->data_out[0] = 'C';
 944     fci->data_out[1] = 'K';
 945     deflate( &stream, Z_FINISH );
 946     deflateEnd( &stream );
 947     return stream.total_out + 2;
 948 }
 949
 950 #endif  /* HAVE_ZLIB */
 951
 952
 953 /***********************************************************************
 954  *              FCICreate (CABINET.10)
 955  *
 956  * FCICreate is provided with several callbacks and
 957  * returns a handle which can be used to create cabinet files.
 958  *
 959  * PARAMS
 960  *   perf       [IO]  A pointer to an ERF structure.  When FCICreate
 961  *                    returns an error condition, error information may
 962  *                    be found here as well as from GetLastError.
 963  *   pfnfiledest [I]  A pointer to a function which is called when a file
 964  *                    is placed. Only useful for subsequent cabinet files.
 965  *   pfnalloc    [I]  A pointer to a function which allocates ram.  Uses
 966  *                    the same interface as malloc.
 967  *   pfnfree     [I]  A pointer to a function which frees ram.  Uses the
 968  *                    same interface as free.
 969  *   pfnopen     [I]  A pointer to a function which opens a file.  Uses
 970  *                    the same interface as _open.
 971  *   pfnread     [I]  A pointer to a function which reads from a file into
 972  *                    a caller-provided buffer.  Uses the same interface
 973  *                    as _read.
 974  *   pfnwrite    [I]  A pointer to a function which writes to a file from
 975  *                    a caller-provided buffer.  Uses the same interface
 976  *                    as _write.
 977  *   pfnclose    [I]  A pointer to a function which closes a file handle.
 978  *                    Uses the same interface as _close.
 979  *   pfnseek     [I]  A pointer to a function which seeks in a file.
 980  *                    Uses the same interface as _lseek.
 981  *   pfndelete   [I]  A pointer to a function which deletes a file.
 982  *   pfnfcigtf   [I]  A pointer to a function which gets the name of a
 983  *                    temporary file.
 984  *   pccab       [I]  A pointer to an initialized CCAB structure.
 985  *   pv          [I]  A pointer to an application-defined notification
 986  *                    function which will be passed to other FCI functions
 987  *                    as a parameter.
 988  *
 989  * RETURNS
 990  *   On success, returns an FCI handle of type HFCI.
 991  *   On failure, the NULL file handle is returned. Error
 992  *   info can be retrieved from perf.
 993  *
 994  * INCLUDES
 995  *   fci.h
 996  *
 997  */
 998 HFCI __cdecl FCICreate(
 999         PERF perf,
1000         PFNFCIFILEPLACED   pfnfiledest,
1001         PFNFCIALLOC        pfnalloc,
1002         PFNFCIFREE         pfnfree,
1003         PFNFCIOPEN         pfnopen,
1004         PFNFCIREAD         pfnread,
1005         PFNFCIWRITE        pfnwrite,
1006         PFNFCICLOSE        pfnclose,
1007         PFNFCISEEK         pfnseek,
1008         PFNFCIDELETE       pfndelete,
1009         PFNFCIGETTEMPFILE  pfnfcigtf,
1010         PCCAB              pccab,
1011         void *pv)
1012 {
1013   FCI_Int *p_fci_internal;
1014
1015   if (!perf) {
1016     SetLastError(ERROR_BAD_ARGUMENTS);
1017     return NULL;
1018   }
1019   if ((!pfnalloc) || (!pfnfree) || (!pfnopen) || (!pfnread) ||
1020       (!pfnwrite) || (!pfnclose) || (!pfnseek) || (!pfndelete) ||
1021       (!pfnfcigtf) || (!pccab)) {
1022     perf->erfOper = FCIERR_NONE;
1023     perf->erfType = ERROR_BAD_ARGUMENTS;
1024     perf->fError = TRUE;
1025
1026     SetLastError(ERROR_BAD_ARGUMENTS);
1027     return NULL;
1028   }
1029
1030   if (!((p_fci_internal = pfnalloc(sizeof(FCI_Int))))) {
1031     perf->erfOper = FCIERR_ALLOC_FAIL;
1032     perf->erfType = ERROR_NOT_ENOUGH_MEMORY;
1033     perf->fError = TRUE;
1034
1035     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1036     return NULL;
1037   }
1038
1039   p_fci_internal->magic = FCI_INT_MAGIC;
1040   p_fci_internal->perf = perf;
1041   p_fci_internal->fileplaced = pfnfiledest;
1042   p_fci_internal->alloc = pfnalloc;
1043   p_fci_internal->free = pfnfree;
1044   p_fci_internal->open = pfnopen;
1045   p_fci_internal->read = pfnread;
1046   p_fci_internal->write = pfnwrite;
1047   p_fci_internal->close = pfnclose;
1048   p_fci_internal->seek = pfnseek;
1049   p_fci_internal->delete = pfndelete;
1050   p_fci_internal->gettemp = pfnfcigtf;
1051   p_fci_internal->ccab = *pccab;
1052   p_fci_internal->pccab = pccab;
1053   p_fci_internal->fPrevCab = FALSE;
1054   p_fci_internal->fNextCab = FALSE;
1055   p_fci_internal->fSplitFolder = FALSE;
1056   p_fci_internal->fGetNextCabInVain = FALSE;
1057   p_fci_internal->pv = pv;
1058   p_fci_internal->cdata_in = 0;
1059   p_fci_internal->cCompressedBytesInFolder = 0;
1060   p_fci_internal->cFolders = 0;
1061   p_fci_internal->cFiles = 0;
1062   p_fci_internal->cDataBlocks = 0;
1063   p_fci_internal->data.handle = -1;
1064   p_fci_internal->fNewPrevious = FALSE;
1065   p_fci_internal->estimatedCabinetSize = 0;
1066   p_fci_internal->statusFolderTotal = 0;
1067   p_fci_internal->folders_size = 0;
1068   p_fci_internal->files_size = 0;
1069   p_fci_internal->placed_files_size = 0;
1070   p_fci_internal->pending_data_size = 0;
1071   p_fci_internal->folders_data_size = 0;
1072   p_fci_internal->compression = tcompTYPE_NONE;
1073   p_fci_internal->compress = compress_NONE;
1074
1075   list_init( &p_fci_internal->folders_list );
1076   list_init( &p_fci_internal->files_list );
1077   list_init( &p_fci_internal->blocks_list );
1078
1079   memcpy(p_fci_internal->szPrevCab, pccab->szCab, CB_MAX_CABINET_NAME);
1080   memcpy(p_fci_internal->szPrevDisk, pccab->szDisk, CB_MAX_DISK_NAME);
1081
1082   return (HFCI)p_fci_internal;
1083 }
1084
1085
1086
1087
1088 static BOOL fci_flush_folder( FCI_Int *p_fci_internal,
1089         BOOL                  fGetNextCab,
1090         PFNFCIGETNEXTCABINET  pfnfcignc,
1091         PFNFCISTATUS          pfnfcis)
1092 {
1093   cab_ULONG payload;
1094   cab_ULONG read_result;
1095   struct folder *folder;
1096
1097   if ((!pfnfcignc) || (!pfnfcis)) {
1098     set_error( p_fci_internal, FCIERR_NONE, ERROR_BAD_ARGUMENTS );
1099     return FALSE;
1100   }
1101
1102   if( p_fci_internal->fGetNextCabInVain &&
1103       p_fci_internal->fNextCab ){
1104     /* internal error */
1105     set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1106     return FALSE;
1107   }
1108
1109   /* If there was no FCIAddFile or FCIFlushFolder has already been called */
1110   /* this function will return TRUE */
1111   if( p_fci_internal->files_size == 0 ) {
1112     if ( p_fci_internal->pending_data_size != 0 ) {
1113       /* error handling */
1114       set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1115       return FALSE;
1116     }
1117     return TRUE;
1118   }
1119
1120   /* FCIFlushFolder has already been called... */
1121   if (p_fci_internal->fSplitFolder && p_fci_internal->placed_files_size!=0) {
1122     return TRUE;
1123   }
1124
1125   /* This can be set already, because it makes only a difference */
1126   /* when the current function exits with return FALSE */
1127   p_fci_internal->fSplitFolder=FALSE;
1128
1129   /* START of COPY */
1130   if (!add_data_block( p_fci_internal, pfnfcis )) return FALSE;
1131
1132   /* reset to get the number of data blocks of this folder which are */
1133   /* actually in this cabinet ( at least partially ) */
1134   p_fci_internal->cDataBlocks=0;
1135
1136   p_fci_internal->statusFolderTotal = get_header_size( p_fci_internal ) +
1137       sizeof(CFFOLDER) + p_fci_internal->ccab.cbReserveCFFolder +
1138       p_fci_internal->placed_files_size+
1139       p_fci_internal->folders_data_size + p_fci_internal->files_size+
1140       p_fci_internal->pending_data_size + p_fci_internal->folders_size;
1141   p_fci_internal->statusFolderCopied = 0;
1142
1143   /* report status with pfnfcis about copied size of folder */
1144   if( (*pfnfcis)(statusFolder, p_fci_internal->statusFolderCopied,
1145       p_fci_internal->statusFolderTotal, /* TODO total folder size */
1146       p_fci_internal->pv) == -1) {
1147     set_error( p_fci_internal, FCIERR_USER_ABORT, 0 );
1148     return FALSE;
1149   }
1150
1151   /* USE the variable read_result */
1152   read_result = get_header_size( p_fci_internal ) + p_fci_internal->folders_data_size +
1153       p_fci_internal->placed_files_size + p_fci_internal->folders_size;
1154
1155   if(p_fci_internal->files_size!=0) {
1156     read_result+= sizeof(CFFOLDER)+p_fci_internal->ccab.cbReserveCFFolder;
1157   }
1158
1159   /* Check if multiple cabinets have to be created. */
1160
1161   /* Might be too much data for the maximum allowed cabinet size.*/
1162   /* When any further data will be added later, it might not */
1163   /* be possible to flush the cabinet, because there might */
1164   /* not be enough space to store the name of the following */
1165   /* cabinet and name of the corresponding disk. */
1166   /* So take care of this and get the name of the next cabinet */
1167   if( p_fci_internal->fGetNextCabInVain==FALSE &&
1168       p_fci_internal->fNextCab==FALSE &&
1169       (
1170         (
1171           p_fci_internal->ccab.cb < read_result +
1172           p_fci_internal->pending_data_size +
1173           p_fci_internal->files_size +
1174           CB_MAX_CABINET_NAME +   /* next cabinet name */
1175           CB_MAX_DISK_NAME        /* next disk name */
1176         ) || fGetNextCab
1177       )
1178   ) {
1179     /* increment cabinet index */
1180     ++(p_fci_internal->pccab->iCab);
1181     /* get name of next cabinet */
1182     p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
1183     if (!(*pfnfcignc)(p_fci_internal->pccab,
1184         p_fci_internal->estimatedCabinetSize, /* estimated size of cab */
1185         p_fci_internal->pv)) {
1186       set_error( p_fci_internal, FCIERR_NONE, ERROR_FUNCTION_FAILED );
1187       return FALSE;
1188     }
1189
1190     /* Skip a few lines of code. This is caught by the next if. */
1191     p_fci_internal->fGetNextCabInVain=TRUE;
1192   }
1193
1194   /* too much data for cabinet */
1195   if( (p_fci_internal->fGetNextCabInVain ||
1196         p_fci_internal->fNextCab ) &&
1197       (
1198         (
1199           p_fci_internal->ccab.cb < read_result +
1200           p_fci_internal->pending_data_size +
1201           p_fci_internal->files_size +
1202           strlen(p_fci_internal->pccab->szCab)+1 +   /* next cabinet name */
1203           strlen(p_fci_internal->pccab->szDisk)+1    /* next disk name */
1204         ) || fGetNextCab
1205       )
1206   ) {
1207     p_fci_internal->fGetNextCabInVain=FALSE;
1208     p_fci_internal->fNextCab=TRUE;
1209
1210     /* return FALSE if there is not enough space left*/
1211     /* this should never happen */
1212     if (p_fci_internal->ccab.cb <=
1213         p_fci_internal->files_size +
1214         read_result +
1215         strlen(p_fci_internal->pccab->szCab)+1 + /* next cabinet name */
1216         strlen(p_fci_internal->pccab->szDisk)+1  /* next disk name */
1217     ) {
1218
1219       return FALSE;
1220     }
1221
1222     /* the folder will be split across cabinets */
1223     p_fci_internal->fSplitFolder=TRUE;
1224
1225   } else {
1226     /* this should never happen */
1227     if (p_fci_internal->fNextCab) {
1228       /* internal error */
1229       set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1230       return FALSE;
1231     }
1232   }
1233
1234   if (!(folder = add_folder( p_fci_internal ))) return FALSE;
1235   if (!add_data_to_folder( p_fci_internal, folder, &payload, pfnfcis )) return FALSE;
1236   if (!add_files_to_folder( p_fci_internal, folder, payload )) return FALSE;
1237
1238   /* reset CFFolder specific information */
1239   p_fci_internal->cDataBlocks=0;
1240   p_fci_internal->cCompressedBytesInFolder=0;
1241
1242   return TRUE;
1243 }
1244
1245
1246
1247
1248 static BOOL fci_flush_cabinet( FCI_Int *p_fci_internal,
1249         BOOL                  fGetNextCab,
1250         PFNFCIGETNEXTCABINET  pfnfcignc,
1251         PFNFCISTATUS          pfnfcis)
1252 {
1253   cab_ULONG read_result=0;
1254   BOOL returntrue=FALSE;
1255
1256   /* TODO test if fci_flush_cabinet really aborts if there was no FCIAddFile */
1257
1258   /* when FCIFlushCabinet was or FCIAddFile hasn't been called */
1259   if( p_fci_internal->files_size==0 && fGetNextCab ) {
1260     returntrue=TRUE;
1261   }
1262
1263   if (!fci_flush_folder(p_fci_internal,fGetNextCab,pfnfcignc,pfnfcis)){
1264     /* TODO set error */
1265     return FALSE;
1266   }
1267
1268   if(returntrue) return TRUE;
1269
1270   if ( (p_fci_internal->fSplitFolder && p_fci_internal->fNextCab==FALSE)||
1271        (p_fci_internal->folders_size==0 &&
1272          (p_fci_internal->files_size!=0 ||
1273           p_fci_internal->placed_files_size!=0 )
1274      ) )
1275   {
1276       /* error */
1277       set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1278       return FALSE;
1279   }
1280
1281   /* create the cabinet */
1282   if (!write_cabinet( p_fci_internal, pfnfcis )) return FALSE;
1283
1284   p_fci_internal->fPrevCab=TRUE;
1285   /* The sections szPrevCab and szPrevDisk are not being updated, because */
1286   /* MS CABINET.DLL always puts the first cabinet name and disk into them */
1287
1288   if (p_fci_internal->fNextCab) {
1289     p_fci_internal->fNextCab=FALSE;
1290
1291     if (p_fci_internal->files_size==0 && p_fci_internal->pending_data_size!=0) {
1292       /* THIS CAN NEVER HAPPEN */
1293       /* set error code */
1294       set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1295       return FALSE;
1296     }
1297
1298     if( p_fci_internal->fNewPrevious ) {
1299       memcpy(p_fci_internal->szPrevCab, p_fci_internal->ccab.szCab,
1300         CB_MAX_CABINET_NAME);
1301       memcpy(p_fci_internal->szPrevDisk, p_fci_internal->ccab.szDisk,
1302         CB_MAX_DISK_NAME);
1303       p_fci_internal->fNewPrevious=FALSE;
1304     }
1305     p_fci_internal->ccab = *p_fci_internal->pccab;
1306
1307     /* REUSE the variable read_result */
1308     read_result=get_header_size( p_fci_internal );
1309     if(p_fci_internal->files_size!=0) {
1310         read_result+=p_fci_internal->ccab.cbReserveCFFolder;
1311     }
1312     read_result+= p_fci_internal->pending_data_size +
1313       p_fci_internal->files_size + p_fci_internal->folders_data_size +
1314       p_fci_internal->placed_files_size + p_fci_internal->folders_size +
1315       sizeof(CFFOLDER); /* set size of new CFFolder entry */
1316
1317     /* too much data for the maximum size of a cabinet */
1318     if( p_fci_internal->fGetNextCabInVain==FALSE &&
1319         p_fci_internal->ccab.cb < read_result ) {
1320       return fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis);
1321     }
1322
1323     /* Might be too much data for the maximum size of a cabinet.*/
1324     /* When any further data will be added later, it might not */
1325     /* be possible to flush the cabinet, because there might */
1326     /* not be enough space to store the name of the following */
1327     /* cabinet and name of the corresponding disk. */
1328     /* So take care of this and get the name of the next cabinet */
1329     if (p_fci_internal->fGetNextCabInVain==FALSE && (
1330       p_fci_internal->ccab.cb < read_result +
1331       CB_MAX_CABINET_NAME + CB_MAX_DISK_NAME
1332     )) {
1333       /* increment cabinet index */
1334       ++(p_fci_internal->pccab->iCab);
1335       /* get name of next cabinet */
1336       p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
1337       if (!(*pfnfcignc)(p_fci_internal->pccab,
1338           p_fci_internal->estimatedCabinetSize, /* estimated size of cab */
1339           p_fci_internal->pv)) {
1340         /* error handling */
1341         set_error( p_fci_internal, FCIERR_NONE, ERROR_FUNCTION_FAILED );
1342         return FALSE;
1343       }
1344       /* Skip a few lines of code. This is caught by the next if. */
1345       p_fci_internal->fGetNextCabInVain=TRUE;
1346     }
1347
1348     /* too much data for cabinet */
1349     if (p_fci_internal->fGetNextCabInVain && (
1350         p_fci_internal->ccab.cb < read_result +
1351         strlen(p_fci_internal->ccab.szCab)+1+
1352         strlen(p_fci_internal->ccab.szDisk)+1
1353     )) {
1354       p_fci_internal->fGetNextCabInVain=FALSE;
1355       p_fci_internal->fNextCab=TRUE;
1356       return fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis);
1357     }
1358
1359     /* if the FolderThreshold has been reached flush the folder automatically */
1360     if (p_fci_internal->cCompressedBytesInFolder >= p_fci_internal->ccab.cbFolderThresh)
1361         return fci_flush_folder(p_fci_internal, FALSE, pfnfcignc, pfnfcis);
1362
1363     if( p_fci_internal->files_size>0 ) {
1364       if( !fci_flush_folder(p_fci_internal, FALSE, pfnfcignc, pfnfcis) ) return FALSE;
1365       p_fci_internal->fNewPrevious=TRUE;
1366     }
1367   } else {
1368     p_fci_internal->fNewPrevious=FALSE;
1369     if( p_fci_internal->files_size>0 || p_fci_internal->pending_data_size) {
1370       /* THIS MAY NEVER HAPPEN */
1371       /* set error structures */
1372       set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1373       return FALSE;
1374     }
1375   }
1376
1377   return TRUE;
1378 } /* end of fci_flush_cabinet */
1379
1380
1381
1382
1383
1384 /***********************************************************************
1385  *              FCIAddFile (CABINET.11)
1386  *
1387  * FCIAddFile adds a file to the to be created cabinet file
1388  *
1389  * PARAMS
1390  *   hfci          [I]  An HFCI from FCICreate
1391  *   pszSourceFile [I]  A pointer to a C string which contains the name and
1392  *                      location of the file which will be added to the cabinet
1393  *   pszFileName   [I]  A pointer to a C string which contains the name under
1394  *                      which the file will be stored in the cabinet
1395  *   fExecute      [I]  A boolean value which indicates if the file should be
1396  *                      executed after extraction of self extracting
1397  *                      executables
1398  *   pfnfcignc     [I]  A pointer to a function which gets information about
1399  *                      the next cabinet
1400  *   pfnfcis      [IO]  A pointer to a function which will report status
1401  *                      information about the compression process
1402  *   pfnfcioi      [I]  A pointer to a function which reports file attributes
1403  *                      and time and date information
1404  *   typeCompress  [I]  Compression type
1405  *
1406  * RETURNS
1407  *   On success, returns TRUE
1408  *   On failure, returns FALSE
1409  *
1410  * INCLUDES
1411  *   fci.h
1412  *
1413  */
1414 BOOL __cdecl FCIAddFile(
1415         HFCI                  hfci,
1416         char                 *pszSourceFile,
1417         char                 *pszFileName,
1418         BOOL                  fExecute,
1419         PFNFCIGETNEXTCABINET  pfnfcignc,
1420         PFNFCISTATUS          pfnfcis,
1421         PFNFCIGETOPENINFO     pfnfcigoi,
1422         TCOMP                 typeCompress)
1423 {
1424   cab_ULONG read_result;
1425   FCI_Int *p_fci_internal = get_fci_ptr( hfci );
1426
1427   if (!p_fci_internal) return FALSE;
1428
1429   if ((!pszSourceFile) || (!pszFileName) || (!pfnfcignc) || (!pfnfcis) ||
1430       (!pfnfcigoi) || strlen(pszFileName)>=CB_MAX_FILENAME) {
1431     set_error( p_fci_internal, FCIERR_NONE, ERROR_BAD_ARGUMENTS );
1432     return FALSE;
1433   }
1434
1435   if (typeCompress != p_fci_internal->compression)
1436   {
1437       if (!FCIFlushFolder( hfci, pfnfcignc, pfnfcis )) return FALSE;
1438       switch (typeCompress)
1439       {
1440       case tcompTYPE_MSZIP:
1441 #ifdef HAVE_ZLIB
1442           p_fci_internal->compression = tcompTYPE_MSZIP;
1443           p_fci_internal->compress    = compress_MSZIP;
1444           break;
1445 #endif
1446       default:
1447           FIXME( "compression %x not supported, defaulting to none\n", typeCompress );
1448           /* fall through */
1449       case tcompTYPE_NONE:
1450           p_fci_internal->compression = tcompTYPE_NONE;
1451           p_fci_internal->compress    = compress_NONE;
1452           break;
1453       }
1454   }
1455
1456   /* TODO check if pszSourceFile??? */
1457
1458   if(p_fci_internal->fGetNextCabInVain && p_fci_internal->fNextCab) {
1459     /* internal error */
1460     set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1461     return FALSE;
1462   }
1463
1464   if(p_fci_internal->fNextCab) {
1465     /* internal error */
1466     set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1467     return FALSE;
1468   }
1469
1470   /* REUSE the variable read_result */
1471   read_result=get_header_size( p_fci_internal ) + p_fci_internal->ccab.cbReserveCFFolder;
1472
1473   read_result+= sizeof(CFFILE) + strlen(pszFileName)+1 +
1474     p_fci_internal->files_size + p_fci_internal->folders_data_size +
1475     p_fci_internal->placed_files_size + p_fci_internal->folders_size +
1476     sizeof(CFFOLDER); /* size of new CFFolder entry */
1477
1478   /* Might be too much data for the maximum size of a cabinet.*/
1479   /* When any further data will be added later, it might not */
1480   /* be possible to flush the cabinet, because there might */
1481   /* not be enough space to store the name of the following */
1482   /* cabinet and name of the corresponding disk. */
1483   /* So take care of this and get the name of the next cabinet */
1484   if( p_fci_internal->fGetNextCabInVain==FALSE &&
1485       p_fci_internal->fNextCab==FALSE &&
1486       ( p_fci_internal->ccab.cb < read_result +
1487         CB_MAX_CABINET_NAME + CB_MAX_DISK_NAME
1488       )
1489   ) {
1490     /* increment cabinet index */
1491     ++(p_fci_internal->pccab->iCab);
1492     /* get name of next cabinet */
1493     p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
1494     if (!(*pfnfcignc)(p_fci_internal->pccab,
1495         p_fci_internal->estimatedCabinetSize, /* estimated size of cab */
1496         p_fci_internal->pv)) {
1497       /* error handling */
1498       set_error( p_fci_internal, FCIERR_NONE, ERROR_FUNCTION_FAILED );
1499       return FALSE;
1500     }
1501     /* Skip a few lines of code. This is caught by the next if. */
1502     p_fci_internal->fGetNextCabInVain=TRUE;
1503   }
1504
1505   if( p_fci_internal->fGetNextCabInVain &&
1506       p_fci_internal->fNextCab
1507   ) {
1508     /* THIS CAN NEVER HAPPEN */
1509     /* set error code */
1510     set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1511     return FALSE;
1512   }
1513
1514   /* too much data for cabinet */
1515   if( p_fci_internal->fGetNextCabInVain &&
1516      (
1517       p_fci_internal->ccab.cb < read_result +
1518       strlen(p_fci_internal->pccab->szCab)+1+
1519       strlen(p_fci_internal->pccab->szDisk)+1
1520   )) {
1521     p_fci_internal->fGetNextCabInVain=FALSE;
1522     p_fci_internal->fNextCab=TRUE;
1523     if(!fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis)) return FALSE;
1524   }
1525
1526   if( p_fci_internal->fNextCab ) {
1527     /* THIS MAY NEVER HAPPEN */
1528     /* set error code */
1529     set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1530     return FALSE;
1531   }
1532
1533   if (!add_file_data( p_fci_internal, pszSourceFile, pszFileName, fExecute, pfnfcigoi, pfnfcis ))
1534       return FALSE;
1535
1536   /* REUSE the variable read_result */
1537   read_result = get_header_size( p_fci_internal ) + p_fci_internal->ccab.cbReserveCFFolder;
1538   read_result+= p_fci_internal->pending_data_size +
1539     p_fci_internal->files_size + p_fci_internal->folders_data_size +
1540     p_fci_internal->placed_files_size + p_fci_internal->folders_size +
1541     sizeof(CFFOLDER); /* set size of new CFFolder entry */
1542
1543   /* too much data for the maximum size of a cabinet */
1544   /* (ignoring the unflushed data block) */
1545   if( p_fci_internal->fGetNextCabInVain==FALSE &&
1546       p_fci_internal->fNextCab==FALSE && /* this is always the case */
1547       p_fci_internal->ccab.cb < read_result ) {
1548     return fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis);
1549   }
1550
1551   /* Might be too much data for the maximum size of a cabinet.*/
1552   /* When any further data will be added later, it might not */
1553   /* be possible to flush the cabinet, because there might */
1554   /* not be enough space to store the name of the following */
1555   /* cabinet and name of the corresponding disk. */
1556   /* So take care of this and get the name of the next cabinet */
1557   /* (ignoring the unflushed data block) */
1558   if( p_fci_internal->fGetNextCabInVain==FALSE &&
1559       p_fci_internal->fNextCab==FALSE &&
1560       ( p_fci_internal->ccab.cb < read_result +
1561         CB_MAX_CABINET_NAME + CB_MAX_DISK_NAME
1562       )
1563   ) {
1564     /* increment cabinet index */
1565     ++(p_fci_internal->pccab->iCab);
1566     /* get name of next cabinet */
1567     p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
1568     if (!(*pfnfcignc)(p_fci_internal->pccab,
1569         p_fci_internal->estimatedCabinetSize,/* estimated size of cab */
1570         p_fci_internal->pv)) {
1571       /* error handling */
1572       set_error( p_fci_internal, FCIERR_NONE, ERROR_FUNCTION_FAILED );
1573       return FALSE;
1574     }
1575     /* Skip a few lines of code. This is caught by the next if. */
1576     p_fci_internal->fGetNextCabInVain=TRUE;
1577   }
1578
1579   if( p_fci_internal->fGetNextCabInVain &&
1580       p_fci_internal->fNextCab
1581   ) {
1582     /* THIS CAN NEVER HAPPEN */
1583     set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1584     return FALSE;
1585   }
1586
1587   /* too much data for cabinet */
1588   if( (p_fci_internal->fGetNextCabInVain ||
1589       p_fci_internal->fNextCab) && (
1590       p_fci_internal->ccab.cb < read_result +
1591       strlen(p_fci_internal->pccab->szCab)+1+
1592       strlen(p_fci_internal->pccab->szDisk)+1
1593   )) {
1594
1595     p_fci_internal->fGetNextCabInVain=FALSE;
1596     p_fci_internal->fNextCab=TRUE;
1597     return fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis);
1598   }
1599
1600   if( p_fci_internal->fNextCab ) {
1601     /* THIS MAY NEVER HAPPEN */
1602     /* set error code */
1603     set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
1604     return FALSE;
1605   }
1606
1607   /* if the FolderThreshold has been reached flush the folder automatically */
1608   if (p_fci_internal->cCompressedBytesInFolder >= p_fci_internal->ccab.cbFolderThresh)
1609       return FCIFlushFolder(hfci, pfnfcignc, pfnfcis);
1610
1611   return TRUE;
1612 } /* end of FCIAddFile */
1613
1614
1615
1616
1617
1618 /***********************************************************************
1619  *              FCIFlushFolder (CABINET.12)
1620  *
1621  * FCIFlushFolder completes the CFFolder structure under construction.
1622  *
1623  * All further data which is added by FCIAddFile will be associated to
1624  * the next CFFolder structure.
1625  *
1626  * FCIFlushFolder will be called by FCIAddFile automatically if the
1627  * threshold (stored in the member cbFolderThresh of the CCAB structure
1628  * pccab passed to FCICreate) is exceeded.
1629  *
1630  * FCIFlushFolder will be called by FCIFlushFolder automatically before
1631  * any data will be written into the cabinet file.
1632  *
1633  * PARAMS
1634  *   hfci          [I]  An HFCI from FCICreate
1635  *   pfnfcignc     [I]  A pointer to a function which gets information about
1636  *                      the next cabinet
1637  *   pfnfcis      [IO]  A pointer to a function which will report status
1638  *                      information about the compression process
1639  *
1640  * RETURNS
1641  *   On success, returns TRUE
1642  *   On failure, returns FALSE
1643  *
1644  * INCLUDES
1645  *   fci.h
1646  *
1647  */
1648 BOOL __cdecl FCIFlushFolder(
1649         HFCI                  hfci,
1650         PFNFCIGETNEXTCABINET  pfnfcignc,
1651         PFNFCISTATUS          pfnfcis)
1652 {
1653     FCI_Int *p_fci_internal = get_fci_ptr( hfci );
1654
1655     if (!p_fci_internal) return FALSE;
1656     return fci_flush_folder(p_fci_internal,FALSE,pfnfcignc,pfnfcis);
1657 }
1658
1659
1660
1661 /***********************************************************************
1662  *              FCIFlushCabinet (CABINET.13)
1663  *
1664  * FCIFlushCabinet stores the data which has been added by FCIAddFile
1665  * into the cabinet file. If the maximum cabinet size (stored in the
1666  * member cb of the CCAB structure pccab passed to FCICreate) has been
1667  * exceeded FCIFlushCabinet will be called automatic by FCIAddFile.
1668  * The remaining data still has to be flushed manually by calling
1669  * FCIFlushCabinet.
1670  *
1671  * After FCIFlushCabinet has been called (manually) FCIAddFile must
1672  * NOT be called again. Then hfci has to be released by FCIDestroy.
1673  *
1674  * PARAMS
1675  *   hfci          [I]  An HFCI from FCICreate
1676  *   fGetNextCab   [I]  Whether you want to add additional files to a
1677  *                      cabinet set (TRUE) or whether you want to
1678  *                      finalize it (FALSE)
1679  *   pfnfcignc     [I]  A pointer to a function which gets information about
1680  *                      the next cabinet
1681  *   pfnfcis      [IO]  A pointer to a function which will report status
1682  *                      information about the compression process
1683  *
1684  * RETURNS
1685  *   On success, returns TRUE
1686  *   On failure, returns FALSE
1687  *
1688  * INCLUDES
1689  *   fci.h
1690  *
1691  */
1692 BOOL __cdecl FCIFlushCabinet(
1693         HFCI                  hfci,
1694         BOOL                  fGetNextCab,
1695         PFNFCIGETNEXTCABINET  pfnfcignc,
1696         PFNFCISTATUS          pfnfcis)
1697 {
1698   FCI_Int *p_fci_internal = get_fci_ptr( hfci );
1699
1700   if (!p_fci_internal) return FALSE;
1701
1702   if(!fci_flush_cabinet(p_fci_internal,fGetNextCab,pfnfcignc,pfnfcis)) return FALSE;
1703
1704   while( p_fci_internal->files_size>0 ||
1705          p_fci_internal->placed_files_size>0 ) {
1706     if(!fci_flush_cabinet(p_fci_internal,fGetNextCab,pfnfcignc,pfnfcis)) return FALSE;
1707   }
1708
1709   return TRUE;
1710 }
1711
1712
1713 /***********************************************************************
1714  *              FCIDestroy (CABINET.14)
1715  *
1716  * Frees a handle created by FCICreate.
1717  * Only reason for failure would be an invalid handle.
1718  *
1719  * PARAMS
1720  *   hfci [I] The HFCI to free
1721  *
1722  * RETURNS
1723  *   TRUE for success
1724  *   FALSE for failure
1725  */
1726 BOOL __cdecl FCIDestroy(HFCI hfci)
1727 {
1728     struct folder *folder, *folder_next;
1729     struct file *file, *file_next;
1730     struct data_block *block, *block_next;
1731     FCI_Int *p_fci_internal = get_fci_ptr( hfci );
1732
1733     if (!p_fci_internal) return FALSE;
1734
1735     /* before hfci can be removed all temporary files must be closed */
1736     /* and deleted */
1737     p_fci_internal->magic = 0;
1738
1739     LIST_FOR_EACH_ENTRY_SAFE( folder, folder_next, &p_fci_internal->folders_list, struct folder, entry )
1740     {
1741         free_folder( p_fci_internal, folder );
1742     }
1743     LIST_FOR_EACH_ENTRY_SAFE( file, file_next, &p_fci_internal->files_list, struct file, entry )
1744     {
1745         free_file( p_fci_internal, file );
1746     }
1747     LIST_FOR_EACH_ENTRY_SAFE( block, block_next, &p_fci_internal->blocks_list, struct data_block, entry )
1748     {
1749         free_data_block( p_fci_internal, block );
1750     }
1751
1752     close_temp_file( p_fci_internal, &p_fci_internal->data );
1753
1754     /* hfci can now be removed */
1755     p_fci_internal->free(hfci);
1756     return TRUE;
1757 }