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
30extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered)
31const char* file;
32const char* fileOut;
33const char* fileOutTmp;
34uLong* nRecovered;
35uLong* 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[1024];
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 (fnsize < sizeof(filename)) {
77            if (fread(filename, 1, fnsize, fpZip) == fnsize) {
78                if (fwrite(filename, 1, fnsize, fpOut) == fnsize) {
79                offset += fnsize;
80              } else {
81                err = Z_ERRNO;
82                break;
83              }
84            } else {
85              err = Z_ERRNO;
86              break;
87            }
88          } else {
89            err = Z_ERRNO;
90            break;
91          }
92        } else {
93          err = Z_STREAM_ERROR;
94          break;
95        }
96
97        /* Extra field */
98        if (extsize > 0) {
99          if (extsize < sizeof(extra)) {
100            if (fread(extra, 1, extsize, fpZip) == extsize) {
101              if (fwrite(extra, 1, extsize, fpOut) == extsize) {
102                offset += extsize;
103                } else {
104                err = Z_ERRNO;
105                break;
106              }
107            } else {
108              err = Z_ERRNO;
109              break;
110            }
111          } else {
112            err = Z_ERRNO;
113            break;
114          }
115        }
116
117        /* Data */
118        {
119          int dataSize = cpsize;
120          if (dataSize == 0) {
121            dataSize = uncpsize;
122          }
123          if (dataSize > 0) {
124            char* data = malloc(dataSize);
125            if (data != NULL) {
126              if ((int)fread(data, 1, dataSize, fpZip) == dataSize) {
127                if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) {
128                  offset += dataSize;
129                  totalBytes += dataSize;
130                } else {
131                  err = Z_ERRNO;
132                }
133              } else {
134                err = Z_ERRNO;
135              }
136              free(data);
137              if (err != Z_OK) {
138                break;
139              }
140            } else {
141              err = Z_MEM_ERROR;
142              break;
143            }
144          }
145        }
146
147        /* Central directory entry */
148        {
149          char header[46];
150          char* comment = "";
151          int comsize = (int) strlen(comment);
152          WRITE_32(header, 0x02014b50);
153          WRITE_16(header + 4, version);
154          WRITE_16(header + 6, version);
155          WRITE_16(header + 8, gpflag);
156          WRITE_16(header + 10, method);
157          WRITE_16(header + 12, filetime);
158          WRITE_16(header + 14, filedate);
159          WRITE_32(header + 16, crc);
160          WRITE_32(header + 20, cpsize);
161          WRITE_32(header + 24, uncpsize);
162          WRITE_16(header + 28, fnsize);
163          WRITE_16(header + 30, extsize);
164          WRITE_16(header + 32, comsize);
165          WRITE_16(header + 34, 0);     /* disk # */
166          WRITE_16(header + 36, 0);     /* int attrb */
167          WRITE_32(header + 38, 0);     /* ext attrb */
168          WRITE_32(header + 42, currentOffset);
169          /* Header */
170          if (fwrite(header, 1, 46, fpOutCD) == 46) {
171            offsetCD += 46;
172
173            /* Filename */
174            if (fnsize > 0) {
175              if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) {
176                offsetCD += fnsize;
177              } else {
178                err = Z_ERRNO;
179                break;
180              }
181            } else {
182              err = Z_STREAM_ERROR;
183              break;
184            }
185
186            /* Extra field */
187            if (extsize > 0) {
188              if (fwrite(extra, 1, extsize, fpOutCD) == extsize) {
189                offsetCD += extsize;
190              } else {
191                err = Z_ERRNO;
192                break;
193              }
194            }
195
196            /* Comment field */
197            if (comsize > 0) {
198              if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) {
199                offsetCD += comsize;
200              } else {
201                err = Z_ERRNO;
202                break;
203              }
204            }
205
206
207          } else {
208            err = Z_ERRNO;
209            break;
210          }
211        }
212
213        /* Success */
214        entries++;
215
216      } else {
217        break;
218      }
219    }
220
221    /* Final central directory  */
222    {
223      int entriesZip = entries;
224      char header[22];
225      char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
226      int comsize = (int) strlen(comment);
227      if (entriesZip > 0xffff) {
228        entriesZip = 0xffff;
229      }
230      WRITE_32(header, 0x06054b50);
231      WRITE_16(header + 4, 0);    /* disk # */
232      WRITE_16(header + 6, 0);    /* disk # */
233      WRITE_16(header + 8, entriesZip);   /* hack */
234      WRITE_16(header + 10, entriesZip);  /* hack */
235      WRITE_32(header + 12, offsetCD);    /* size of CD */
236      WRITE_32(header + 16, offset);      /* offset to CD */
237      WRITE_16(header + 20, comsize);     /* comment */
238
239      /* Header */
240      if (fwrite(header, 1, 22, fpOutCD) == 22) {
241
242        /* Comment field */
243        if (comsize > 0) {
244          if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) {
245            err = Z_ERRNO;
246          }
247        }
248
249      } else {
250        err = Z_ERRNO;
251      }
252    }
253
254    /* Final merge (file + central directory) */
255    fclose(fpOutCD);
256    if (err == Z_OK) {
257      fpOutCD = fopen(fileOutTmp, "rb");
258      if (fpOutCD != NULL) {
259        int nRead;
260        char buffer[8192];
261        while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
262          if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) {
263            err = Z_ERRNO;
264            break;
265          }
266        }
267        fclose(fpOutCD);
268      }
269    }
270
271    /* Close */
272    fclose(fpZip);
273    fclose(fpOut);
274
275    /* Wipe temporary file */
276    (void)remove(fileOutTmp);
277
278    /* Number of recovered entries */
279    if (err == Z_OK) {
280      if (nRecovered != NULL) {
281        *nRecovered = entries;
282      }
283      if (bytesRecovered != NULL) {
284        *bytesRecovered = totalBytes;
285      }
286    }
287  } else {
288    err = Z_STREAM_ERROR;
289  }
290  return err;
291}
292