fci.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <zlib.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "winternl.h"
#include "fci.h"
#include "cabinet.h"
#include "wine/list.h"
#include "wine/debug.h"

Include dependency graph for fci.c:

Go to the source code of this file.

Classes
struct	CFHEADER
struct	CFFOLDER
struct	CFFILE
struct	CFDATA
struct	temp_file
struct	folder
struct	file
struct	data_block
struct	FCI_Int

Macros
#define	fci_endian_ulong(x)   (x)
#define	fci_endian_uword(x)   (x)
#define	FCI_INT_MAGIC   0xfcfcfc05

Typedefs
typedef struct FCI_Int	FCI_Int

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (cabinet)
static void	set_error (FCI_Int *fci, int oper, int err)
static FCI_Int *	get_fci_ptr (HFCI hfci)
static cab_ULONG	get_header_size (FCI_Int *fci)
static BOOL	create_temp_file (FCI_Int *fci, struct temp_file *file)
static BOOL	close_temp_file (FCI_Int *fci, struct temp_file *file)
static struct file *	add_file (FCI_Int *fci, const char *filename)
static struct file *	copy_file (FCI_Int *fci, const struct file *orig)
static void	free_file (FCI_Int *fci, struct file *file)
static BOOL	add_data_block (FCI_Int *fci, PFNFCISTATUS status_callback)
static BOOL	add_file_data (FCI_Int *fci, char *sourcefile, char *filename, BOOL execute, PFNFCIGETOPENINFO get_open_info, PFNFCISTATUS status_callback)
static void	free_data_block (FCI_Int *fci, struct data_block *block)
static struct folder *	add_folder (FCI_Int *fci)
static void	free_folder (FCI_Int *fci, struct folder *folder)
static void	reset_cabinet (FCI_Int *fci)
static cab_ULONG	fci_get_checksum (const void *pv, UINT cb, cab_ULONG seed)
static BOOL	copy_data_blocks (FCI_Int *fci, INT_PTR handle, cab_ULONG start_pos, struct temp_file *temp, PFNFCISTATUS status_callback)
static BOOL	write_folders (FCI_Int *fci, INT_PTR handle, cab_ULONG header_size, PFNFCISTATUS status_callback)
static BOOL	write_files (FCI_Int *fci, INT_PTR handle, PFNFCISTATUS status_callback)
static BOOL	write_data_blocks (FCI_Int *fci, INT_PTR handle, PFNFCISTATUS status_callback)
static BOOL	write_cabinet (FCI_Int *fci, PFNFCISTATUS status_callback)
static BOOL	add_data_to_folder (FCI_Int *fci, struct folder *folder, cab_ULONG *payload, PFNFCISTATUS status_callback)
static BOOL	add_files_to_folder (FCI_Int *fci, struct folder *folder, cab_ULONG payload)
static cab_UWORD	compress_NONE (FCI_Int *fci)
static void *	zalloc (void *opaque, unsigned int items, unsigned int size)
static void	zfree (void *opaque, void *ptr)
static cab_UWORD	compress_MSZIP (FCI_Int *fci)
HFCI __cdecl	FCICreate (PERF perf, PFNFCIFILEPLACED pfnfiledest, PFNFCIALLOC pfnalloc, PFNFCIFREE pfnfree, PFNFCIOPEN pfnopen, PFNFCIREAD pfnread, PFNFCIWRITE pfnwrite, PFNFCICLOSE pfnclose, PFNFCISEEK pfnseek, PFNFCIDELETE pfndelete, PFNFCIGETTEMPFILE pfnfcigtf, PCCAB pccab, void *pv)
static BOOL	fci_flush_folder (FCI_Int *p_fci_internal, BOOL fGetNextCab, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis)
static BOOL	fci_flush_cabinet (FCI_Int *p_fci_internal, BOOL fGetNextCab, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis)
BOOL __cdecl	FCIAddFile (HFCI hfci, char *pszSourceFile, char *pszFileName, BOOL fExecute, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis, PFNFCIGETOPENINFO pfnfcigoi, TCOMP typeCompress)
BOOL __cdecl	FCIFlushFolder (HFCI hfci, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis)
BOOL __cdecl	FCIFlushCabinet (HFCI hfci, BOOL fGetNextCab, PFNFCIGETNEXTCABINET pfnfcignc, PFNFCISTATUS pfnfcis)
BOOL __cdecl	FCIDestroy (HFCI hfci)

Macro Definition Documentation

fci_endian_ulong

#define fci_endian_ulong

(

x

)

(x)

Definition at line 56 of file fci.c.

fci_endian_uword

#define fci_endian_uword

(

x

)

(x)

Definition at line 57 of file fci.c.

FCI_INT_MAGIC

#define FCI_INT_MAGIC   0xfcfcfc05

Definition at line 190 of file fci.c.

Typedef Documentation

FCI_Int

typedef struct FCI_Int FCI_Int

Function Documentation

add_data_block()

static BOOL add_data_block ( FCI_Int *  fci, PFNFCISTATUS  status_callback  )

static

Definition at line 309 of file fci.c.

{
    int err;
    struct data_block *block;
 
    if (!fci->cdata_in) return TRUE;
 
    if (fci->data.handle == -1 && !create_temp_file( fci, &fci->data )) return FALSE;
 
    if (!(block = fci->alloc( sizeof(*block) )))
    {
        set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
        return FALSE;
    }
    block->uncompressed = fci->cdata_in;
    block->compressed   = fci->compress( fci );
 
    if (fci->write( fci->data.handle, fci->data_out,
                    block->compressed, &err, fci->pv ) != block->compressed)
    {
        set_error( fci, FCIERR_TEMP_FILE, err );
        fci->free( block );
        return FALSE;
    }
 
    fci->cdata_in = 0;
    fci->pending_data_size += sizeof(CFDATA) + fci->ccab.cbReserveCFData + block->compressed;
    fci->cCompressedBytesInFolder += block->compressed;
    fci->cDataBlocks++;
    list_add_tail( &fci->blocks_list, &block->entry );
 
    if (status_callback( statusFile, block->compressed, block->uncompressed, fci->pv ) == -1)
    {
        set_error( fci, FCIERR_USER_ABORT, 0 );
        return FALSE;
    }
    return TRUE;
}

Referenced by add_file_data(), and fci_flush_folder().

add_data_to_folder()

static BOOL add_data_to_folder ( FCI_Int *  fci, struct folder *  folder, cab_ULONG *  payload, PFNFCISTATUS  status_callback  )

static

Definition at line 758 of file fci.c.

