← Back to branch summary

~ubuntu-branches/debian/jessie/smplayer/jessie

« back to all changes in this revision

Viewing changes to src/findsubtitles/quazip/zip.c

  • Committer: Package Import Robot
  • Author(s): Alessio Treglia
  • Date: 2013-10-08 12:51:23 UTC
  • mfrom: (1.3.1) (21.1.2 experimental)
  • Revision ID: package-import@ubuntu.com-20131008125123-b3n39yi2i7dxvq5p
Tags: 0.8.6-1
* Team upload.
* Upload to unstable.
* New upstream release.
* Refresh patches.
* Fix VCS urls to meet the canonical form.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/findsubtitles/quazip/zip.c
1
 
/* zip.c -- IO on .zip files using zlib
2
 
   Version 1.01e, February 12th, 2005
3
 
 
4
 
   27 Dec 2004 Rolf Kalbermatter
5
 
   Modification to zipOpen2 to support globalComment retrieval.
6
 
 
7
 
   Copyright (C) 1998-2005 Gilles Vollant
8
 
 
9
 
   Read zip.h for more info
10
 
*/
11
 
 
12
 
 
13
 
#include <stdio.h>
14
 
#include <stdlib.h>
15
 
#include <string.h>
16
 
#include <time.h>
17
 
#include "zlib.h"
18
 
#include "zip.h"
19
 
 
20
 
#ifdef STDC
21
 
#  include <stddef.h>
22
 
#  include <string.h>
23
 
#  include <stdlib.h>
24
 
#endif
25
 
#ifdef NO_ERRNO_H
26
 
    extern int errno;
27
 
#else
28
 
#   include <errno.h>
29
 
#endif
30
 
 
31
 
 
32
 
#ifndef local
33
 
#  define local static
34
 
#endif
35
 
/* compile with -Dlocal if your debugger can't find static symbols */
36
 
 
37
 
#ifndef VERSIONMADEBY
38
 
# define VERSIONMADEBY   (0x0) /* platform depedent */
39
 
#endif
40
 
 
41
 
#ifndef Z_BUFSIZE
42
 
#define Z_BUFSIZE (16384)
43
 
#endif
44
 
 
45
 
#ifndef Z_MAXFILENAMEINZIP
46
 
#define Z_MAXFILENAMEINZIP (256)
47
 
#endif
48
 
 
49
 
#ifndef ALLOC
50
 
# define ALLOC(size) (malloc(size))
51
 
#endif
52
 
#ifndef TRYFREE
53
 
# define TRYFREE(p) {if (p) free(p);}
54
 
#endif
55
 
 
56
 
/*
57
 
#define SIZECENTRALDIRITEM (0x2e)
58
 
#define SIZEZIPLOCALHEADER (0x1e)
59
 
*/
60
 
 
61
 
/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
62
 
 
63
 
#ifndef SEEK_CUR
64
 
#define SEEK_CUR    1
65
 
#endif
66
 
 
67
 
#ifndef SEEK_END
68
 
#define SEEK_END    2
69
 
#endif
70
 
 
71
 
#ifndef SEEK_SET
72
 
#define SEEK_SET    0
73
 
#endif
74
 
 
75
 
#ifndef DEF_MEM_LEVEL
76
 
#if MAX_MEM_LEVEL >= 8
77
 
#  define DEF_MEM_LEVEL 8
78
 
#else
79
 
#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
80
 
#endif
81
 
#endif
82
 
const char zip_copyright[] =
83
 
   " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
84
 
 
85
 
 
86
 
#define SIZEDATA_INDATABLOCK (4096-(4*4))
87
 
 
88
 
#define LOCALHEADERMAGIC    (0x04034b50)
89
 
#define CENTRALHEADERMAGIC  (0x02014b50)
90
 
#define ENDHEADERMAGIC      (0x06054b50)
91
 
 
92
 
#define FLAG_LOCALHEADER_OFFSET (0x06)
93
 
#define CRC_LOCALHEADER_OFFSET  (0x0e)
94
 
 
95
 
#define SIZECENTRALHEADER (0x2e) /* 46 */
96
 
 
97
 
typedef struct linkedlist_datablock_internal_s
98
 
{
99
 
  struct linkedlist_datablock_internal_s* next_datablock;
100
 
  uLong  avail_in_this_block;
101
 
  uLong  filled_in_this_block;
102
 
  uLong  unused; /* for future use and alignement */
103
 
  unsigned char data[SIZEDATA_INDATABLOCK];
104
 
} linkedlist_datablock_internal;
105
 
 
106
 
typedef struct linkedlist_data_s
107
 
{
108
 
    linkedlist_datablock_internal* first_block;
109
 
    linkedlist_datablock_internal* last_block;
110
 
} linkedlist_data;
111
 
 
112
 
 
113
 
typedef struct
114
 
{
115
 
    z_stream stream;            /* zLib stream structure for inflate */
116
 
    int  stream_initialised;    /* 1 is stream is initialised */
117
 
    uInt pos_in_buffered_data;  /* last written byte in buffered_data */
118
 
 
119
 
    uLong pos_local_header;     /* offset of the local header of the file
120
 
                                     currenty writing */
121
 
    char* central_header;       /* central header data for the current file */
122
 
    uLong size_centralheader;   /* size of the central header for cur file */
123
 
    uLong flag;                 /* flag of the file currently writing */
124
 
 
125
 
    int  method;                /* compression method of file currenty wr.*/
126
 
    int  raw;                   /* 1 for directly writing raw data */
127
 
    Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
128
 
    uLong dosDate;
129
 
    uLong crc32;
130
 
    int  encrypt;
131
 
#ifndef NOCRYPT
132
 
    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
133
 
    const unsigned long* pcrc_32_tab;
134
 
    int crypt_header_size;
135
 
#endif
136
 
} curfile_info;
137
 
 
138
 
