← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to lib/zlib/contrib/minizip/mztools.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/zlib/contrib/minizip/mztools.c
 
1
/*
 
2
  Additional tools for Minizip
 
3
  Code: Xavier Roche '2004
 
4
  License: Same as ZLIB (www.gzip.org)
 
5
*/
 
6
 
 
7
/* Code */
 
8
#include <stdio.h>
 
9
#include <stdlib.h>
 
10
#include <string.h>
 
11
#include "zlib.h"
 
12
#include "unzip.h"
 
13
 
 
14
#define READ_8(adr)  ((unsigned char)*(adr))
 
15
#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) )
 
16
#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) )
 
17
 
 
18
#define WRITE_8(buff, n) do { \
 
19
  *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \
 
20
} while(0)
 
21
#define WRITE_16(buff, n) do { \
 
22
  WRITE_8((unsigned char*)(buff), n); \
 
23
  WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \
 
24
} while(0)
 
25
#define WRITE_32(buff, n) do { \
 
26
  WRITE_16((unsigned char*)(buff), (n) & 0xffff); \
 
27
  WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \
 
28
} while(0)
 
29
 
 
30
extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered)
 
31
const char* file;
 
32
const char* fileOut;
 
33
const char* fileOutTmp;
 
34
uLong* nRecovered;
 
35
uLong* bytesRecovered;
 
36
{
 
37
  int err = Z_OK;
 
38
  FILE* fpZip = fopen(file, "rb");
 
39
  FILE* fpOut = fopen(fileOut, "wb");
 
40
  FILE* fpOutCD = fopen(fileOutTmp, "wb");
 
41
  if (fpZip != NULL &&  fpOut != NULL) {
 
42
    int entries = 0;
 
43
    uLong totalBytes = 0;
 
44
    char header[30];
 
45
    char filename[256];
 
46
    char extra[1024];
 
47
    int offset = 0;
 
48
    int offsetCD = 0;
 
49
    while ( fread(header, 1, 30, fpZip) == 30 ) {
 
50
      int currentOffset = offset;
 
51
 
 
52
      /* File entry */
 
53
      if (READ_32(header) == 0x04034b50) {
 
54
        unsigned int version = READ_16(header + 4);
 
55
        unsigned int gpflag = READ_16(header + 6);
 
56
        unsigned int method = READ_16(header + 8);
 
57
        unsigned int filetime = READ_16(header + 10);
 
58
        unsigned int filedate = READ_16(header + 12);
 
59
        unsigned int crc = READ_32(header + 14); /* crc */
 
60
        unsigned int cpsize = READ_32(header + 18); /* compressed size */
 
61
        unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */
 
62
        unsigned int fnsize = READ_16(header + 26); /* file name length */
 
63
        unsigned int extsize = READ_16(header + 28); /* extra field length */
 
64
        filename[0] = extra[0] = '\0';
 
65
        
 
66
        /* Header */
 
67
        if (fwrite(header, 1, 30, fpOut) == 30) {
 
68
          offset += 30;
 
69
        } else {
 
70
          err = Z_ERRNO;
 
71
          break;
 
72
        }
 
73
        
 
74
        /* Filename */
 
75
        if (fnsize > 0) {
 
76
          if (fread(filename, 1, fnsize, fpZip) == fnsize) {
 
77
            if (fwrite(filename, 1, fnsize, fpOut) == fnsize) {
 
78
              offset += fnsize;
 
79
            } else {
 
80
              err = Z_ERRNO;
 
81
              break;
 
82
            }
 
83
          } else {
 
84
            err = Z_ERRNO;
 
85
            break;
 
86
          }
 
87
        } else {
 
88
          err = Z_STREAM_ERROR;
 
89
          break;
 
90
        }
 
91
 
 
92
        /* Extra field */
 
93
        if (extsize > 0) {
 
94
          if (fread(extra, 1, extsize, fpZip) == extsize) {
 
95
            if (fwrite(extra, 1, extsize, fpOut) == extsize) {
 
96
              offset += extsize;
 
97
            } else {
 
98
              err = Z_ERRNO;
 
99
              break;
 
100
            }
 
101
          } else {
 
102
            err = Z_ERRNO;
 
103
            break;
 
104
          }
 
105
        }
 
106
        
 
107
        /* Data */
 
108
        {
 
109
          int dataSize = cpsize;
 
110
          if (dataSize == 0) {
 
111
            dataSize = uncpsize;
 
112
          }
 
113
          if (dataSize > 0) {
 
114
            char* data = malloc(dataSize);
 
115
            if (data != NULL) {
 
116
              if ((int)fread(data, 1, dataSize, fpZip) == dataSize) {
 
117
                if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) {
 
118
                  offset += dataSize;
 
119
                  totalBytes += dataSize;
 
120
                } else {
 
121
                  err = Z_ERRNO;
 
122
                }
 
123
              } else {
 
124
                err = Z_ERRNO;
 
125
              }
 
126
              free(data);
 
127
              if (err != Z_OK) {
 
128
                break;
 
129
              }
 
130
            } else {
 
131
              err = Z_MEM_ERROR;
 
132
              break;
 
133
            }
 
134
          }
 
135
        }
 
136
        
 
137
        /* Central directory entry */
 
138
        {
 
139
          char header[46];
 
140
          char* comment = "";
 
141
          int comsize = (int) strlen(comment);
 
142
          WRITE_32(header, 0x02014b50);
 
143
          WRITE_16(header + 4, version);
 
144
          WRITE_16(header + 6, version);
 
145
          WRITE_16(header + 8, gpflag);
 
146
          WRITE_16(header + 10, method);
 
147
          WRITE_16(header + 12, filetime);
 
148
          WRITE_16(header + 14, filedate);
 
149
          WRITE_32(header + 16, crc);
 
150
          WRITE_32(header + 20, cpsize);
 
151
          WRITE_32(header + 24, uncpsize);
 
152
          WRITE_16(header + 28, fnsize);
 
153
          WRITE_16(header + 30, extsize);
 
154
          WRITE_16(header + 32, comsize);
 
155
          WRITE_16(header + 34, 0);     /* disk # */
 
156
          WRITE_16(header + 36, 0);     /* int attrb */
 
157
          WRITE_32(header + 38, 0);     /* ext attrb */
 
158
          WRITE_32(header + 42, currentOffset);
 
159
          /* Header */
 
160
          if (fwrite(header, 1, 46, fpOutCD) == 46) {
 
161
            offsetCD += 46;
 
162
            
 
163
            /* Filename */
 
164
            if (fnsize > 0) {
 
165
              if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) {
 
166
                offsetCD += fnsize;
 
167
              } else {
 
168
                err = Z_ERRNO;
 
169
                break;
 
170
              }
 
171
            } else {
 
172
              err = Z_STREAM_ERROR;
 
173
              break;
 
174
            }
 
175
            
 
176
            /* Extra field */
 
177
            if (extsize > 0) {
 
178
              if (fwrite(extra, 1, extsize, fpOutCD) == extsize) {
 
179
                offsetCD += extsize;
 
180
              } else {
 
181
                err = Z_ERRNO;
 
182
                break;
 
183
              }
 
184
            }
 
185
            
 
186
            /* Comment field */
 
187
            if (comsize > 0) {
 
188
              if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) {
 
189
                offsetCD += comsize;
 
190
              } else {
 
191
                err = Z_ERRNO;
 
192
                break;
 
193
              }
 
194
            }
 
195
            
 
196
            
 
197
          } else {
 
198
            err = Z_ERRNO;
 
199
            break;
 
200
          }
 
201
        }
 
202
 
 
203
        /* Success */
 
204
        entries++;
 
205
 
 
206
      } else {
 
207
        break;
 
208
      }
 