{
    struct data_block *block, *new, *next;
    BOOL split_block = FALSE;
    cab_ULONG current_size, start_pos = 0;
 
    *payload = 0;
    current_size = get_header_size( fci ) + fci->folders_size +
                   fci->files_size + fci->placed_files_size + fci->folders_data_size;
 
    /* move the temp file into the folder structure */
    folder->data = fci->data;
    fci->data.handle = -1;
    fci->pending_data_size = 0;
 
    LIST_FOR_EACH_ENTRY_SAFE( block, next, &fci->blocks_list, struct data_block, entry )
    {
        /* No more CFDATA fits into the cabinet under construction */
        /* So don't try to store more data into it */
        if (fci->fNextCab && (fci->ccab.cb <= sizeof(CFDATA) + fci->ccab.cbReserveCFData +
                              current_size + sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder))
            break;
 
        if (!(new = fci->alloc( sizeof(*new) )))
        {
            set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
            return FALSE;
        }
        /* Is cabinet with new CFDATA too large? Then data block has to be split */
        if( fci->fNextCab &&
            (fci->ccab.cb < sizeof(CFDATA) + fci->ccab.cbReserveCFData +
             block->compressed + current_size + sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder))
        {
            /* Modify the size of the compressed data to store only a part of the */
            /* data block into the current cabinet. This is done to prevent */
            /* that the maximum cabinet size will be exceeded. The remainder */
            /* will be stored into the next following cabinet. */
 
            new->compressed = fci->ccab.cb - (sizeof(CFDATA) + fci->ccab.cbReserveCFData + current_size +
                                              sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder );
            new->uncompressed = 0; /* on split blocks of data this is zero */
            block->compressed -= new->compressed;
            split_block = TRUE;
        }
        else
        {
            new->compressed   = block->compressed;
            new->uncompressed = block->uncompressed;
        }
 
        start_pos += new->compressed;
        current_size += sizeof(CFDATA) + fci->ccab.cbReserveCFData + new->compressed;
        fci->folders_data_size += sizeof(CFDATA) + fci->ccab.cbReserveCFData + new->compressed;
        fci->statusFolderCopied += new->compressed;
        (*payload) += new->uncompressed;
 
        list_add_tail( &folder->blocks_list, &new->entry );
        folder->data_count++;
 
        /* report status with pfnfcis about copied size of folder */
        if (status_callback( statusFolder, fci->statusFolderCopied,
                             fci->statusFolderTotal, fci->pv ) == -1)
        {
            set_error( fci, FCIERR_USER_ABORT, 0 );
            return FALSE;
        }
        if (split_block) break;
        free_data_block( fci, block );
        fci->cDataBlocks--;
    }
 
    if (list_empty( &fci->blocks_list )) return TRUE;
    return copy_data_blocks( fci, folder->data.handle, start_pos, &fci->data, status_callback );
}

Referenced by fci_flush_folder().

add_file()

static struct file * add_file ( FCI_Int *  fci, const char *  filename  )

static

Definition at line 266 of file fci.c.

{
    unsigned int size = FIELD_OFFSET( struct file, name[strlen(filename) + 1] );
    struct file *file = fci->alloc( size );
 
    if (!file)
    {
        set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
        return NULL;
    }
    file->size    = 0;
    file->offset  = fci->cDataBlocks * CAB_BLOCKMAX + fci->cdata_in;
    file->folder  = fci->cFolders;
    file->date    = 0;
    file->time    = 0;
    file->attribs = 0;
    strcpy( file->name, filename );
    list_add_tail( &fci->files_list, &file->entry );
    fci->files_size += sizeof(CFFILE) + strlen(filename) + 1;
    return file;
}

Referenced by add_file_data().

add_file_data()

static BOOL add_file_data ( FCI_Int *  fci, char *  sourcefile, char *  filename, BOOL  execute, PFNFCIGETOPENINFO  get_open_info, PFNFCISTATUS  status_callback  )

static

Definition at line 349 of file fci.c.

{
    int err, len;
    INT_PTR handle;
    struct file *file;
 
    if (!(file = add_file( fci, filename ))) return FALSE;
 
    handle = get_open_info( sourcefile, &file->date, &file->time, &file->attribs, &err, fci->pv );
    if (handle == -1)
    {
        free_file( fci, file );
        set_error( fci, FCIERR_OPEN_SRC, err );
        return FALSE;
    }
    if (execute) file->attribs |= _A_EXEC;
 
    for (;;)
    {
        len = fci->read( handle, fci->data_in + fci->cdata_in,
                         CAB_BLOCKMAX - fci->cdata_in, &err, fci->pv );
        if (!len) break;
 
        if (len == -1)
        {
            set_error( fci, FCIERR_READ_SRC, err );
            return FALSE;
        }
        file->size += len;
        fci->cdata_in += len;
        if (fci->cdata_in == CAB_BLOCKMAX && !add_data_block( fci, status_callback )) return FALSE;
    }
    fci->close( handle, &err, fci->pv );
    return TRUE;
}

Referenced by FCIAddFile().

add_files_to_folder()

static BOOL add_files_to_folder ( FCI_Int *  fci, struct folder *  folder, cab_ULONG  payload  )

static

Definition at line 835 of file fci.c.

{
    cab_ULONG sizeOfFiles = 0, sizeOfFilesPrev;
    cab_ULONG cbFileRemainder = 0;
    struct file *file, *next;
 
    LIST_FOR_EACH_ENTRY_SAFE( file, next, &fci->files_list, struct file, entry )
    {
        cab_ULONG size = sizeof(CFFILE) + strlen(file->name) + 1;
 
        /* fnfilfnfildest: placed file on cabinet */
        fci->fileplaced( &fci->ccab, file->name, file->size,
                         (file->folder == cffileCONTINUED_FROM_PREV), fci->pv );
 
        sizeOfFilesPrev = sizeOfFiles;
        /* set complete size of all processed files */
        if (file->folder == cffileCONTINUED_FROM_PREV && fci->cbFileRemainder != 0)
        {
            sizeOfFiles += fci->cbFileRemainder;
            fci->cbFileRemainder = 0;
        }
        else sizeOfFiles += file->size;
 
        /* check if spanned file fits into this cabinet folder */
        if (sizeOfFiles > payload)
        {
            if (file->folder == cffileCONTINUED_FROM_PREV)
                file->folder = cffileCONTINUED_PREV_AND_NEXT;
            else
                file->folder = cffileCONTINUED_TO_NEXT;
        }
 
        list_remove( &file->entry );
        list_add_tail( &folder->files_list, &file->entry );
        fci->placed_files_size += size;
        fci->cFiles++;
 
        /* This is only true for files which will be written into the */
        /* next cabinet of the spanning folder */
        if (sizeOfFiles > payload)
        {
            /* add a copy back onto the list */
            if (!(file = copy_file( fci, file ))) return FALSE;
            list_add_before( &next->entry, &file->entry );
 
            /* Files which data will be partially written into the current cabinet */
            if (file->folder == cffileCONTINUED_PREV_AND_NEXT || file->folder == cffileCONTINUED_TO_NEXT)
            {
                if (sizeOfFilesPrev <= payload)
                {
                    /* The size of the uncompressed, data of a spanning file in a */
                    /* spanning data */
                    cbFileRemainder = sizeOfFiles - payload;
                }
                file->folder = cffileCONTINUED_FROM_PREV;
            }
            else file->folder = 0;
        }
        else
        {
            fci->files_size -= size;
        }
    }
    fci->cbFileRemainder = cbFileRemainder;
    return TRUE;
}

Referenced by fci_flush_folder().

add_folder()

static struct folder * add_folder ( FCI_Int *  fci )

static

Definition at line 392 of file fci.c.

{
    struct folder *folder = fci->alloc( sizeof(*folder) );
 
    if (!folder)
    {
        set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
        return NULL;
    }
    folder->data.handle = -1;
    folder->data_start  = fci->folders_data_size;
    folder->data_count  = 0;
    folder->compression = fci->compression;
    list_init( &folder->files_list );
    list_init( &folder->blocks_list );
    list_add_tail( &fci->folders_list, &folder->entry );
    fci->folders_size += sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder;
    fci->cFolders++;
    return folder;
}

Referenced by fci_flush_folder().

close_temp_file()

static BOOL close_temp_file ( FCI_Int *  fci, struct temp_file *  file  )

static

Definition at line 247 of file fci.c.