typedef struct
139
 
{
140
 
    zlib_filefunc_def z_filefunc;
141
 
    voidpf filestream;        /* io structore of the zipfile */
142
 
    linkedlist_data central_dir;/* datablock with central dir in construction*/
143
 
    int  in_opened_file_inzip;  /* 1 if a file in the zip is currently writ.*/
144
 
    curfile_info ci;            /* info on the file curretly writing */
145
 
 
146
 
    uLong begin_pos;            /* position of the beginning of the zipfile */
147
 
    uLong add_position_when_writting_offset;
148
 
    uLong number_entry;
149
 
#ifndef NO_ADDFILEINEXISTINGZIP
150
 
    char *globalcomment;
151
 
#endif
152
 
} zip_internal;
153
 
 
154
 
 
155
 
 
156
 
#ifndef NOCRYPT
157
 
#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
158
 
#include "crypt.h"
159
 
#endif
160
 
 
161
 
local linkedlist_datablock_internal* allocate_new_datablock()
162
 
{
163
 
    linkedlist_datablock_internal* ldi;
164
 
    ldi = (linkedlist_datablock_internal*)
165
 
                 ALLOC(sizeof(linkedlist_datablock_internal));
166
 
    if (ldi!=NULL)
167
 
    {
168
 
        ldi->next_datablock = NULL ;
169
 
        ldi->filled_in_this_block = 0 ;
170
 
        ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
171
 
    }
172
 
    return ldi;
173
 
}
174
 
 
175
 
local void free_datablock(ldi)
176
 
    linkedlist_datablock_internal* ldi;
177
 
{
178
 
    while (ldi!=NULL)
179
 
    {
180
 
        linkedlist_datablock_internal* ldinext = ldi->next_datablock;
181
 
        TRYFREE(ldi);
182
 
        ldi = ldinext;
183
 
    }
184
 
}
185
 
 
186
 
local void init_linkedlist(ll)
187
 
    linkedlist_data* ll;
188
 
{
189
 
    ll->first_block = ll->last_block = NULL;
190
 
}
191
 
 
192
 
#if 0 // unused
193
 
local void free_linkedlist(ll)
194
 
    linkedlist_data* ll;
195
 
{
196
 
    free_datablock(ll->first_block);
197
 
    ll->first_block = ll->last_block = NULL;
198
 
}
199
 
#endif
200
 
 
201
 
local int add_data_in_datablock(ll,buf,len)
202
 
    linkedlist_data* ll;
203
 
    const void* buf;
204
 
    uLong len;
205
 
{
206
 
    linkedlist_datablock_internal* ldi;
207
 
    const unsigned char* from_copy;
208
 
 
209
 
    if (ll==NULL)
210
 
        return ZIP_INTERNALERROR;
211
 
 
212
 
    if (ll->last_block == NULL)
213
 
    {
214
 
        ll->first_block = ll->last_block = allocate_new_datablock();
215
 
        if (ll->first_block == NULL)
216
 
            return ZIP_INTERNALERROR;
217
 
    }
218
 
 
219
 
    ldi = ll->last_block;
220
 
    from_copy = (unsigned char*)buf;
221
 
 
222
 
    while (len>0)
223
 
    {
224
 
        uInt copy_this;
225
 
        uInt i;
226
 
        unsigned char* to_copy;
227
 
 
228
 
        if (ldi->avail_in_this_block==0)
229
 
        {
230
 
            ldi->next_datablock = allocate_new_datablock();
231
 
            if (ldi->next_datablock == NULL)
232
 
                return ZIP_INTERNALERROR;
233
 
            ldi = ldi->next_datablock ;
234
 
            ll->last_block = ldi;
235
 
        }
236
 
 
237
 
        if (ldi->avail_in_this_block < len)
238
 
            copy_this = (uInt)ldi->avail_in_this_block;
239
 
        else
240
 
            copy_this = (uInt)len;
241
 
 
242
 
        to_copy = &(ldi->data[ldi->filled_in_this_block]);
243
 
 
244
 
        for (i=0;i<copy_this;i++)
245
 
            *(to_copy+i)=*(from_copy+i);
246
 
 
247
 
        ldi->filled_in_this_block += copy_this;
248
 
        ldi->avail_in_this_block -= copy_this;
249
 
        from_copy += copy_this ;
250
 
        len -= copy_this;
251
 
    }
252
 
    return ZIP_OK;
253
 
}
254
 
 
255
 
 
256
 
 
257
 
/****************************************************************************/
258
 
 
259
 
#ifndef NO_ADDFILEINEXISTINGZIP
260
 
/* ===========================================================================
261
 
   Inputs a long in LSB order to the given file
262
 
   nbByte == 1, 2 or 4 (byte, short or long)
263
 
*/
264
 
 
265
 
local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
266
 
                                voidpf filestream, uLong x, int nbByte));
267
 
local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
268
 
    const zlib_filefunc_def* pzlib_filefunc_def;
269
 
    voidpf filestream;
270
 
    uLong x;
271
 
    int nbByte;
272
 
{
273
 
    unsigned char buf[4];
274
 
    int n;
275
 
    for (n = 0; n < nbByte; n++)
276
 
    {
277
 
        buf[n] = (unsigned char)(x & 0xff);
278
 
        x >>= 8;
279
 
    }
280
 
    if (x != 0)
281
 
      {     /* data overflow - hack for ZIP64 (X Roche) */
282
 
      for (n = 0; n < nbByte; n++)
283
 
        {
284
 
          buf[n] = 0xff;
285
 
        }
286
 
      }
287
 
 
288
 
    if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
289
 
        return ZIP_ERRNO;
290
 
    else
291
 
        return ZIP_OK;
292
 
}
293
 
 
294
 
