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