{
    int err;
 
    if (file->handle == -1) return TRUE;
    if (fci->close( file->handle, &err, fci->pv ) == -1)
    {
        set_error( fci, FCIERR_TEMP_FILE, err );
        return FALSE;
    }
    file->handle = -1;
    if (fci->delete( file->name, &err, fci->pv ) == -1)
    {
        set_error( fci, FCIERR_TEMP_FILE, err );
        return FALSE;
    }
    return TRUE;
}

Referenced by copy_data_blocks(), FCIDestroy(), and free_folder().

compress_MSZIP()

static cab_UWORD compress_MSZIP ( FCI_Int *  fci )

static

Definition at line 920 of file fci.c.

{
    z_stream stream;
 
    stream.zalloc = zalloc;
    stream.zfree  = zfree;
    stream.opaque = fci;
    if (deflateInit2( &stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY ) != Z_OK)
    {
        set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
        return 0;
    }
    stream.next_in   = fci->data_in;
    stream.avail_in  = fci->cdata_in;
    stream.next_out  = fci->data_out + 2;
    stream.avail_out = sizeof(fci->data_out) - 2;
    /* insert the signature */
    fci->data_out[0] = 'C';
    fci->data_out[1] = 'K';
    deflate( &stream, Z_FINISH );
    deflateEnd( &stream );
    return stream.total_out + 2;
}

Referenced by FCIAddFile().

compress_NONE()

static cab_UWORD compress_NONE ( FCI_Int *  fci )

static

Definition at line 902 of file fci.c.

{
    memcpy( fci->data_out, fci->data_in, fci->cdata_in );
    return fci->cdata_in;
}

Referenced by FCIAddFile(), and FCICreate().

copy_data_blocks()

static BOOL copy_data_blocks ( FCI_Int *  fci, INT_PTR  handle, cab_ULONG  start_pos, struct temp_file *  temp, PFNFCISTATUS  status_callback  )

static

Definition at line 481 of file fci.c.

{
    struct data_block *block;
    int err;
 
    if (fci->seek( handle, start_pos, SEEK_SET, &err, fci->pv ) != start_pos)
    {
        set_error( fci, FCIERR_TEMP_FILE, err );
        return FALSE;
    }
    if (!create_temp_file( fci, temp )) return FALSE;
 
    LIST_FOR_EACH_ENTRY( block, &fci->blocks_list, struct data_block, entry )
    {
        if (fci->read( handle, fci->data_out, block->compressed,
                       &err, fci->pv ) != block->compressed)
        {
            close_temp_file( fci, temp );
            set_error( fci, FCIERR_TEMP_FILE, err );
            return FALSE;
        }
        if (fci->write( temp->handle, fci->data_out, block->compressed,
                        &err, fci->pv ) != block->compressed)
        {
            close_temp_file( fci, temp );
            set_error( fci, FCIERR_TEMP_FILE, err );
            return FALSE;
        }
        fci->pending_data_size += sizeof(CFDATA) + fci->ccab.cbReserveCFData + block->compressed;
        fci->statusFolderCopied += block->compressed;
 
        if (status_callback( statusFolder, fci->statusFolderCopied,
                             fci->statusFolderTotal, fci->pv) == -1)
        {
            close_temp_file( fci, temp );
            set_error( fci, FCIERR_USER_ABORT, 0 );
            return FALSE;
        }
    }
    return TRUE;
}

Referenced by add_data_to_folder().

copy_file()

static struct file * copy_file ( FCI_Int *  fci, const struct file *  orig  )

static

Definition at line 288 of file fci.c.

{
    unsigned int size = FIELD_OFFSET( struct file, name[strlen(orig->name) + 1] );
    struct file *file = fci->alloc( size );
 
    if (!file)
    {
        set_error( fci, FCIERR_ALLOC_FAIL, ERROR_NOT_ENOUGH_MEMORY );
        return NULL;
    }
    memcpy( file, orig, size );
    return file;
}

Referenced by add_files_to_folder().

create_temp_file()

static BOOL create_temp_file ( FCI_Int *  fci, struct temp_file *  file  )

static

Definition at line 229 of file fci.c.

{
    int err;
 
    if (!fci->gettemp( file->name, CB_MAX_FILENAME, fci->pv ))
    {
        set_error( fci, FCIERR_TEMP_FILE, ERROR_FUNCTION_FAILED );
        return FALSE;
    }
    if ((file->handle = fci->open( file->name, _O_RDWR | _O_CREAT | _O_EXCL | _O_BINARY,
                                   _S_IREAD | _S_IWRITE, &err, fci->pv )) == -1)
    {
        set_error( fci, FCIERR_TEMP_FILE, err );
        return FALSE;
    }
    return TRUE;
}

Referenced by add_data_block(), and copy_data_blocks().

fci_flush_cabinet()

static BOOL fci_flush_cabinet ( FCI_Int *  p_fci_internal, BOOL  fGetNextCab, PFNFCIGETNEXTCABINET  pfnfcignc, PFNFCISTATUS  pfnfcis  )

static

Definition at line 1223 of file fci.c.

{
  cab_ULONG read_result=0;
  BOOL returntrue=FALSE;
 
  /* TODO test if fci_flush_cabinet really aborts if there was no FCIAddFile */
 
  /* when FCIFlushCabinet was or FCIAddFile hasn't been called */
  if( p_fci_internal->files_size==0 && fGetNextCab ) {
    returntrue=TRUE;
  }
 
  if (!fci_flush_folder(p_fci_internal,fGetNextCab,pfnfcignc,pfnfcis)){
    /* TODO set error */
    return FALSE;
  }
 
  if(returntrue) return TRUE;
 
  if ( (p_fci_internal->fSplitFolder && p_fci_internal->fNextCab==FALSE)||
       (p_fci_internal->folders_size==0 &&
         (p_fci_internal->files_size!=0 ||
          p_fci_internal->placed_files_size!=0 )
     ) )
  {
      /* error */
      set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
      return FALSE;
  }
 
  /* create the cabinet */
  if (!write_cabinet( p_fci_internal, pfnfcis )) return FALSE;
 
  p_fci_internal->fPrevCab=TRUE;
  /* The sections szPrevCab and szPrevDisk are not being updated, because */
  /* MS CABINET.DLL always puts the first cabinet name and disk into them */
 
  if (p_fci_internal->fNextCab) {
    p_fci_internal->fNextCab=FALSE;
 
    if (p_fci_internal->files_size==0 && p_fci_internal->pending_data_size!=0) {
      /* THIS CAN NEVER HAPPEN */
      /* set error code */
      set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
      return FALSE;
    }
 
    if( p_fci_internal->fNewPrevious ) {
      memcpy(p_fci_internal->szPrevCab, p_fci_internal->ccab.szCab,
        CB_MAX_CABINET_NAME);
      memcpy(p_fci_internal->szPrevDisk, p_fci_internal->ccab.szDisk,
        CB_MAX_DISK_NAME);
      p_fci_internal->fNewPrevious=FALSE;
    }
    p_fci_internal->ccab = *p_fci_internal->pccab;
 
    /* REUSE the variable read_result */
    read_result=get_header_size( p_fci_internal );
    if(p_fci_internal->files_size!=0) {
        read_result+=p_fci_internal->ccab.cbReserveCFFolder;
    }
    read_result+= p_fci_internal->pending_data_size +
      p_fci_internal->files_size + p_fci_internal->folders_data_size +
      p_fci_internal->placed_files_size + p_fci_internal->folders_size +
      sizeof(CFFOLDER); /* set size of new CFFolder entry */
 
    /* too much data for the maximum size of a cabinet */
    if( p_fci_internal->fGetNextCabInVain==FALSE &&
        p_fci_internal->ccab.cb < read_result ) {
      return fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis);
    }
 
    /* Might be too much data for the maximum size of a cabinet.*/
    /* When any further data will be added later, it might not */
    /* be possible to flush the cabinet, because there might */
    /* not be enough space to store the name of the following */
    /* cabinet and name of the corresponding disk. */
    /* So take care of this and get the name of the next cabinet */
    if (p_fci_internal->fGetNextCabInVain==FALSE && (
      p_fci_internal->ccab.cb < read_result +
      CB_MAX_CABINET_NAME + CB_MAX_DISK_NAME
    )) {
      /* increment cabinet index */
      ++(p_fci_internal->pccab->iCab);
      /* get name of next cabinet */
      p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
      if (!(*pfnfcignc)(p_fci_internal->pccab,
          p_fci_internal->estimatedCabinetSize, /* estimated size of cab */
          p_fci_internal->pv)) {
        /* error handling */
        set_error( p_fci_internal, FCIERR_NONE, ERROR_FUNCTION_FAILED );
        return FALSE;
      }
      /* Skip a few lines of code. This is caught by the next if. */
      p_fci_internal->fGetNextCabInVain=TRUE;
    }
 
    /* too much data for cabinet */
    if (p_fci_internal->fGetNextCabInVain && (
        p_fci_internal->ccab.cb < read_result +
        strlen(p_fci_internal->ccab.szCab)+1+
        strlen(p_fci_internal->ccab.szDisk)+1
    )) {
      p_fci_internal->fGetNextCabInVain=FALSE;
      p_fci_internal->fNextCab=TRUE;
      return fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis);
    }
 
    /* if the FolderThreshold has been reached flush the folder automatically */
    if (p_fci_internal->cCompressedBytesInFolder >= p_fci_internal->ccab.cbFolderThresh)
        return fci_flush_folder(p_fci_internal, FALSE, pfnfcignc, pfnfcis);
 
    if( p_fci_internal->files_size>0 ) {
      if( !fci_flush_folder(p_fci_internal, FALSE, pfnfcignc, pfnfcis) ) return FALSE;
      p_fci_internal->fNewPrevious=TRUE;
    }
  } else {
    p_fci_internal->fNewPrevious=FALSE;
    if( p_fci_internal->files_size>0 || p_fci_internal->pending_data_size) {
      /* THIS MAY NEVER HAPPEN */
      /* set error structures */
      set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
      return FALSE;
    }
  }
 
  return TRUE;
} /* end of fci_flush_cabinet */