local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
295
 
local void ziplocal_putValue_inmemory (dest, x, nbByte)
296
 
    void* dest;
297
 
    uLong x;
298
 
    int nbByte;
299
 
{
300
 
    unsigned char* buf=(unsigned char*)dest;
301
 
    int n;
302
 
    for (n = 0; n < nbByte; n++) {
303
 
        buf[n] = (unsigned char)(x & 0xff);
304
 
        x >>= 8;
305
 
    }
306
 
 
307
 
    if (x != 0)
308
 
    {     /* data overflow - hack for ZIP64 */
309
 
       for (n = 0; n < nbByte; n++)
310
 
       {
311
 
          buf[n] = 0xff;
312
 
       }
313
 
    }
314
 
}
315
 
 
316
 
/****************************************************************************/
317
 
 
318
 
 
319
 
local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
320
 
    const tm_zip* ptm;
321
 
    uLong dosDate;
322
 
{
323
 
    (void) dosDate; /* avoid "unused parameter" warning */
324
 
    uLong year = (uLong)ptm->tm_year;
325
 
    if (year>1980)
326
 
        year-=1980;
327
 
    else if (year>80)
328
 
        year-=80;
329
 
    return
330
 
      (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
331
 
        ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
332
 
}
333
 
 
334
 
 
335
 
/****************************************************************************/
336
 
 
337
 
local int ziplocal_getByte OF((
338
 
    const zlib_filefunc_def* pzlib_filefunc_def,
339
 
    voidpf filestream,
340
 
    int *pi));
341
 
 
342
 
local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
343
 
    const zlib_filefunc_def* pzlib_filefunc_def;
344
 
    voidpf filestream;
345
 
    int *pi;
346
 
{
347
 
    unsigned char c;
348
 
    int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
349
 
    if (err==1)
350
 
    {
351
 
        *pi = (int)c;
352
 
        return ZIP_OK;
353
 
    }
354
 
    else
355
 
    {
356
 
        if (ZERROR(*pzlib_filefunc_def,filestream))
357
 
            return ZIP_ERRNO;
358
 
        else
359
 
            return ZIP_EOF;
360
 
    }
361
 
}
362
 
 
363
 
 
364
 
/* ===========================================================================
365
 
   Reads a long in LSB order from the given gz_stream. Sets
366
 
*/
367
 
local int ziplocal_getShort OF((
368
 
    const zlib_filefunc_def* pzlib_filefunc_def,
369
 
    voidpf filestream,
370
 
    uLong *pX));
371
 
 
372
 
local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
373
 
    const zlib_filefunc_def* pzlib_filefunc_def;
374
 
    voidpf filestream;
375
 
    uLong *pX;
376
 
{
377
 
    uLong x ;
378
 
    int i;
379
 
    int err;
380
 
 
381
 
    err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
382
 
    x = (uLong)i;
383
 
 
384
 
    if (err==ZIP_OK)
385
 
        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
386
 
    x += ((uLong)i)<<8;
387
 
 
388
 
    if (err==ZIP_OK)
389
 
        *pX = x;
390
 
    else
391
 
        *pX = 0;
392
 
    return err;
393
 
}
394
 
 
395
 
local int ziplocal_getLong OF((
396
 
    const zlib_filefunc_def* pzlib_filefunc_def,
397
 
    voidpf filestream,
398
 
    uLong *pX));
399
 
 
400
 
local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
401
 
    const zlib_filefunc_def* pzlib_filefunc_def;
402
 
    voidpf filestream;
403
 
    uLong *pX;
404
 
{
405
 
    uLong x ;
406
 
    int i;
407
 
    int err;
408
 
 
409
 
    err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
410
 
    x = (uLong)i;
411
 
 
412
 
    if (err==ZIP_OK)
413
 
        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
414
 
    x += ((uLong)i)<<8;
415
 
 
416
 
    if (err==ZIP_OK)
417
 
        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
418
 
    x += ((uLong)i)<<16;
419
 
 
420
 
    if (err==ZIP_OK)
421
 
        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
422
 
    x += ((uLong)i)<<24;
423
 
 
424
 
    if (err==ZIP_OK)
425
 
        *pX = x;
426
 
    else
427
 
        *pX = 0;
428
 
    return err;
429
 
}
430
 
 
431
 
#ifndef BUFREADCOMMENT
432
 
#define BUFREADCOMMENT (0x400)
433
 
#endif
434
 
/*
435
 
  Locate the Central directory of a zipfile (at the end, just before
436
 
    the global comment)
437
 
*/
438
 
local uLong ziplocal_SearchCentralDir OF((
439
 
    const zlib_filefunc_def* pzlib_filefunc_def,
440
 
    voidpf filestream));
441
 
 
442
 
local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
443
 
    const zlib_filefunc_def* pzlib_filefunc_def;
444
 
    voidpf filestream;
445
 
{
446
 
    unsigned char* buf;
447
 
    uLong uSizeFile;
448
 
    uLong uBackRead;
449
 
    uLong uMaxBack=0xffff; /* maximum size of global comment */
450
 
    uLong uPosFound=0;
451
 
 
452
 
    if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
453
 
        return 0;
454
 
 
455
 
 
456
 
    uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
457
 
 
458
 
    if (uMaxBack>uSizeFile)
459
 
        uMaxBack = uSizeFile;
460
 
 
461
 
    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
462
 
    if (buf==NULL)
463
 
        return 0;
464
 
 
465
 
    uBackRead = 4;
466
 
    while (uBackRead<uMaxBack)
467
 
    {
468
 
        uLong uReadSize,uReadPos ;
469
 
        int i;
470
 
        if (uBackRead+BUFREADCOMMENT>uMaxBack)
471
 
            uBackRead = uMaxBack;
472
 
        else
473
 
            uBackRead+=BUFREADCOMMENT;
474
 
        uReadPos = uSizeFile-uBackRead ;
475
 
 
476
 
        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
477
 
                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
478
 
        if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
479
 
            break;
480
 
 
481
 
        if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
482
 
            break;
483
 
 
484
 
        for (i=(int)uReadSize-3; (i--)>0;)
485
 
            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
486
 
                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
487
 
            {
488
 
                uPosFound = uReadPos+i;
489
 
                break;
490
 
            }
491
 
 
492
 
        if (uPosFound!=0)
493
 
            break;
494
 
    }
495
 
    TRYFREE(buf);
496
 
    return uPosFound;
497
 
}
498
 
#endif /* !NO_ADDFILEINEXISTINGZIP*/
499
 
 
500
 
/************************************************************/
501
 
extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
502
 
    const char *pathname;
503
 
    int append;
504
 
    zipcharpc* globalcomment;
505
 
    zlib_filefunc_def* pzlib_filefunc_def;
506
 
{
507
 
    zip_internal ziinit;
508
 
    zip_internal* zi;
509
 
    int err=ZIP_OK;
510
 
 
511
 
 
512
 
    if (pzlib_filefunc_def==NULL)
513
 
        fill_fopen_filefunc(&ziinit.z_filefunc);
514
 
    else
515
 
        ziinit.z_filefunc = *pzlib_filefunc_def;
516
 
 
517
 
    ziinit.filestream = (*(ziinit.z_filefunc.zopen_file))
518
 
                 (ziinit.z_filefunc.opaque,
519
 
                  pathname,
520
 
                  (append == APPEND_STATUS_CREATE) ?
521
 
                  (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
522
 
                    (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
523
 
 
524
 
    if (ziinit.filestream == NULL)
525
 
        return NULL;
526
 
    ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream);
527
 
    ziinit.in_opened_file_inzip = 0;
528
 
    ziinit.ci.stream_initialised = 0;
529
 
    ziinit.number_entry = 0;
530
 
    ziinit.add_position_when_writting_offset = 0;
531
 
    init_linkedlist(&(ziinit.central_dir));
532
 
 
533
 
 
534
 
    zi = (zip_internal*)ALLOC(sizeof(zip_internal));
535
 
    if (zi==NULL)
536
 
    {
537
 
        ZCLOSE(ziinit.z_filefunc,ziinit.filestream);
538
 
        return NULL;
539
 
    }
540
 
 
541
 
    /* now we add file in a zipfile */
542
 
#    ifndef NO_ADDFILEINEXISTINGZIP
543
 
    ziinit.globalcomment = NULL;
544
 
    if (append == APPEND_STATUS_ADDINZIP)
545
 
    {
546
 
        uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
547
 
 
548
 
        uLong size_central_dir;     /* size of the central directory  */
549
 
        uLong offset_central_dir;   /* offset of start of central directory */
550
 
        uLong central_pos,uL;
551
 
 
552
 
        uLong number_disk;          /* number of the current dist, used for
553
 
                                    spaning ZIP, unsupported, always 0*/
554
 
        uLong number_disk_with_CD;  /* number the the disk with central dir, used
555
 
                                    for spaning ZIP, unsupported, always 0*/
556
 
        uLong number_entry;
557
 
        uLong number_entry_CD;      /* total number of entries in
558
 
                                    the central dir
559
 
                                    (same than number_entry on nospan) */
560
 
        uLong size_comment;
561
 
 
562
 
        central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);
563
 
        if (central_pos==0)
564
 
            err=ZIP_ERRNO;
565
 
 
566
 
        if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
567
 
                                        central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
568
 
            err=ZIP_ERRNO;
569
 
 
570
 
        /* the signature, already checked */
571
 
        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK)
572
 
            err=ZIP_ERRNO;
573
 
 
574
 
        /* number of this disk */
575
 
        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK)
576
 
            err=ZIP_ERRNO;
577
 
 
578
 
        /* number of the disk with the start of the central directory */
579
 
        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK)
580
 
            err=ZIP_ERRNO;
581
 
 
582
 
        /* total number of entries in the central dir on this disk */
583
 
        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK)
