← Back to branch summary

~ubuntu-branches/ubuntu/wily/luatex/wily

« back to all changes in this revision

Viewing changes to source/libs/zlib/zlib-1.2.3/contrib/minizip/minizip.c

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Preining
  • Date: 2010-04-29 00:47:19 UTC
  • mfrom: (1.1.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20100429004719-o42etkqe90n97b9e
Tags: 0.60.1-1
* new upstream release, adapt build-script patch
* disable patch: upstream-epstopdf_cc_no_xpdf_patching, included upstream
* disable patch: libpoppler-0.12, not needed anymore

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/libs/zlib/zlib-1.2.3/contrib/minizip/minizip.c
 
1
/*
 
2
   minizip.c
 
3
   Version 1.01e, February 12th, 2005
 
4
 
 
5
   Copyright (C) 1998-2005 Gilles Vollant
 
6
*/
 
7
 
 
8
#include <stdio.h>
 
9
#include <stdlib.h>
 
10
#include <string.h>
 
11
#include <time.h>
 
12
#include <errno.h>
 
13
#include <fcntl.h>
 
14
 
 
15
#ifdef unix
 
16
# include <unistd.h>
 
17
# include <utime.h>
 
18
# include <sys/types.h>
 
19
# include <sys/stat.h>
 
20
#else
 
21
# include <direct.h>
 
22
# include <io.h>
 
23
#endif
 
24
 
 
25
#include "zip.h"
 
26
 
 
27
#ifdef WIN32
 
28
#define USEWIN32IOAPI
 
29
#include "iowin32.h"
 
30
#endif
 
31
 
 
32
 
 
33
 
 
34
#define WRITEBUFFERSIZE (16384)
 
35
#define MAXFILENAME (256)
 
36
 
 
37
#ifdef WIN32
 
38
uLong filetime(f, tmzip, dt)
 
39
    char *f;                /* name of file to get info on */
 
40
    tm_zip *tmzip;             /* return value: access, modific. and creation times */
 
41
    uLong *dt;             /* dostime */
 
42
{
 
43
  int ret = 0;
 
44
  {
 
45
      FILETIME ftLocal;
 
46
      HANDLE hFind;
 
47
      WIN32_FIND_DATA  ff32;
 
48
 
 
49
      hFind = FindFirstFile(f,&ff32);
 
50
      if (hFind != INVALID_HANDLE_VALUE)
 
51
      {
 
52
        FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
 
53
        FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
 
54
        FindClose(hFind);
 
55
        ret = 1;
 
56
      }
 
57
  }
 
58
  return ret;
 
59
}
 
60
#else
 
61
#ifdef unix
 
62
uLong filetime(f, tmzip, dt)
 
63
    char *f;               /* name of file to get info on */
 
64
    tm_zip *tmzip;         /* return value: access, modific. and creation times */
 
65
    uLong *dt;             /* dostime */
 
66
{
 
67
  int ret=0;
 
68
  struct stat s;        /* results of stat() */
 
69
  struct tm* filedate;
 
70
  time_t tm_t=0;
 
71
 
 
72
  if (strcmp(f,"-")!=0)
 
73
  {
 
74
    char name[MAXFILENAME+1];
 
75
    int len = strlen(f);
 
76
    if (len > MAXFILENAME)
 
77
      len = MAXFILENAME;
 
78
 
 
79
    strncpy(name, f,MAXFILENAME-1);
 
80
    /* strncpy doesnt append the trailing NULL, of the string is too long. */
 
81
    name[ MAXFILENAME ] = '\0';
 
82
 
 
83
    if (name[len - 1] == '/')
 
84
      name[len - 1] = '\0';
 
85
    /* not all systems allow stat'ing a file with / appended */
 
86
    if (stat(name,&s)==0)
 
87
    {
 
88
      tm_t = s.st_mtime;
 
89
      ret = 1;
 
90
    }
 
91
  }
 
92
  filedate = localtime(&tm_t);
 
93
 
 
94
  tmzip->tm_sec  = filedate->tm_sec;
 
95
  tmzip->tm_min  = filedate->tm_min;
 
96
  tmzip->tm_hour = filedate->tm_hour;
 
97
  tmzip->tm_mday = filedate->tm_mday;
 
98
  tmzip->tm_mon  = filedate->tm_mon ;
 
99
  tmzip->tm_year = filedate->tm_year;
 
100
 
 
101
  return ret;
 
102
}
 
103
#else
 
104
uLong filetime(f, tmzip, dt)
 
105
    char *f;                /* name of file to get info on */
 
106
    tm_zip *tmzip;             /* return value: access, modific. and creation times */
 
107
    uLong *dt;             /* dostime */
 
108
{
 
109
    return 0;
 
110
}
 
111
#endif
 
112
#endif
 
113
 
 
114
 
 
115
 
 
116
 
 
117
int check_exist_file(filename)
 
118
    const char* filename;
 
119
{
 
120
    FILE* ftestexist;
 
121
    int ret = 1;
 
122
    ftestexist = fopen(filename,"rb");
 
123
    if (ftestexist==NULL)
 
124
        ret = 0;
 
125
    else
 
126
        fclose(ftestexist);
 
127
    return ret;
 
128
}
 
129
 
 
130
void do_banner()
 
131
{
 
132
    printf("MiniZip 1.01b, demo of zLib + Zip package written by Gilles Vollant\n");
 
133
    printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
 
134
}
 
135
 
 
136
void do_help()
 
137
{
 
138
    printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
 
139
           "  -o  Overwrite existing file.zip\n" \
 
140
           "  -a  Append to existing file.zip\n" \
 
141
           "  -0  Store only\n" \
 
142
           "  -1  Compress faster\n" \
 
143
           "  -9  Compress better\n\n");
 
144
}
 