Referenced by fci_flush_cabinet(), FCIAddFile(), and FCIFlushCabinet().

fci_flush_folder()

static BOOL fci_flush_folder ( FCI_Int *  p_fci_internal, BOOL  fGetNextCab, PFNFCIGETNEXTCABINET  pfnfcignc, PFNFCISTATUS  pfnfcis  )

static

Definition at line 1063 of file fci.c.

{
  cab_ULONG payload;
  cab_ULONG read_result;
  struct folder *folder;
 
  if ((!pfnfcignc) || (!pfnfcis)) {
    set_error( p_fci_internal, FCIERR_NONE, ERROR_BAD_ARGUMENTS );
    return FALSE;
  }
 
  if( p_fci_internal->fGetNextCabInVain &&
      p_fci_internal->fNextCab ){
    /* internal error */
    set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
    return FALSE;
  }
 
  /* If there was no FCIAddFile or FCIFlushFolder has already been called */
  /* this function will return TRUE */
  if( p_fci_internal->files_size == 0 ) {
    if ( p_fci_internal->pending_data_size != 0 ) {
      /* error handling */
      set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
      return FALSE;
    }
    return TRUE;
  }
 
  /* FCIFlushFolder has already been called... */
  if (p_fci_internal->fSplitFolder && p_fci_internal->placed_files_size!=0) {
    return TRUE;
  }
 
  /* This can be set already, because it makes only a difference */
  /* when the current function exits with return FALSE */
  p_fci_internal->fSplitFolder=FALSE;
 
  /* START of COPY */
  if (!add_data_block( p_fci_internal, pfnfcis )) return FALSE;
 
  /* reset to get the number of data blocks of this folder which are */
  /* actually in this cabinet ( at least partially ) */
  p_fci_internal->cDataBlocks=0;
 
  p_fci_internal->statusFolderTotal = get_header_size( p_fci_internal ) +
      sizeof(CFFOLDER) + p_fci_internal->ccab.cbReserveCFFolder +
      p_fci_internal->placed_files_size+
      p_fci_internal->folders_data_size + p_fci_internal->files_size+
      p_fci_internal->pending_data_size + p_fci_internal->folders_size;
  p_fci_internal->statusFolderCopied = 0;
 
  /* report status with pfnfcis about copied size of folder */
  if( (*pfnfcis)(statusFolder, p_fci_internal->statusFolderCopied,
      p_fci_internal->statusFolderTotal, /* TODO total folder size */
      p_fci_internal->pv) == -1) {
    set_error( p_fci_internal, FCIERR_USER_ABORT, 0 );
    return FALSE;
  }
 
  /* USE the variable read_result */
  read_result = get_header_size( p_fci_internal ) + p_fci_internal->folders_data_size +
      p_fci_internal->placed_files_size + p_fci_internal->folders_size;
 
  if(p_fci_internal->files_size!=0) {
    read_result+= sizeof(CFFOLDER)+p_fci_internal->ccab.cbReserveCFFolder;
  }
 
  /* Check if multiple cabinets have to be created. */
 
  /* Might be too much data for the maximum allowed cabinet size.*/
  /* When any further data will be added later, it might not */
  /* be possible to flush the cabinet, because there might */
  /* not be enough space to store the name of the following */
  /* cabinet and name of the corresponding disk. */
  /* So take care of this and get the name of the next cabinet */
  if( p_fci_internal->fGetNextCabInVain==FALSE &&
      p_fci_internal->fNextCab==FALSE &&
      (
        (
          p_fci_internal->ccab.cb < read_result +
          p_fci_internal->pending_data_size +
          p_fci_internal->files_size +
          CB_MAX_CABINET_NAME +   /* next cabinet name */
          CB_MAX_DISK_NAME        /* next disk name */
        ) || fGetNextCab
      )
  ) {
    /* increment cabinet index */
    ++(p_fci_internal->pccab->iCab);
    /* get name of next cabinet */
    p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
    if (!(*pfnfcignc)(p_fci_internal->pccab,
        p_fci_internal->estimatedCabinetSize, /* estimated size of cab */
        p_fci_internal->pv)) {
      set_error( p_fci_internal, FCIERR_NONE, ERROR_FUNCTION_FAILED );
      return FALSE;
    }
 
    /* Skip a few lines of code. This is caught by the next if. */
    p_fci_internal->fGetNextCabInVain=TRUE;
  }
 
  /* too much data for cabinet */
  if( (p_fci_internal->fGetNextCabInVain ||
        p_fci_internal->fNextCab ) &&
      (
        (
          p_fci_internal->ccab.cb < read_result +
          p_fci_internal->pending_data_size +
          p_fci_internal->files_size +
          strlen(p_fci_internal->pccab->szCab)+1 +   /* next cabinet name */
          strlen(p_fci_internal->pccab->szDisk)+1    /* next disk name */
        ) || fGetNextCab
      )
  ) {
    p_fci_internal->fGetNextCabInVain=FALSE;
    p_fci_internal->fNextCab=TRUE;
 
    /* return FALSE if there is not enough space left*/
    /* this should never happen */
    if (p_fci_internal->ccab.cb <=
        p_fci_internal->files_size +
        read_result +
        strlen(p_fci_internal->pccab->szCab)+1 + /* next cabinet name */
        strlen(p_fci_internal->pccab->szDisk)+1  /* next disk name */
    ) {
 
      return FALSE;
    }
 
    /* the folder will be split across cabinets */
    p_fci_internal->fSplitFolder=TRUE;
 
  } else {
    /* this should never happen */
    if (p_fci_internal->fNextCab) {
      /* internal error */
      set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
      return FALSE;
    }
  }
 
  if (!(folder = add_folder( p_fci_internal ))) return FALSE;
  if (!add_data_to_folder( p_fci_internal, folder, &payload, pfnfcis )) return FALSE;
  if (!add_files_to_folder( p_fci_internal, folder, payload )) return FALSE;
 
  /* reset CFFolder specific information */
  p_fci_internal->cDataBlocks=0;
  p_fci_internal->cCompressedBytesInFolder=0;
 
  return TRUE;
}