584
 
            err=ZIP_ERRNO;
585
 
 
586
 
        /* total number of entries in the central dir */
587
 
        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK)
588
 
            err=ZIP_ERRNO;
589
 
 
590
 
        if ((number_entry_CD!=number_entry) ||
591
 
            (number_disk_with_CD!=0) ||
592
 
            (number_disk!=0))
593
 
            err=ZIP_BADZIPFILE;
594
 
 
595
 
        /* size of the central directory */
596
 
        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK)
597
 
            err=ZIP_ERRNO;
598
 
 
599
 
        /* offset of start of central directory with respect to the
600
 
            starting disk number */
601
 
        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK)
602
 
            err=ZIP_ERRNO;
603
 
 
604
 
        /* zipfile global comment length */
605
 
        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK)
606
 
            err=ZIP_ERRNO;
607
 
 
608
 
        if ((central_pos<offset_central_dir+size_central_dir) &&
609
 
            (err==ZIP_OK))
610
 
            err=ZIP_BADZIPFILE;
611
 
 
612
 
        if (err!=ZIP_OK)
613
 
        {
614
 
            ZCLOSE(ziinit.z_filefunc, ziinit.filestream);
615
 
            return NULL;
616
 
        }
617
 
 
618
 
        if (size_comment>0)
619
 
        {
620
 
            ziinit.globalcomment = ALLOC(size_comment+1);
621
 
            if (ziinit.globalcomment)
622
 
            {
623
 
               size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
624
 
               ziinit.globalcomment[size_comment]=0;
625
 
            }
626
 
        }