145
 
 
146
/* calculate the CRC32 of a file,
 
147
   because to encrypt a file, we need known the CRC32 of the file before */
 
148
int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
 
149
{
 
150
   unsigned long calculate_crc=0;
 
151
   int err=ZIP_OK;
 
152
   FILE * fin = fopen(filenameinzip,"rb");
 
153
   unsigned long size_read = 0;
 
154
   unsigned long total_read = 0;
 
155
   if (fin==NULL)
 
156
   {
 
157
       err = ZIP_ERRNO;
 
158
   }
 
159
 
 
160
    if (err == ZIP_OK)
 
161
        do
 
162
        {
 
163
            err = ZIP_OK;
 
164
            size_read = (int)fread(buf,1,size_buf,fin);
 
165
            if (size_read < size_buf)
 
166
                if (feof(fin)==0)
 
167
            {
 
168
                printf("error in reading %s\n",filenameinzip);
 
169
                err = ZIP_ERRNO;
 
170
            }
 
171
 
 
172
            if (size_read>0)
 
173
                calculate_crc = crc32(calculate_crc,buf,size_read);
 
174
            total_read += size_read;
 
175
 
 
176
        } while ((err == ZIP_OK) && (size_read>0));
 
177
 
 
178
    if (fin)
 
179
        fclose(fin);
 
180
 
 
181
    *result_crc=calculate_crc;
 
182
    printf("file %s crc %x\n",filenameinzip,calculate_crc);
 
183
    return err;
 
184
}
 
185
 
 
186
int main(argc,argv)
 
187
    int argc;
 
188
    char *argv[];
 