Referenced by fci_flush_cabinet(), and FCIFlushFolder().

fci_get_checksum()

static cab_ULONG fci_get_checksum ( const void *  pv, UINT  cb, cab_ULONG  seed  )

static

Definition at line 442 of file fci.c.

{
  cab_ULONG     csum;
  cab_ULONG     ul;
  int           cUlong;
  const BYTE    *pb;
 
  csum = seed;
  cUlong = cb / 4;
  pb = pv;
 
  while (cUlong-- > 0) {
    ul = *pb++;
    ul |= (((cab_ULONG)(*pb++)) <<  8);
    ul |= (((cab_ULONG)(*pb++)) << 16);
    ul |= (((cab_ULONG)(*pb++)) << 24);
    csum ^= ul;
  }
 
  ul = 0;
  switch (cb % 4) {
    case 3:
      ul |= (((ULONG)(*pb++)) << 16);
      /* fall through */
    case 2:
      ul |= (((ULONG)(*pb++)) <<  8);
      /* fall through */
    case 1:
      ul |= *pb;
      /* fall through */
    default:
      break;
  }
  csum ^= ul;
 
  return csum;
}

Referenced by write_data_blocks().

FCIAddFile()

BOOL __cdecl FCIAddFile	(	HFCI	hfci,
		char *	pszSourceFile,
		char *	pszFileName,
		BOOL	fExecute,
		PFNFCIGETNEXTCABINET	pfnfcignc,
		PFNFCISTATUS	pfnfcis,
		PFNFCIGETOPENINFO	pfnfcigoi,
		TCOMP	typeCompress
	)

Definition at line 1389 of file fci.c.

{
  cab_ULONG read_result;
  FCI_Int *p_fci_internal = get_fci_ptr( hfci );
 
  if (!p_fci_internal) return FALSE;
 
  if ((!pszSourceFile) || (!pszFileName) || (!pfnfcignc) || (!pfnfcis) ||
      (!pfnfcigoi) || strlen(pszFileName)>=CB_MAX_FILENAME) {
    set_error( p_fci_internal, FCIERR_NONE, ERROR_BAD_ARGUMENTS );
    return FALSE;
  }
 
  if (typeCompress != p_fci_internal->compression)
  {
      if (!FCIFlushFolder( hfci, pfnfcignc, pfnfcis )) return FALSE;
      switch (typeCompress)
      {
      case tcompTYPE_MSZIP:
          p_fci_internal->compression = tcompTYPE_MSZIP;
          p_fci_internal->compress    = compress_MSZIP;
          break;
      default:
          FIXME( "compression %x not supported, defaulting to none\n", typeCompress );
          /* fall through */
      case tcompTYPE_NONE:
          p_fci_internal->compression = tcompTYPE_NONE;
          p_fci_internal->compress    = compress_NONE;
          break;
      }
  }
 
  /* TODO check if pszSourceFile??? */
 
  if(p_fci_internal->fGetNextCabInVain && p_fci_internal->fNextCab) {
    /* internal error */
    set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
    return FALSE;
  }
 
  if(p_fci_internal->fNextCab) {
    /* internal error */
    set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
    return FALSE;
  }
 
  /* REUSE the variable read_result */
  read_result=get_header_size( p_fci_internal ) + p_fci_internal->ccab.cbReserveCFFolder;
 
  read_result+= sizeof(CFFILE) + strlen(pszFileName)+1 +
    p_fci_internal->files_size + p_fci_internal->folders_data_size +
    p_fci_internal->placed_files_size + p_fci_internal->folders_size +
    sizeof(CFFOLDER); /* size of new CFFolder entry */
 
  /* Might be too much data for the maximum size of a cabinet.*/
  /* When any further data will be added later, it might not */
  /* be possible to flush the cabinet, because there might */
  /* not be enough space to store the name of the following */
  /* cabinet and name of the corresponding disk. */
  /* So take care of this and get the name of the next cabinet */
  if( p_fci_internal->fGetNextCabInVain==FALSE &&
      p_fci_internal->fNextCab==FALSE &&
      ( p_fci_internal->ccab.cb < read_result +
        CB_MAX_CABINET_NAME + CB_MAX_DISK_NAME
      )
  ) {
    /* increment cabinet index */
    ++(p_fci_internal->pccab->iCab);
    /* get name of next cabinet */
    p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
    if (!(*pfnfcignc)(p_fci_internal->pccab,
        p_fci_internal->estimatedCabinetSize, /* estimated size of cab */
        p_fci_internal->pv)) {
      /* error handling */
      set_error( p_fci_internal, FCIERR_NONE, ERROR_FUNCTION_FAILED );
      return FALSE;
    }
    /* Skip a few lines of code. This is caught by the next if. */
    p_fci_internal->fGetNextCabInVain=TRUE;
  }
 
  if( p_fci_internal->fGetNextCabInVain &&
      p_fci_internal->fNextCab
  ) {
    /* THIS CAN NEVER HAPPEN */
    /* set error code */
    set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
    return FALSE;
  }
 
  /* too much data for cabinet */
  if( p_fci_internal->fGetNextCabInVain &&
     (
      p_fci_internal->ccab.cb < read_result +
      strlen(p_fci_internal->pccab->szCab)+1+
      strlen(p_fci_internal->pccab->szDisk)+1
  )) {
    p_fci_internal->fGetNextCabInVain=FALSE;
    p_fci_internal->fNextCab=TRUE;
    if(!fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis)) return FALSE;
  }
 
  if( p_fci_internal->fNextCab ) {
    /* THIS MAY NEVER HAPPEN */
    /* set error code */
    set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
    return FALSE;
  }
 
  if (!add_file_data( p_fci_internal, pszSourceFile, pszFileName, fExecute, pfnfcigoi, pfnfcis ))
      return FALSE;
 
  /* REUSE the variable read_result */
  read_result = get_header_size( p_fci_internal ) + p_fci_internal->ccab.cbReserveCFFolder;
  read_result+= p_fci_internal->pending_data_size +
    p_fci_internal->files_size + p_fci_internal->folders_data_size +
    p_fci_internal->placed_files_size + p_fci_internal->folders_size +
    sizeof(CFFOLDER); /* set size of new CFFolder entry */
 
  /* too much data for the maximum size of a cabinet */
  /* (ignoring the unflushed data block) */
  if( p_fci_internal->fGetNextCabInVain==FALSE &&
      p_fci_internal->fNextCab==FALSE && /* this is always the case */
      p_fci_internal->ccab.cb < read_result ) {
    return fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis);
  }
 
  /* Might be too much data for the maximum size of a cabinet.*/
  /* When any further data will be added later, it might not */
  /* be possible to flush the cabinet, because there might */
  /* not be enough space to store the name of the following */
  /* cabinet and name of the corresponding disk. */
  /* So take care of this and get the name of the next cabinet */
  /* (ignoring the unflushed data block) */
  if( p_fci_internal->fGetNextCabInVain==FALSE &&
      p_fci_internal->fNextCab==FALSE &&
      ( p_fci_internal->ccab.cb < read_result +
        CB_MAX_CABINET_NAME + CB_MAX_DISK_NAME
      )
  ) {
    /* increment cabinet index */
    ++(p_fci_internal->pccab->iCab);
    /* get name of next cabinet */
    p_fci_internal->estimatedCabinetSize=p_fci_internal->statusFolderTotal;
    if (!(*pfnfcignc)(p_fci_internal->pccab,
        p_fci_internal->estimatedCabinetSize,/* estimated size of cab */
        p_fci_internal->pv)) {
      /* error handling */
      set_error( p_fci_internal, FCIERR_NONE, ERROR_FUNCTION_FAILED );
      return FALSE;
    }
    /* Skip a few lines of code. This is caught by the next if. */
    p_fci_internal->fGetNextCabInVain=TRUE;
  }
 
  if( p_fci_internal->fGetNextCabInVain &&
      p_fci_internal->fNextCab
  ) {
    /* THIS CAN NEVER HAPPEN */
    set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
    return FALSE;
  }
 
  /* too much data for cabinet */
  if( (p_fci_internal->fGetNextCabInVain ||
      p_fci_internal->fNextCab) && (
      p_fci_internal->ccab.cb < read_result +
      strlen(p_fci_internal->pccab->szCab)+1+
      strlen(p_fci_internal->pccab->szDisk)+1
  )) {
 
    p_fci_internal->fGetNextCabInVain=FALSE;
    p_fci_internal->fNextCab=TRUE;
    return fci_flush_cabinet( p_fci_internal, FALSE, pfnfcignc, pfnfcis);
  }
 
  if( p_fci_internal->fNextCab ) {
    /* THIS MAY NEVER HAPPEN */
    /* set error code */
    set_error( p_fci_internal, FCIERR_NONE, ERROR_GEN_FAILURE );
    return FALSE;
  }
 
  /* if the FolderThreshold has been reached flush the folder automatically */
  if (p_fci_internal->cCompressedBytesInFolder >= p_fci_internal->ccab.cbFolderThresh)
      return FCIFlushFolder(hfci, pfnfcignc, pfnfcis);
 
  return TRUE;
} /* end of FCIAddFile */

