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