627
 
 
628
 
        byte_before_the_zipfile = central_pos -
629
 
                                (offset_central_dir+size_central_dir);
630
 
        ziinit.add_position_when_writting_offset = byte_before_the_zipfile;
631
 
 
632
 
        {
633
 
            uLong size_central_dir_to_read = size_central_dir;
634
 
            size_t buf_size = SIZEDATA_INDATABLOCK;
635
 
            void* buf_read = (void*)ALLOC(buf_size);
636
 
            if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
637
 
                  offset_central_dir + byte_before_the_zipfile,
638
 
                  ZLIB_FILEFUNC_SEEK_SET) != 0)
639
 
                  err=ZIP_ERRNO;
640
 
 
641
 
            while ((size_central_dir_to_read>0) && (err==ZIP_OK))
642
 
            {
643
 
                uLong read_this = SIZEDATA_INDATABLOCK;
644
 
                if (read_this > size_central_dir_to_read)
645
 
                    read_this = size_central_dir_to_read;
646
 
                if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this)
647
 
                    err=ZIP_ERRNO;
648
 
 
649
 
                if (err==ZIP_OK)
650
 
                    err = add_data_in_datablock(&ziinit.central_dir,buf_read,
651
 
                                                (uLong)read_this);
652
 
                size_central_dir_to_read-=read_this;
653
 
            }
654
 
            TRYFREE(buf_read);
655
 
        }
656
 
        ziinit.begin_pos = byte_before_the_zipfile;
657
 
        ziinit.number_entry = number_entry_CD;
658
 
 
659
 
        if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
660
 
                  offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
661
 
            err=ZIP_ERRNO;
662
 
    }
663
 
 
664
 
    if (globalcomment)
665
 
    {
666
 
      *globalcomment = ziinit.globalcomment;
667
 
    }
668
 
#    endif /* !NO_ADDFILEINEXISTINGZIP*/
669
 
 
670
 
    if (err != ZIP_OK)
671
 
    {
672
 
#    ifndef NO_ADDFILEINEXISTINGZIP
673
 
        TRYFREE(ziinit.globalcomment);
674
 
#    endif /* !NO_ADDFILEINEXISTINGZIP*/
675
 
        TRYFREE(zi);
676
 
        return NULL;
677
 
    }
678
 
    else
679
 
    {
680
 
        *zi = ziinit;
681
 
        return (zipFile)zi;
682
 
    }
683
 
}
684
 
 
685
 
extern zipFile ZEXPORT zipOpen (pathname, append)
686
 
    const char *pathname;
687
 
    int append;
688
 
{
689
 
    return zipOpen2(pathname,append,NULL,NULL);
690
 
}
691
 
 
692
 
extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
693
 
                                         extrafield_local, size_extrafield_local,
694
 
                                         extrafield_global, size_extrafield_global,
695
 
                                         comment, method, level, raw,
696
 
                                         windowBits, memLevel, strategy,
697
 
                                         password, crcForCrypting)
698
 
    zipFile file;
699
 
    const char* filename;
700
 
    const zip_fileinfo* zipfi;
701
 
    const void* extrafield_local;
702
 
    uInt size_extrafield_local;
703
 
    const void* extrafield_global;
704
 
    uInt size_extrafield_global;
705
 
    const char* comment;
706
 
    int method;
707
 
    int level;
708
 
    int raw;
709
 
    int windowBits;
710
 
    int memLevel;
711
 
    int strategy;
712
 
    const char* password;
713
 
    uLong crcForCrypting;
714
 
{
715
 
    zip_internal* zi;
716
 
    uInt size_filename;
717
 
    uInt size_comment;
718
 
    uInt i;
719
 
    int err = ZIP_OK;
720
 
 
721
 
#    ifdef NOCRYPT
722
 
    if (password != NULL)
723
 
        return ZIP_PARAMERROR;
724
 
#    endif
725
 
 
726
 
    if (file == NULL)
727
 
        return ZIP_PARAMERROR;
728
 
    if ((method!=0) && (method!=Z_DEFLATED))
729
 
        return ZIP_PARAMERROR;
730
 
 
731
 
    zi = (zip_internal*)file;
732
 
 
733
 
    if (zi->in_opened_file_inzip == 1)
734
 
    {
735
 
        err = zipCloseFileInZip (file);
736
 
        if (err != ZIP_OK)
737
 
            return err;
738
 
    }
739
 
 
740
 
 
741
 
    if (filename==NULL)
742
 
        filename="-";
743
 
 
744
 
    if (comment==NULL)
745
 
        size_comment = 0;
746
 
    else
747
 
        size_comment = (uInt)strlen(comment);
748
 
 
749
 
    size_filename = (uInt)strlen(filename);
750
 
 
751
 
    if (zipfi == NULL)
752
 
        zi->ci.dosDate = 0;
753
 
    else
754
 
    {
755
 
        if (zipfi->dosDate != 0)
756
 
            zi->ci.dosDate = zipfi->dosDate;
757
 
        else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate);
758
 
    }
759
 
 
760
 
    zi->ci.flag = 0;
761
 
    if ((level==8) || (level==9))
762
 
      zi->ci.flag |= 2;
763
 
    if ((level==2))