Referenced by add_file().

FCICreate()

HFCI __cdecl FCICreate	(	PERF	perf,
		PFNFCIFILEPLACED	pfnfiledest,
		PFNFCIALLOC	pfnalloc,
		PFNFCIFREE	pfnfree,
		PFNFCIOPEN	pfnopen,
		PFNFCIREAD	pfnread,
		PFNFCIWRITE	pfnwrite,
		PFNFCICLOSE	pfnclose,
		PFNFCISEEK	pfnseek,
		PFNFCIDELETE	pfndelete,
		PFNFCIGETTEMPFILE	pfnfcigtf,
		PCCAB	pccab,
		void *	pv
	)

Definition at line 990 of file fci.c.

{
  FCI_Int *p_fci_internal;
 
  if (!perf) {
    SetLastError(ERROR_BAD_ARGUMENTS);
    return NULL;
  }
  if ((!pfnalloc) || (!pfnfree) || (!pfnopen) || (!pfnread) ||
      (!pfnwrite) || (!pfnclose) || (!pfnseek) || (!pfndelete) ||
      (!pfnfcigtf) || (!pccab)) {
    perf->erfOper = FCIERR_NONE;
    perf->erfType = ERROR_BAD_ARGUMENTS;
    perf->fError = TRUE;
 
    SetLastError(ERROR_BAD_ARGUMENTS);
    return NULL;
  }
 
  if (!((p_fci_internal = pfnalloc(sizeof(FCI_Int))))) {
    perf->erfOper = FCIERR_ALLOC_FAIL;
    perf->erfType = ERROR_NOT_ENOUGH_MEMORY;
    perf->fError = TRUE;
 
    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    return NULL;
  }
 
  memset(p_fci_internal, 0, sizeof(FCI_Int));
  p_fci_internal->magic = FCI_INT_MAGIC;
  p_fci_internal->perf = perf;
  p_fci_internal->fileplaced = pfnfiledest;
  p_fci_internal->alloc = pfnalloc;
  p_fci_internal->free = pfnfree;
  p_fci_internal->open = pfnopen;
  p_fci_internal->read = pfnread;
  p_fci_internal->write = pfnwrite;
  p_fci_internal->close = pfnclose;
  p_fci_internal->seek = pfnseek;
  p_fci_internal->delete = pfndelete;
  p_fci_internal->gettemp = pfnfcigtf;
  p_fci_internal->ccab = *pccab;
  p_fci_internal->pccab = pccab;
  p_fci_internal->pv = pv;
  p_fci_internal->data.handle = -1;
  p_fci_internal->compress = compress_NONE;
 
  list_init( &p_fci_internal->folders_list );
  list_init( &p_fci_internal->files_list );
  list_init( &p_fci_internal->blocks_list );
 
  memcpy(p_fci_internal->szPrevCab, pccab->szCab, CB_MAX_CABINET_NAME);
  memcpy(p_fci_internal->szPrevDisk, pccab->szDisk, CB_MAX_DISK_NAME);
 
  return (HFCI)p_fci_internal;
}

Referenced by create_cab_file(), create_cc_test_files(), and test_FDICopy().

FCIDestroy()

BOOL __cdecl FCIDestroy

(

HFCI

hfci

)

Definition at line 1699 of file fci.c.

{
    struct folder *folder, *folder_next;
    struct file *file, *file_next;
    struct data_block *block, *block_next;
    FCI_Int *p_fci_internal = get_fci_ptr( hfci );
 
    if (!p_fci_internal) return FALSE;
 
    /* before hfci can be removed all temporary files must be closed */
    /* and deleted */
    p_fci_internal->magic = 0;
 
    LIST_FOR_EACH_ENTRY_SAFE( folder, folder_next, &p_fci_internal->folders_list, struct folder, entry )
    {
        free_folder( p_fci_internal, folder );
    }
    LIST_FOR_EACH_ENTRY_SAFE( file, file_next, &p_fci_internal->files_list, struct file, entry )
    {
        free_file( p_fci_internal, file );
    }
    LIST_FOR_EACH_ENTRY_SAFE( block, block_next, &p_fci_internal->blocks_list, struct data_block, entry )
    {
        free_data_block( p_fci_internal, block );
    }
 
    close_temp_file( p_fci_internal, &p_fci_internal->data );
 
    /* hfci can now be removed */
    p_fci_internal->free(hfci);
    return TRUE;
}

Referenced by create_cab_file(), create_cc_test_files(), and test_FDICopy().

FCIFlushCabinet()

BOOL __cdecl FCIFlushCabinet	(	HFCI	hfci,
		BOOL	fGetNextCab,
		PFNFCIGETNEXTCABINET	pfnfcignc,
		PFNFCISTATUS	pfnfcis
	)

Definition at line 1665 of file fci.c.

{
  FCI_Int *p_fci_internal = get_fci_ptr( hfci );
 
  if (!p_fci_internal) return FALSE;
 
  if(!fci_flush_cabinet(p_fci_internal,fGetNextCab,pfnfcignc,pfnfcis)) return FALSE;
 
  while( p_fci_internal->files_size>0 ||
         p_fci_internal->placed_files_size>0 ) {
    if(!fci_flush_cabinet(p_fci_internal,fGetNextCab,pfnfcignc,pfnfcis)) return FALSE;
  }
 
  return TRUE;
}

