URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [minizip/] [mztools.c] - Blame information for rev 767

Go to most recent revision | Details | Compare with Previous | View Log


/*
  Additional tools for Minizip
  Code: Xavier Roche '2004
  License: Same as ZLIB (www.gzip.org)
*/
 
/* Code */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "zlib.h"
#include "unzip.h"
 
#define READ_8(adr)  ((unsigned char)*(adr))
#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) )
#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) )
 
#define WRITE_8(buff, n) do { \
  *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \
} while(0)
#define WRITE_16(buff, n) do { \
  WRITE_8((unsigned char*)(buff), n); \
  WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \
} while(0)
#define WRITE_32(buff, n) do { \
  WRITE_16((unsigned char*)(buff), (n) & 0xffff); \
  WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \
} while(0)
 
extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered)
const char* file;
const char* fileOut;
const char* fileOutTmp;
uLong* nRecovered;
uLong* bytesRecovered;
{
  int err = Z_OK;
  FILE* fpZip = fopen(file, "rb");
  FILE* fpOut = fopen(fileOut, "wb");
  FILE* fpOutCD = fopen(fileOutTmp, "wb");
  if (fpZip != NULL &&  fpOut != NULL) {
    int entries = 0;
    uLong totalBytes = 0;
    char header[30];
    char filename[256];
    char extra[1024];
    int offset = 0;
    int offsetCD = 0;
    while ( fread(header, 1, 30, fpZip) == 30 ) {
      int currentOffset = offset;
 
      /* File entry */
      if (READ_32(header) == 0x04034b50) {
        unsigned int version = READ_16(header + 4);
        unsigned int gpflag = READ_16(header + 6);
        unsigned int method = READ_16(header + 8);
        unsigned int filetime = READ_16(header + 10);
        unsigned int filedate = READ_16(header + 12);
        unsigned int crc = READ_32(header + 14); /* crc */
        unsigned int cpsize = READ_32(header + 18); /* compressed size */
        unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */
        unsigned int fnsize = READ_16(header + 26); /* file name length */
        unsigned int extsize = READ_16(header + 28); /* extra field length */
        filename[0] = extra[0] = '\0';
 
        /* Header */
        if (fwrite(header, 1, 30, fpOut) == 30) {
          offset += 30;
        } else {
          err = Z_ERRNO;
          break;
        }
 
        /* Filename */
        if (fnsize > 0) {
          if (fread(filename, 1, fnsize, fpZip) == fnsize) {
            if (fwrite(filename, 1, fnsize, fpOut) == fnsize) {
              offset += fnsize;
            } else {
              err = Z_ERRNO;
              break;
            }
          } else {
            err = Z_ERRNO;
            break;
          }
        } else {
          err = Z_STREAM_ERROR;
          break;
        }
 
        /* Extra field */
        if (extsize > 0) {
          if (fread(extra, 1, extsize, fpZip) == extsize) {
            if (fwrite(extra, 1, extsize, fpOut) == extsize) {
              offset += extsize;
            } else {
              err = Z_ERRNO;
              break;
            }
          } else {
            err = Z_ERRNO;
            break;
          }
        }
 
        /* Data */
        {
          int dataSize = cpsize;
          if (dataSize == 0) {
            dataSize = uncpsize;
          }
          if (dataSize > 0) {
            char* data = malloc(dataSize);
            if (data != NULL) {
              if ((int)fread(data, 1, dataSize, fpZip) == dataSize) {
                if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) {
                  offset += dataSize;
                  totalBytes += dataSize;
                } else {
                  err = Z_ERRNO;
                }
              } else {
                err = Z_ERRNO;
              }
              free(data);
              if (err != Z_OK) {
                break;
              }
            } else {
              err = Z_MEM_ERROR;
              break;
            }
          }
        }
 
        /* Central directory entry */
        {
          char header[46];
          char* comment = "";
          int comsize = (int) strlen(comment);
          WRITE_32(header, 0x02014b50);
          WRITE_16(header + 4, version);
          WRITE_16(header + 6, version);
          WRITE_16(header + 8, gpflag);
          WRITE_16(header + 10, method);
          WRITE_16(header + 12, filetime);
          WRITE_16(header + 14, filedate);
          WRITE_32(header + 16, crc);
          WRITE_32(header + 20, cpsize);
          WRITE_32(header + 24, uncpsize);
          WRITE_16(header + 28, fnsize);
          WRITE_16(header + 30, extsize);
          WRITE_16(header + 32, comsize);
          WRITE_16(header + 34, 0);     /* disk # */
          WRITE_16(header + 36, 0);     /* int attrb */
          WRITE_32(header + 38, 0);     /* ext attrb */
          WRITE_32(header + 42, currentOffset);
          /* Header */
          if (fwrite(header, 1, 46, fpOutCD) == 46) {
            offsetCD += 46;
 
            /* Filename */
            if (fnsize > 0) {
              if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) {
                offsetCD += fnsize;
              } else {
                err = Z_ERRNO;
                break;
              }
            } else {
              err = Z_STREAM_ERROR;
              break;
            }
 
            /* Extra field */
            if (extsize > 0) {
              if (fwrite(extra, 1, extsize, fpOutCD) == extsize) {
                offsetCD += extsize;
              } else {
                err = Z_ERRNO;
                break;
              }
            }
 
            /* Comment field */
            if (comsize > 0) {
              if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) {
                offsetCD += comsize;
              } else {
                err = Z_ERRNO;
                break;
              }
            }
 
 
          } else {
            err = Z_ERRNO;
            break;
          }
        }
 
        /* Success */
        entries++;
 
      } else {
        break;
      }
    }
 
    /* Final central directory  */
    {
      int entriesZip = entries;
      char header[22];
      char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
      int comsize = (int) strlen(comment);
      if (entriesZip > 0xffff) {
        entriesZip = 0xffff;
      }
      WRITE_32(header, 0x06054b50);
      WRITE_16(header + 4, 0);    /* disk # */
      WRITE_16(header + 6, 0);    /* disk # */
      WRITE_16(header + 8, entriesZip);   /* hack */
      WRITE_16(header + 10, entriesZip);  /* hack */
      WRITE_32(header + 12, offsetCD);    /* size of CD */
      WRITE_32(header + 16, offset);      /* offset to CD */
      WRITE_16(header + 20, comsize);     /* comment */
 
      /* Header */
      if (fwrite(header, 1, 22, fpOutCD) == 22) {
 
        /* Comment field */
        if (comsize > 0) {
          if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) {
            err = Z_ERRNO;
          }
        }
 
      } else {
        err = Z_ERRNO;
      }
    }
 
    /* Final merge (file + central directory) */
    fclose(fpOutCD);
    if (err == Z_OK) {
      fpOutCD = fopen(fileOutTmp, "rb");
      if (fpOutCD != NULL) {
        int nRead;
        char buffer[8192];
        while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
          if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) {
            err = Z_ERRNO;
            break;
          }
        }
        fclose(fpOutCD);
      }
    }
 
    /* Close */
    fclose(fpZip);
    fclose(fpOut);
 
    /* Wipe temporary file */
    (void)remove(fileOutTmp);
 
    /* Number of recovered entries */
    if (err == Z_OK) {
      if (nRecovered != NULL) {
        *nRecovered = entries;
      }
      if (bytesRecovered != NULL) {
        *bytesRecovered = totalBytes;
      }
    }
  } else {
    err = Z_STREAM_ERROR;
  }
  return err;
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [minizip/] [mztools.c] - Blame information for rev 767

Line No.	Rev	Author	Line
1	745	jeremybenn	`/*`
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			`}`