189
{
 
190
    int i;
 
191
    int opt_overwrite=0;
 
192
    int opt_compress_level=Z_DEFAULT_COMPRESSION;
 
193
    int zipfilenamearg = 0;
 
194
    char filename_try[MAXFILENAME+16];
 
195
    int zipok;
 
196
    int err=0;
 
197
    int size_buf=0;
 
198
    void* buf=NULL;
 
199
    const char* password=NULL;
 
200
 
 
201
 
 
202
    do_banner();
 
203
    if (argc==1)
 
204
    {
 
205
        do_help();
 
206
        return 0;
 
207
    }
 
208
    else
 
209
    {
 
210
        for (i=1;i<argc;i++)
 
211
        {
 
212
            if ((*argv[i])=='-')
 
213
            {
 
214
                const char *p=argv[i]+1;
 
215
 
 
216
                while ((*p)!='\0')
 
217
                {
 
218
                    char c=*(p++);;
 
219
                    if ((c=='o') || (c=='O'))
 
220
                        opt_overwrite = 1;
 
221
                    if ((c=='a') || (c=='A'))
 
222
                        opt_overwrite = 2;
 
223
                    if ((c>='0') && (c<='9'))
 
224
                        opt_compress_level = c-'0';
 
225
 
 
226
                    if (((c=='p') || (c=='P')) && (i+1<argc))
 
227
                    {
 
228
                        password=argv[i+1];
 
229
                        i++;
 
230
                    }
 
231
                }
 
232
            }
 
233
            else
 
234
                if (zipfilenamearg == 0)
 
235
                    zipfilenamearg = i ;
 
236
        }
 
237
    }
 
238
 
 
239
    size_buf = WRITEBUFFERSIZE;
 
240
    buf = (void*)malloc(size_buf);
 
241
    if (buf==NULL)
 
242
    {
 
243
        printf("Error allocating memory\n");
 
244
        return ZIP_INTERNALERROR;
 
245
    }
 
246
 
 
247
    if (zipfilenamearg==0)
 
248
        zipok=0;
 
249
    else
 
250
    {
 
251
        int i,len;
 
252
        int dot_found=0;
 
253
 
 
254
        zipok = 1 ;
 
255
        strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
 
256
        /* strncpy doesnt append the trailing NULL, of the string is too long. */
 
257
        filename_try[ MAXFILENAME ] = '\0';
 
258
 
 
259
        len=(int)strlen(filename_try);
 
260
        for (i=0;i<len;i++)
 
261
            if (filename_try[i]=='.')
 
262
                dot_found=1;
 
263
 
 
264
        if (dot_found==0)
 
265
            strcat(filename_try,".zip");
 
266
 
 
267
        if (opt_overwrite==2)
 
268
        {
 
269
            /* if the file don't exist, we not append file */
 
270
            if (check_exist_file(filename_try)==0)
 
271
                opt_overwrite=1;
 
272
        }
 
273
        else
 
274
        if (opt_overwrite==0)
 
275
            if (check_exist_file(filename_try)!=0)
 
276
            {
 
277
                char rep=0;
 
278
                do
 
279
                {
 
280
                    char answer[128];
 
281
                    int ret;
 
282
                    printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
 
283
                    ret = scanf("%1s",answer);
 
284
                    if (ret != 1)
 
285
                    {
 
286
                       exit(EXIT_FAILURE);
 
287
                    }
 
288
                    rep = answer[0] ;
 
289
                    if ((rep>='a') && (rep<='z'))
 
290
                        rep -= 0x20;
 
291
                }
 
292
                while ((rep!='Y') && (rep!='N') && (rep!='A'));
 
293
                if (rep=='N')
 
294
                    zipok = 0;
 
295
                if (rep=='A')
 
296
                    opt_overwrite = 2;
 
297
            }
 
298
    }
 
299
 
 
300
    if (zipok==1)
 
301
    {
 
302
        zipFile zf;
 
303
        int errclose;
 
304
#        ifdef USEWIN32IOAPI
 
305
        zlib_filefunc_def ffunc;
 
306
        fill_win32_filefunc(&ffunc);
 
307
        zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
 
308
#        else
 
309
        zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
 
310
#        endif
 
311
 
 
312
        if (zf == NULL)
 
313
        {
 
314
            printf("error opening %s\n",filename_try);
 
315
            err= ZIP_ERRNO;
 
316
        }
 
317
        else
 
318
            printf("creating %s\n",filename_try);
 
319
 
 
320
        for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
 
321
        {
 
322
            if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) &&
 
323
                  ((argv[i][1]=='o') || (argv[i][1]=='O') ||
 
324
                   (argv[i][1]=='a') || (argv[i][1]=='A') ||
 
325
                   (argv[i][1]=='p') || (argv[i][1]=='P') ||
 
326
                   ((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
 
327
                  (strlen(argv[i]) == 2)))
 
328
            {
 
329
                FILE * fin;
 
330
                int size_read;
 
331
                const char* filenameinzip = argv[i];
 
332
                zip_fileinfo zi;
 
333
                unsigned long crcFile=0;
 
334
 
 
335
                zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
 
336
                zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
 
337
                zi.dosDate = 0;
 
338
                zi.internal_fa = 0;
 
339
                zi.external_fa = 0;
 
340
                filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
 
341
 
 
342
/*
 
343
                err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
 
344
                                 NULL,0,NULL,0,NULL / * comment * /,
 
345
                                 (opt_compress_level != 0) ? Z_DEFLATED : 0,
 
346
                                 opt_compress_level);
 
347
*/
 
348
                if ((password != NULL) && (err==ZIP_OK))
 
349
                    err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
 
350
 
 
351
                err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
 
352
                                 NULL,0,NULL,0,NULL /* comment*/,
 
353
                                 (opt_compress_level != 0) ? Z_DEFLATED : 0,
 
354
                                 opt_compress_level,0,
 
355
                                 /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
 
356
                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
 
357
                                 password,crcFile);
 
358
 
 
359
                if (err != ZIP_OK)
 
360
                    printf("error in opening %s in zipfile\n",filenameinzip);
 
361
                else
 
362
                {
 
363
                    fin = fopen(filenameinzip,"rb");
 
364
                    if (fin==NULL)
 
365
                    {
 
366
                        err=ZIP_ERRNO;
 
367
                        printf("error in opening %s for reading\n",filenameinzip);
 
368
                    }
 
369
                }
 
370
 
 
371
                if (err == ZIP_OK)
 
372
                    do
 
373
                    {
 
374
                        err = ZIP_OK;
 
375
                        size_read = (int)fread(buf,1,size_buf,fin);
 
376
                        if (size_read < size_buf)
 
377
                            if (feof(fin)==0)
 
378
                        {
 
379
                            printf("error in reading %s\n",filenameinzip);
 
380
                            err = ZIP_ERRNO;
 
381
                        }
 
382
 
 
383
                        if (size_read>0)
 
384
                        {
 
385
                            err = zipWriteInFileInZip (zf,buf,size_read);
 
386
                            if (err<0)
 
387
                            {
 
388
                                printf("error in writing %s in the zipfile\n",
 
389
                                                 filenameinzip);
 
390
                            }
 
391
 
 
392
                        }
 
393
                    } while ((err == ZIP_OK) && (size_read>0));
 
394
 
 
395
                if (fin)
 
396
                    fclose(fin);
 
397
 
 
398
                if (err<0)
 
399
                    err=ZIP_ERRNO;
 
400
                else
 
401
                {
 
402
                    err = zipCloseFileInZip(zf);
 
403
                    if (err!=ZIP_OK)
 
404
                        printf("error in closing %s in the zipfile\n",
 
405
                                    filenameinzip);
 
406
                }
 
407
            }
 
408
        }
 
409
        errclose = zipClose(zf,NULL);
 
410
        if (errclose != ZIP_OK)
 
411
            printf("error in closing %s\n",filename_try);
 
412
    }
 
413
    else
 
414
    {
 
415
       do_help();
 
416
    }
 
417
 
 
418
    free(buf);
 
419
    return 0;
 
420
}