Referenced by create_cab_file(), create_cc_test_files(), and test_FDICopy().

FCIFlushFolder()

BOOL __cdecl FCIFlushFolder	(	HFCI	hfci,
		PFNFCIGETNEXTCABINET	pfnfcignc,
		PFNFCISTATUS	pfnfcis
	)

Definition at line 1621 of file fci.c.

{
    FCI_Int *p_fci_internal = get_fci_ptr( hfci );
 
    if (!p_fci_internal) return FALSE;
    return fci_flush_folder(p_fci_internal,FALSE,pfnfcignc,pfnfcis);
}

Referenced by FCIAddFile().

free_data_block()

static void free_data_block ( FCI_Int *  fci, struct data_block *  block  )

static

Definition at line 386 of file fci.c.

{
    list_remove( &block->entry );
    fci->free( block );
}

Referenced by add_data_to_folder(), FCIDestroy(), and free_folder().

free_file()

static void free_file ( FCI_Int *  fci, struct file *  file  )

static

Definition at line 302 of file fci.c.

{
    list_remove( &file->entry );
    fci->free( file );
}

Referenced by add_file_data(), FCIDestroy(), and free_folder().

free_folder()

static void free_folder ( FCI_Int *  fci, struct folder *  folder  )

static

Definition at line 413 of file fci.c.

{
    struct file *file, *file_next;
    struct data_block *block, *block_next;
 
    LIST_FOR_EACH_ENTRY_SAFE( file, file_next, &folder->files_list, struct file, entry )
        free_file( fci, file );
    LIST_FOR_EACH_ENTRY_SAFE( block, block_next, &folder->blocks_list, struct data_block, entry )
        free_data_block( fci, block );
    close_temp_file( fci, &folder->data );
    list_remove( &folder->entry );
    fci->free( folder );
}

Referenced by FCIDestroy(), and reset_cabinet().

get_fci_ptr()

static FCI_Int * get_fci_ptr ( HFCI  hfci )

static

Definition at line 200 of file fci.c.

{
    FCI_Int *fci= (FCI_Int *)hfci;
 
    if (!fci || fci->magic != FCI_INT_MAGIC)
    {
        SetLastError( ERROR_INVALID_HANDLE );
        return NULL;
    }
    return fci;
}

Referenced by FCIAddFile(), FCIDestroy(), FCIFlushCabinet(), and FCIFlushFolder().

get_header_size()

static cab_ULONG get_header_size ( FCI_Int *  fci )

static

Definition at line 213 of file fci.c.

{
    cab_ULONG ret = sizeof(CFHEADER) + fci->ccab.cbReserveCFHeader;
 
    if (fci->ccab.cbReserveCFHeader || fci->ccab.cbReserveCFFolder || fci->ccab.cbReserveCFData)
        ret += 4;
 
    if (fci->fPrevCab)
        ret += strlen( fci->szPrevCab ) + 1 + strlen( fci->szPrevDisk ) + 1;
 
    if (fci->fNextCab)
        ret += strlen( fci->pccab->szCab ) + 1 + strlen( fci->pccab->szDisk ) + 1;
 
    return ret;
}

Referenced by add_data_to_folder(), fci_flush_cabinet(), fci_flush_folder(), FCIAddFile(), and write_cabinet().

reset_cabinet()

static void reset_cabinet ( FCI_Int *  fci )

static

Definition at line 428 of file fci.c.

{
    struct folder *folder, *folder_next;
 
    LIST_FOR_EACH_ENTRY_SAFE( folder, folder_next, &fci->folders_list, struct folder, entry )
        free_folder( fci, folder );
 
    fci->cFolders          = 0;
    fci->cFiles            = 0;
    fci->folders_size      = 0;
    fci->placed_files_size = 0;
    fci->folders_data_size = 0;
}

Referenced by write_cabinet().

set_error()

static void set_error ( FCI_Int *  fci, int  oper, int  err  )

static

Definition at line 192 of file fci.c.

{
    fci->perf->erfOper = oper;
    fci->perf->erfType = err;
    fci->perf->fError = TRUE;
    if (err) SetLastError( err );
}

Referenced by add_data_block(), add_data_to_folder(), add_file(), add_file_data(), add_folder(), close_temp_file(), compress_MSZIP(), copy_data_blocks(), copy_file(), create_temp_file(), fci_flush_cabinet(), fci_flush_folder(), FCIAddFile(), netconn_create(), write_cabinet(), write_data_blocks(), write_files(), and write_folders().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

cabinet

)

write_cabinet()

static BOOL write_cabinet ( FCI_Int *  fci, PFNFCISTATUS  status_callback  )

static

Definition at line 645 of file fci.c.

{
    char filename[CB_MAX_CAB_PATH + CB_MAX_CABINET_NAME];
    int err;
    char *ptr;
    INT_PTR handle;
    CFHEADER *cfheader = (CFHEADER *)fci->data_out;
    cab_UWORD flags = 0;
    cab_ULONG header_size = get_header_size( fci );
    cab_ULONG total_size = header_size + fci->folders_size +
                           fci->placed_files_size + fci->folders_data_size;
 
    assert( header_size <= sizeof(fci->data_out) );
    memset( cfheader, 0, header_size );
 
    if (fci->fPrevCab) flags |= cfheadPREV_CABINET;
    if (fci->fNextCab) flags |= cfheadNEXT_CABINET;
    if (fci->ccab.cbReserveCFHeader || fci->ccab.cbReserveCFFolder || fci->ccab.cbReserveCFData)
      flags |= cfheadRESERVE_PRESENT;
 
    memcpy( cfheader->signature, "!CAB", 4 );
    cfheader->cbCabinet    = fci_endian_ulong( total_size );
    cfheader->coffFiles    = fci_endian_ulong( header_size + fci->folders_size );
    cfheader->versionMinor = 3;
    cfheader->versionMajor = 1;
    cfheader->cFolders     = fci_endian_uword( fci->cFolders );
    cfheader->cFiles       = fci_endian_uword( fci->cFiles );
    cfheader->flags        = fci_endian_uword( flags );
    cfheader->setID        = fci_endian_uword( fci->ccab.setID );
    cfheader->iCabinet     = fci_endian_uword( fci->ccab.iCab );
    ptr = (char *)(cfheader + 1);
 
    if (flags & cfheadRESERVE_PRESENT)
    {
        struct
        {
            cab_UWORD cbCFHeader;
            cab_UBYTE cbCFFolder;
            cab_UBYTE cbCFData;
        } *reserve = (void *)ptr;
 
        reserve->cbCFHeader = fci_endian_uword( fci->ccab.cbReserveCFHeader );
        reserve->cbCFFolder = fci->ccab.cbReserveCFFolder;
        reserve->cbCFData   = fci->ccab.cbReserveCFData;
        ptr = (char *)(reserve + 1);
    }
    ptr += fci->ccab.cbReserveCFHeader;
 
    if (flags & cfheadPREV_CABINET)
    {
        strcpy( ptr, fci->szPrevCab );
        ptr += strlen( ptr ) + 1;
        strcpy( ptr, fci->szPrevDisk );
        ptr += strlen( ptr ) + 1;
    }
 
    if (flags & cfheadNEXT_CABINET)
    {
        strcpy( ptr, fci->pccab->szCab );
        ptr += strlen( ptr ) + 1;
        strcpy( ptr, fci->pccab->szDisk );
        ptr += strlen( ptr ) + 1;
    }
 
    assert( ptr - (char *)cfheader == header_size );
 
    strcpy( filename, fci->ccab.szCabPath );
    strcat( filename, fci->ccab.szCab );
 
    if ((handle = fci->open( filename, _O_RDWR | _O_CREAT | _O_TRUNC | _O_BINARY,
                             _S_IREAD | _S_IWRITE, &err, fci->pv )) == -1)
    {
        set_error( fci, FCIERR_CAB_FILE, err );
        return FALSE;
    }
 
    if (fci->write( handle, cfheader, header_size, &err, fci->pv ) != header_size)
    {
        set_error( fci, FCIERR_CAB_FILE, err );
        goto failed;
    }
 
    /* add size of header size of all CFFOLDERs and size of all CFFILEs */
    header_size += fci->placed_files_size + fci->folders_size;
    if (!write_folders( fci, handle, header_size, status_callback )) goto failed;
    if (!write_files( fci, handle, status_callback )) goto failed;
    if (!write_data_blocks( fci, handle, status_callback )) goto failed;
 
    /* update the signature */
    if (fci->seek( handle, 0, SEEK_SET, &err, fci->pv ) != 0 )
    {
        set_error( fci, FCIERR_CAB_FILE, err );
        goto failed;
    }
    memcpy( cfheader->signature, "MSCF", 4 );
    if (fci->write( handle, cfheader->signature, 4, &err, fci->pv ) != 4)
    {
        set_error( fci, FCIERR_CAB_FILE, err );
        goto failed;
    }
    fci->close( handle, &err, fci->pv );
 
    reset_cabinet( fci );
    status_callback( statusCabinet, fci->estimatedCabinetSize, total_size, fci->pv );
    return TRUE;
 
failed:
    fci->close( handle, &err, fci->pv );
    fci->delete( filename, &err, fci->pv );
    return FALSE;
}