764
 
      zi->ci.flag |= 4;
765
 
    if ((level==1))
766
 
      zi->ci.flag |= 6;
767
 
    if (password != NULL)
768
 
      zi->ci.flag |= 1;
769
 
 
770
 
    zi->ci.crc32 = 0;
771
 
    zi->ci.method = method;
772
 
    zi->ci.encrypt = 0;
773
 
    zi->ci.stream_initialised = 0;
774
 
    zi->ci.pos_in_buffered_data = 0;
775
 
    zi->ci.raw = raw;
776
 
    zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ;
777
 
    zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename +
778
 
                                      size_extrafield_global + size_comment;
779
 
    zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader);
780
 
 
781
 
    ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
782
 
    /* version info */
783
 
    ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2);
784
 
    ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
785
 
    ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
786
 
    ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
787
 
    ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
788
 
    ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
789
 
    ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
790
 
    ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
791
 
    ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
792
 
    ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
793
 
    ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
794
 
    ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
795
 
 
796
 
    if (zipfi==NULL)
797
 
        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
798
 
    else
799
 
        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
800
 
 
801
 
    if (zipfi==NULL)
802
 
        ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
803
 
    else
804
 
        ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
805
 
 
806
 
    ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4);
807
 
 
808
 
    for (i=0;i<size_filename;i++)
809
 
        *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
810
 
 
811
 
    for (i=0;i<size_extrafield_global;i++)
812
 
        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
813
 
              *(((const char*)extrafield_global)+i);
814
 
 
815
 
    for (i=0;i<size_comment;i++)
816
 
        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
817
 
              size_extrafield_global+i) = *(comment+i);
818
 
    if (zi->ci.central_header == NULL)
819
 
        return ZIP_INTERNALERROR;
820
 
 
821
 
    /* write the local header */
822
 
    err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4);
823
 
 
824
 
    if (err==ZIP_OK)
825
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
826
 
    if (err==ZIP_OK)
827
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
828
 
 
829
 
    if (err==ZIP_OK)
830
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
831
 
 
832
 
    if (err==ZIP_OK)
833
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
834
 
 
835
 
    if (err==ZIP_OK)
836
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
837
 
    if (err==ZIP_OK)
838
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
839
 
    if (err==ZIP_OK)
840
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
841
 
 
842
 
    if (err==ZIP_OK)
843
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
844
 
 
845
 
    if (err==ZIP_OK)
846
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2);
847
 
 
848
 
    if ((err==ZIP_OK) && (size_filename>0))
849
 
        if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
850
 
                err = ZIP_ERRNO;
851
 
 
852
 
    if ((err==ZIP_OK) && (size_extrafield_local>0))
853
 
        if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local)
854
 
                                                                           !=size_extrafield_local)
855
 
                err = ZIP_ERRNO;
856
 
 
857
 
    zi->ci.stream.avail_in = (uInt)0;
858
 
    zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
859
 
    zi->ci.stream.next_out = zi->ci.buffered_data;
860
 
    zi->ci.stream.total_in = 0;
861
 
    zi->ci.stream.total_out = 0;
862
 
 
863
 
    if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
864
 
    {
865
 
        zi->ci.stream.zalloc = (alloc_func)0;
866
 
        zi->ci.stream.zfree = (free_func)0;
867
 
        zi->ci.stream.opaque = (voidpf)0;
868
 
 
869
 
        if (windowBits>0)
870
 
            windowBits = -windowBits;
871
 
 
872
 
        err = deflateInit2(&zi->ci.stream, level,
873
 
               Z_DEFLATED, windowBits, memLevel, strategy);
874
 
 
875
 
        if (err==Z_OK)
876
 
            zi->ci.stream_initialised = 1;
877
 
    }
878
 
#    ifndef NOCRYPT
879
 
    zi->ci.crypt_header_size = 0;
880
 
    if ((err==Z_OK) && (password != NULL))
881
 
    {
882
 
        unsigned char bufHead[RAND_HEAD_LEN];
883
 
        unsigned int sizeHead;
884
 
        zi->ci.encrypt = 1;
885
 
        zi->ci.pcrc_32_tab = get_crc_table();
886
 
        /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
887
 
 
888
 
        sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
889
 
        zi->ci.crypt_header_size = sizeHead;
890
 
 
891
 
        if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
892
 
                err = ZIP_ERRNO;
893
 
    }
894
 
#    endif
895
 
 
896
 
    if (err==Z_OK)
897
 
        zi->in_opened_file_inzip = 1;
898
 
    return err;
899
 
}
900
 
 
901
 
extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
902
 
                                        extrafield_local, size_extrafield_local,
903
 
                                        extrafield_global, size_extrafield_global,
904
 
                                        comment, method, level, raw)
905
 
    zipFile file;
906
 
    const char* filename;
907
 
    const zip_fileinfo* zipfi;
908
 
    const void* extrafield_local;
909
 
    uInt size_extrafield_local;
910
 
    const void* extrafield_global;
911
 
    uInt size_extrafield_global;
912
 
    const char* comment;
913
 
    int method;
914
 
    int level;
915
 
    int raw;
916
 
{
917
 
    return zipOpenNewFileInZip3 (file, filename, zipfi,
918
 
                                 extrafield_local, size_extrafield_local,
919
 
                                 extrafield_global, size_extrafield_global,
920
 
                                 comment, method, level, raw,
921
 
                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
922
 
                                 NULL, 0);
923
 
}
924
 
 
925
 
extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
926
 
                                        extrafield_local, size_extrafield_local,
927
 
                                        extrafield_global, size_extrafield_global,
928
 
                                        comment, method, level)
929
 
    zipFile file;