209
    }
 
210
 
 
211
    /* Final central directory  */
 
212
    {
 
213
      int entriesZip = entries;
 
214
      char header[22];
 
215
      char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
 
216
      int comsize = (int) strlen(comment);
 
217
      if (entriesZip > 0xffff) {
 
218
        entriesZip = 0xffff;
 
219
      }
 
220
      WRITE_32(header, 0x06054b50);
 
221
      WRITE_16(header + 4, 0);    /* disk # */
 
222
      WRITE_16(header + 6, 0);    /* disk # */
 
223
      WRITE_16(header + 8, entriesZip);   /* hack */
 
224
      WRITE_16(header + 10, entriesZip);  /* hack */
 
225
      WRITE_32(header + 12, offsetCD);    /* size of CD */
 
226
      WRITE_32(header + 16, offset);      /* offset to CD */
 
227
      WRITE_16(header + 20, comsize);     /* comment */
 
228
      
 
229
      /* Header */
 
230
      if (fwrite(header, 1, 22, fpOutCD) == 22) {
 
231
        
 
232
        /* Comment field */
 
233
        if (comsize > 0) {
 
234
          if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) {
 
235
            err = Z_ERRNO;
 
236
          }
 
237
        }
 
238
        
 
239
      } else {
 
240
        err = Z_ERRNO;
 
241
      }
 
242
    }
 
243
 
 
244
    /* Final merge (file + central directory) */
 
245
    fclose(fpOutCD);
 
246
    if (err == Z_OK) {
 
247
      fpOutCD = fopen(fileOutTmp, "rb");
 
248
      if (fpOutCD != NULL) {
 
249
        int nRead;
 
250
        char buffer[8192];
 
251
        while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
 
252
          if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) {
 
253
            err = Z_ERRNO;
 
254
            break;
 
255
          }
 
256
        }
 
257
        fclose(fpOutCD);
 
258
      }
 
259
    }
 
260
    
 
261
    /* Close */
 
262
    fclose(fpZip);
 
263
    fclose(fpOut);
 
264
    
 
265
    /* Wipe temporary file */
 
266
    (void)remove(fileOutTmp);
 
267
    
 
268
    /* Number of recovered entries */
 
269
    if (err == Z_OK) {
 
270
      if (nRecovered != NULL) {
 
271
        *nRecovered = entries;
 
272
      }
 
273
      if (bytesRecovered != NULL) {
 
274
        *bytesRecovered = totalBytes;
 
275
      }
 
276
    }
 
277
  } else {
 
278
    err = Z_STREAM_ERROR;
 
279
  }
 
280
  return err;
 
281
}