Referenced by fci_flush_cabinet().

write_data_blocks()

static BOOL write_data_blocks ( FCI_Int *  fci, INT_PTR  handle, PFNFCISTATUS  status_callback  )

static

Definition at line 595 of file fci.c.

{
    struct folder *folder;
    struct data_block *block;
    int err, len;
    CFDATA *cfdata;
    void *data;
    cab_UWORD header_size;
 
    header_size = sizeof(CFDATA) + fci->ccab.cbReserveCFData;
    cfdata = (CFDATA *)fci->data_out;
    memset( cfdata, 0, header_size );
    data = (char *)cfdata + header_size;
 
    LIST_FOR_EACH_ENTRY( folder, &fci->folders_list, struct folder, entry )
    {
        if (fci->seek( folder->data.handle, 0, SEEK_SET, &err, fci->pv ) != 0)
        {
            set_error( fci, FCIERR_CAB_FILE, err );
            return FALSE;
        }
        LIST_FOR_EACH_ENTRY( block, &folder->blocks_list, struct data_block, entry )
        {
            len = fci->read( folder->data.handle, data, block->compressed, &err, fci->pv );
            if (len != block->compressed) return FALSE;
 
            cfdata->cbData = fci_endian_uword( block->compressed );
            cfdata->cbUncomp = fci_endian_uword( block->uncompressed );
            cfdata->csum = fci_endian_ulong( fci_get_checksum( &cfdata->cbData,
                                                               header_size - FIELD_OFFSET(CFDATA, cbData),
                                                               fci_get_checksum( data, len, 0 )));
 
            fci->statusFolderCopied += len;
            len += header_size;
            if (fci->write( handle, fci->data_out, len, &err, fci->pv ) != len)
            {
                set_error( fci, FCIERR_CAB_FILE, err );
                return FALSE;
            }
            if (status_callback( statusFolder, fci->statusFolderCopied, fci->statusFolderTotal, fci->pv) == -1)
            {
                set_error( fci, FCIERR_USER_ABORT, 0 );
                return FALSE;
            }
        }
    }
    return TRUE;
}

Referenced by write_cabinet().

write_files()

static BOOL write_files ( FCI_Int *  fci, INT_PTR  handle, PFNFCISTATUS  status_callback  )

static

Definition at line 550 of file fci.c.

{
    cab_ULONG file_size;
    struct folder *folder;
    struct file *file;
    int err;
    CFFILE *cffile = (CFFILE *)fci->data_out;
 
    LIST_FOR_EACH_ENTRY( folder, &fci->folders_list, struct folder, entry )
    {
        LIST_FOR_EACH_ENTRY( file, &folder->files_list, struct file, entry )
        {
            cffile->cbFile          = fci_endian_ulong( file->size );
            cffile->uoffFolderStart = fci_endian_ulong( file->offset );
            cffile->iFolder         = fci_endian_uword( file->folder );
            cffile->date            = fci_endian_uword( file->date );
            cffile->time            = fci_endian_uword( file->time );
            cffile->attribs         = fci_endian_uword( file->attribs );
            lstrcpynA( (char *)(cffile + 1), file->name, CB_MAX_FILENAME );
            file_size = sizeof(CFFILE) + strlen( (char *)(cffile + 1) ) + 1;
            if (fci->write( handle, cffile, file_size, &err, fci->pv ) != file_size)
            {
                set_error( fci, FCIERR_CAB_FILE, err );
                return FALSE;
            }
            if (!fci->fSplitFolder)
            {
                fci->statusFolderCopied = 0;
                /* TODO TEST THIS further */
                fci->statusFolderTotal = fci->folders_data_size + fci->placed_files_size;
            }
            fci->statusFolderCopied += file_size;
            /* report status about copied size of folder */
            if (status_callback( statusFolder, fci->statusFolderCopied,
                                 fci->statusFolderTotal, fci->pv ) == -1)
            {
                set_error( fci, FCIERR_USER_ABORT, 0 );
                return FALSE;
            }
        }
    }
    return TRUE;
}

Referenced by write_cabinet().

write_folders()

static BOOL write_folders ( FCI_Int *  fci, INT_PTR  handle, cab_ULONG  header_size, PFNFCISTATUS  status_callback  )

static

Definition at line 525 of file fci.c.

{
    struct folder *folder;
    int err;
    CFFOLDER *cffolder = (CFFOLDER *)fci->data_out;
    cab_ULONG folder_size = sizeof(CFFOLDER) + fci->ccab.cbReserveCFFolder;
 
    memset( cffolder, 0, folder_size );
 
    /* write the folders */
    LIST_FOR_EACH_ENTRY( folder, &fci->folders_list, struct folder, entry )
    {
        cffolder->coffCabStart = fci_endian_ulong( folder->data_start + header_size );
        cffolder->cCFData      = fci_endian_uword( folder->data_count );
        cffolder->typeCompress = fci_endian_uword( folder->compression );
        if (fci->write( handle, cffolder, folder_size, &err, fci->pv ) != folder_size)
        {
            set_error( fci, FCIERR_CAB_FILE, err );
            return FALSE;
        }
    }
    return TRUE;
}

Referenced by write_cabinet().

zalloc()

static void * zalloc ( void *  opaque, unsigned int  items, unsigned int  size  )

static

Definition at line 908 of file fci.c.

{
    FCI_Int *fci = opaque;
    return fci->alloc( items * size );
}

Referenced by compress_MSZIP().

zfree()

static void zfree ( void *  opaque, void *  ptr  )

static

Definition at line 914 of file fci.c.

{
    FCI_Int *fci = opaque;
    fci->free( ptr );
}

Referenced by compress_MSZIP().