930
 
    const char* filename;
931
 
    const zip_fileinfo* zipfi;
932
 
    const void* extrafield_local;
933
 
    uInt size_extrafield_local;
934
 
    const void* extrafield_global;
935
 
    uInt size_extrafield_global;
936
 
    const char* comment;
937
 
    int method;
938
 
    int level;
939
 
{
940
 
    return zipOpenNewFileInZip2 (file, filename, zipfi,
941
 
                                 extrafield_local, size_extrafield_local,
942
 
                                 extrafield_global, size_extrafield_global,
943
 
                                 comment, method, level, 0);
944
 
}
945
 
 
946
 
local int zipFlushWriteBuffer(zi)
947
 
  zip_internal* zi;
948
 
{
949
 
    int err=ZIP_OK;
950
 
 
951
 
    if (zi->ci.encrypt != 0)
952
 
    {
953
 
#ifndef NOCRYPT
954
 
        uInt i;
955
 
        int t;
956
 
        for (i=0;i<zi->ci.pos_in_buffered_data;i++)
957
 
            zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
958
 
                                       zi->ci.buffered_data[i],t);
959
 
#endif
960
 
    }
961
 
    if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
962
 
                                                                    !=zi->ci.pos_in_buffered_data)
963
 
      err = ZIP_ERRNO;
964
 
    zi->ci.pos_in_buffered_data = 0;
965
 
    return err;
966
 
}
967
 
 
968
 
extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
969
 
    zipFile file;
970
 
    const void* buf;
971
 
    unsigned len;
972
 
{
973
 
    zip_internal* zi;
974
 
    int err=ZIP_OK;
975
 
 
976
 
    if (file == NULL)
977
 
        return ZIP_PARAMERROR;
978
 
    zi = (zip_internal*)file;
979
 
 
980
 
    if (zi->in_opened_file_inzip == 0)
981
 
        return ZIP_PARAMERROR;
982
 
 
983
 
    zi->ci.stream.next_in = (void*)buf;
984
 
    zi->ci.stream.avail_in = len;
985
 
    zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
986
 
 
987
 
    while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
988
 
    {
989
 
        if (zi->ci.stream.avail_out == 0)
990
 
        {
991
 
            if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
992
 
                err = ZIP_ERRNO;
993
 
            zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
994
 
            zi->ci.stream.next_out = zi->ci.buffered_data;
995
 
        }
996
 
 
997
 
 
998
 
        if(err != ZIP_OK)
999
 
            break;
1000
 
 
1001
 
        if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1002
 
        {
1003
 
            uLong uTotalOutBefore = zi->ci.stream.total_out;
1004
 
            err=deflate(&zi->ci.stream,  Z_NO_FLUSH);
1005
 
            zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1006
 
 
1007
 
        }
1008
 
        else
1009
 
        {
1010
 
            uInt copy_this,i;
1011
 
            if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
1012
 
                copy_this = zi->ci.stream.avail_in;
1013
 
            else
1014
 
                copy_this = zi->ci.stream.avail_out;
1015
 
            for (i=0;i<copy_this;i++)
1016
 
                *(((char*)zi->ci.stream.next_out)+i) =
1017
 
                    *(((const char*)zi->ci.stream.next_in)+i);
1018
 
            {
1019
 
                zi->ci.stream.avail_in -= copy_this;
1020
 
                zi->ci.stream.avail_out-= copy_this;
1021
 
                zi->ci.stream.next_in+= copy_this;
1022
 
                zi->ci.stream.next_out+= copy_this;
1023
 
                zi->ci.stream.total_in+= copy_this;
1024
 
                zi->ci.stream.total_out+= copy_this;
1025
 
                zi->ci.pos_in_buffered_data += copy_this;
1026
 
            }
1027
 
        }
1028
 
    }
1029
 
 
1030
 
    return err;
1031
 
}
1032
 
 
1033
 
extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
1034
 
    zipFile file;
1035
 
    uLong uncompressed_size;
1036
 
    uLong crc32;
1037
 
{
1038
 
    zip_internal* zi;
1039
 
    uLong compressed_size;
1040
 
    int err=ZIP_OK;
1041
 
 
1042
 
    if (file == NULL)
1043
 
        return ZIP_PARAMERROR;
1044
 
    zi = (zip_internal*)file;
1045
 
 
1046
 
    if (zi->in_opened_file_inzip == 0)
1047
 
        return ZIP_PARAMERROR;
1048
 
    zi->ci.stream.avail_in = 0;
1049
 
 
1050
 
    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1051
 
        while (err==ZIP_OK)
1052
 
    {
1053
 
        uLong uTotalOutBefore;
1054
 
        if (zi->ci.stream.avail_out == 0)
1055
 
        {
1056
 
            if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
1057
 
                err = ZIP_ERRNO;
1058
 
            zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1059
 
            zi->ci.stream.next_out = zi->ci.buffered_data;
1060
 
        }
1061
 
        uTotalOutBefore = zi->ci.stream.total_out;
1062
 
        err=deflate(&zi->ci.stream,  Z_FINISH);
1063
 
        zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1064
 
    }
1065
 
 
1066
 
    if (err==Z_STREAM_END)
1067
 
        err=ZIP_OK; /* this is normal */
1068
 
 
1069
 
    if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
1070
 
        if (zipFlushWriteBuffer(zi)==ZIP_ERRNO)
1071
 
            err = ZIP_ERRNO;
1072
 
 
1073
 
    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1074
 
    {
1075
 
        err=deflateEnd(&zi->ci.stream);
1076
 
        zi->ci.stream_initialised = 0;
1077
 
    }
1078
 
 
1079
 
    if (!zi->ci.raw)
1080
 
    {
1081
 
        crc32 = (uLong)zi->ci.crc32;
1082
 
        uncompressed_size = (uLong)zi->ci.stream.total_in;
1083
 
    }
1084
 
    compressed_size = (uLong)zi->ci.stream.total_out;
1085
 
#    ifndef NOCRYPT
1086
 
    compressed_size += zi->ci.crypt_header_size;
1087
 
#    endif
1088
 
 
1089
 
    ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
1090
 
    ziplocal_putValue_inmemory(zi->ci.central_header+20,
1091
 
                                compressed_size,4); /*compr size*/
1092
 
    if (zi->ci.stream.data_type == Z_ASCII)
1093
 
        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
1094
 
    ziplocal_putValue_inmemory(zi->ci.central_header+24,
1095
 
                                uncompressed_size,4); /*uncompr size*/
1096
 
 
1097
 
    if (err==ZIP_OK)
1098
 
        err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header,
1099
 
                                       (uLong)zi->ci.size_centralheader);
1100
 
    free(zi->ci.central_header);
1101
 
 
1102
 
    if (err==ZIP_OK)
1103
 
    {
1104
 
        long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
1105
 
        if (ZSEEK(zi->z_filefunc,zi->filestream,
1106
 
                  zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
1107
 
            err = ZIP_ERRNO;
1108
 
 
1109
 
        if (err==ZIP_OK)
1110
 
            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
1111
 
 
1112
 
        if (err==ZIP_OK) /* compressed size, unknown */
1113
 
            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
1114
 
 
1115
 
        if (err==ZIP_OK) /* uncompressed size, unknown */
1116
 
            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
1117
 
 
1118
 
        if (ZSEEK(zi->z_filefunc,zi->filestream,
1119
 
                  cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
1120
 
            err = ZIP_ERRNO;
1121
 
    }
1122
 
 
1123
 
    zi->number_entry ++;
1124
 
    zi->in_opened_file_inzip = 0;
1125
 
 
1126
 
    return err;
1127
 
}
1128
 
 
1129
 
extern int ZEXPORT zipCloseFileInZip (file)
1130
 
    zipFile file;
1131
 
{
1132
 
    return zipCloseFileInZipRaw (file,0,0);
1133
 
}
1134
 
 
1135
 
extern int ZEXPORT zipClose (file, global_comment)
1136
 
    zipFile file;
1137
 
    const char* global_comment;
1138
 
{
1139
 
    zip_internal* zi;
1140
 
    int err = 0;
1141
 
    uLong size_centraldir = 0;
1142
 
    uLong centraldir_pos_inzip;
1143
 
    uInt size_global_comment;
1144
 
    if (file == NULL)
1145
 
        return ZIP_PARAMERROR;
1146
 
    zi = (zip_internal*)file;
1147
 
 
1148
 
    if (zi->in_opened_file_inzip == 1)
1149
 
    {
1150
 
        err = zipCloseFileInZip (file);
1151
 
    }
1152
 
 
1153
 
#ifndef NO_ADDFILEINEXISTINGZIP
1154
 
    if (global_comment==NULL)
1155
 
        global_comment = zi->globalcomment;
1156
 
#endif
1157
 
    if (global_comment==NULL)
1158
 
        size_global_comment = 0;
1159
 
    else
1160
 
        size_global_comment = (uInt)strlen(global_comment);
1161
 
 
1162
 
    centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
1163
 
    if (err==ZIP_OK)
1164
 
    {
1165
 
        linkedlist_datablock_internal* ldi = zi->central_dir.first_block ;
1166
 
        while (ldi!=NULL)
1167
 
        {
1168
 
            if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
1169
 
                if (ZWRITE(zi->z_filefunc,zi->filestream,
1170
 
                           ldi->data,ldi->filled_in_this_block)
1171
 
                              !=ldi->filled_in_this_block )
1172
 
                    err = ZIP_ERRNO;
1173
 
 
1174
 
            size_centraldir += ldi->filled_in_this_block;
1175
 
            ldi = ldi->next_datablock;
1176
 
        }
1177
 
    }
1178
 
    free_datablock(zi->central_dir.first_block);
1179
 
 
1180
 
    if (err==ZIP_OK) /* Magic End */
1181
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
1182
 
 
1183
 
    if (err==ZIP_OK) /* number of this disk */
1184
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1185
 
 
1186
 
    if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1187
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1188
 
 
1189
 
    if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
1190
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1191
 
 
1192
 
    if (err==ZIP_OK) /* total number of entries in the central dir */
1193
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1194
 
 
1195
 
    if (err==ZIP_OK) /* size of the central directory */
1196
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
1197
 
 
1198
 
    if (err==ZIP_OK) /* offset of start of central directory with respect to the
1199
 
                            starting disk number */
1200
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,
1201
 
                                (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
1202
 
 
1203
 
    if (err==ZIP_OK) /* zipfile comment length */
1204
 
        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
1205
 
 
1206
 
    if ((err==ZIP_OK) && (size_global_comment>0))
1207
 
        if (ZWRITE(zi->z_filefunc,zi->filestream,
1208
 
                   global_comment,size_global_comment) != size_global_comment)
1209
 
                err = ZIP_ERRNO;
1210
 
 
1211
 
    if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0)
1212
 
        if (err == ZIP_OK)
1213
 
            err = ZIP_ERRNO;
1214
 
 
1215
 
#ifndef NO_ADDFILEINEXISTINGZIP
1216
 
    TRYFREE(zi->globalcomment);
1217
 
#endif
1218
 
    TRYFREE(zi);
1219
 
 
1220
 
    return err;
1221
 
}