Subversion Repositories SvarDOS

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
219 mateuszvis 1
/*
268 mateuszvis 2
 * This file is part of pkg (SvarDOS)
3
 * Copyright (C) 2012-2021 Mateusz Viste.
219 mateuszvis 4
 *
5
 * Simple library providing functions to unzip files from zip archives.
6
 */
7
 
8
#include <stdio.h>     /* printf(), FILE, fclose()... */
9
#include <stdlib.h>    /* NULL */
10
#include <string.h>    /* memset() */
11
#include <time.h>      /* mktime() */
12
#include <utime.h>     /* utime() */
13
#include <unistd.h>   /* unlink() */
14
 
15
#include "crc32.h"
16
#include "kprintf.h"
268 mateuszvis 17
#include "inf.h"   /* INFLATE support */
219 mateuszvis 18
 
19
#include "libunzip.h"  /* include self for control */
20
 
21
 
22
/* converts a "DOS format" timestamp into unix timestamp. The DOS timestamp is constructed an array of 4 bytes, that contains following data at the bit level:
23
 * HHHHHMMM MMMSSSSS YYYYYYYM MMMDDDDD
24
 *  where:
25
 * day of month is always within 1-31 range;
26
 * month is always within 1-12 range;
27
 * year starts from 1980 and continues for 127 years
28
 * seconds are actually not 0-59 but rather 0-29 as there are only 32 possible values – to get actual seconds multiply this field by 2;
29
 * minutes are always within 0-59 range;
30
 * hours are always within 0-23 range.     */
268 mateuszvis 31
static time_t dostime2unix(const unsigned char *buff) {
219 mateuszvis 32
  struct tm curtime;
33
  time_t result;
34
  memset(&curtime, 0, sizeof(curtime)); /* make sure to set everything in curtime to 0's */
35
  curtime.tm_sec = (buff[0] & 31) << 1; /* seconds (0..60) */
36
  curtime.tm_min = (((buff[1] << 8) | buff[0]) >> 5) & 63 ; /* minutes after the hour (0..59) */
37
  curtime.tm_hour = (buff[1] >> 3); /* hours since midnight (0..23) */
38
  curtime.tm_mday = buff[2] & 31; /* day of the month (1..31) */
39
  curtime.tm_mon = ((((buff[3] << 8) | buff[2]) >> 5) & 15) - 1; /* months since January (0, 11) */
40
  curtime.tm_year = (buff[3] >> 1) + 80; /* years since 1900 */
41
  curtime.tm_wday = 0; /* days since Sunday (0..6) - leave 0, mktime() will set it */
42
  curtime.tm_yday = 0; /* days since January 1 (0..365]) - leave 0, mktime() will set it */
43
  curtime.tm_isdst = -1; /* Daylight Saving Time flag. Positive if DST is in effect, zero if not and negative if no information is available */
44
  result = mktime(&curtime);
45
  if (result == (time_t)-1) return(0);
46
  return(result);
47
}
48
 
49
 
50
/* opens a zip file and provides the list of files in the archive.
51
   returns a pointer to a ziplist (linked list) with all records, or NULL on error.
52
   The ziplist is allocated automatically, and must be freed via zip_freelist. */
53
struct ziplist *zip_listfiles(FILE *fd) {
54
  struct ziplist *reslist = NULL;
55
  struct ziplist *newentry;
56
  unsigned long entrysig;
57
  unsigned short filenamelen, extrafieldlen, filecommentlen;
58
  unsigned long compfilelen;
59
  int centraldirectoryfound = 0;
60
  unsigned int ux;
61
  unsigned char hdrbuff[64];
62
 
63
  rewind(fd);  /* make sure the file cursor is at the very beginning of the file */
64
 
65
  for (;;) { /* read entry after entry */
66
    int x, eofflag;
67
    long longbuff;
68
    entrysig = 0;
69
    eofflag = 0;
70
    /* read the entry signature first */
71
    for (x = 0; x < 32; x += 8) {
72
      if ((longbuff = fgetc(fd)) == EOF) {
73
        eofflag = 1;
74
        break;
75
      }
76
      entrysig |= (longbuff << x);
77
    }
78
    if (eofflag != 0) break;
79
    /* printf("sig: 0x%08x\n", entrysig); */
80
    if (entrysig == 0x04034b50ul) { /* local file */
81
      unsigned int generalpurposeflags;
82
      /* read and parse the zip header */
83
      fread(hdrbuff, 1, 26, fd);
84
      /* read filename's length so I can allocate the proper amound of mem */
85
      filenamelen = hdrbuff[23];
86
      filenamelen <<= 8;
87
      filenamelen |= hdrbuff[22];
88
      /* create new entry and link it into the list */
89
      newentry = calloc(sizeof(struct ziplist) + filenamelen, 1);
90
      if (newentry == NULL) {
91
        kitten_puts(8, 0, "Out of memory!");
92
        zip_freelist(&reslist);
93
        break;
94
      }
95
      newentry->nextfile = reslist;
96
      newentry->flags = 0;
97
      reslist = newentry;
98
      /* read further areas of the header, and fill zip entry */
99
      generalpurposeflags = hdrbuff[3];  /* parse the general */
100
      generalpurposeflags <<= 8;         /* purpose flags and */
101
      generalpurposeflags |= hdrbuff[2]; /* save them for later */
102
      newentry->compmethod = hdrbuff[4] | (hdrbuff[5] << 8);
103
      newentry->timestamp = dostime2unix(&hdrbuff[6]);
104
      newentry->crc32 = 0;
105
      for (x = 13; x >= 10; x--) {
106
        newentry->crc32 <<= 8;
107
        newentry->crc32 |= hdrbuff[x];
108
      }
109
      newentry->compressedfilelen = 0;
110
      for (x = 17; x >= 14; x--) {
111
        newentry->compressedfilelen <<= 8;
112
        newentry->compressedfilelen |= hdrbuff[x];
113
      }
114
      newentry->filelen = 0;
115
      for (x = 21; x >= 18; x--) {
116
        newentry->filelen <<= 8;
117
        newentry->filelen |= hdrbuff[x];
118
      }
119
      extrafieldlen = hdrbuff[25];
120
      extrafieldlen <<= 8;
121
      extrafieldlen |= hdrbuff[24];
122
      /* printf("Filename len: %d / extrafield len: %d / compfile len: %ld / filelen: %ld\n", filenamelen, extrafieldlen, newentry->compressedfilelen, newentry->filelen); */
123
      /* check general purpose flags */
124
      if ((generalpurposeflags & 1) != 0) newentry->flags |= ZIP_FLAG_ENCRYPTED;
125
      /* parse the filename */
126
      for (ux = 0; ux < filenamelen; ux++) newentry->filename[ux] = fgetc(fd); /* store filename */
127
      if (newentry->filename[filenamelen - 1] == '/') newentry->flags |= ZIP_FLAG_ISADIR; /* if filename ends with / it's a dir. Note that ZIP forbids the usage of '\' in ZIP paths anyway */
128
      /* printf("Filename: %s (%ld bytes compressed)\n", newentry->filename, newentry->compressedfilelen); */
129
      newentry->dataoffset = ftell(fd) + extrafieldlen;
130
      /* skip rest of fields and data */
131
      fseek(fd, (extrafieldlen + newentry->compressedfilelen), SEEK_CUR);
132
    } else if (entrysig == 0x02014b50ul) { /* central directory */
133
      centraldirectoryfound = 1;
134
      /* parse header now */
135
      fread(hdrbuff, 1, 42, fd);
136
      filenamelen = hdrbuff[22] | (hdrbuff[23] << 8);
137
      extrafieldlen = hdrbuff[24] | (hdrbuff[25] << 8);
138
      filecommentlen = hdrbuff[26] | (hdrbuff[27] << 8);
139
      compfilelen = 0;
140
      for (x = 17; x >= 14; x--) {
141
        compfilelen <<= 8;
142
        compfilelen |= hdrbuff[x];
143
      }
144
      /* printf("central dir\n"); */
145
      /* skip rest of fields and data */
146
      fseek(fd, (filenamelen + extrafieldlen + compfilelen + filecommentlen), SEEK_CUR);
147
    } else if (entrysig == 0x08074b50ul) { /* Data descriptor header */
148
      /* no need to read the header we just have to skip it */
149
      fseek(fd, 12, SEEK_CUR); /* the header is 3x4 bytes (CRC + compressed len + uncompressed len) */
150
    } else { /* unknown sig */
151
      kitten_printf(8, 1, "unknown zip sig: 0x%08lx", entrysig);
152
      puts("");
153
      zip_freelist(&reslist);
154
      break;
155
    }
156
  }
157
  /* if we got no central directory record, the file is incomplete */
158
  if (centraldirectoryfound == 0) zip_freelist(&reslist);
159
  return(reslist);
160
}
161
 
162
 
163
 
164
/* unzips a file. zipfd points to the open zip file, curzipnode to the entry to extract, and fulldestfilename is the destination file where to unzip it. returns 0 on success, non-zero otherwise. */
268 mateuszvis 165
int zip_unzip(FILE *zipfd, struct ziplist *curzipnode, const char *fulldestfilename) {
219 mateuszvis 166
  #define buffsize 32 * 1024l /* MUST be at least 32K */
167
  FILE *filefd;
168
  unsigned long cksum;
169
  int extract_res;
170
  unsigned char *buff;
171
  struct utimbuf filetimestamp;
172
 
173
  /* first of all, check we support the compression method */
174
  switch (curzipnode->compmethod) {
175
    case 0:  /* stored */
176
    case 8:  /* deflated */
177
      break;
178
    default: /* unsupported compression method, sorry */
179
      return(-1);
180
      break;
181
  }
182
 
183
  /* open the dst file */
184
  filefd = fopen(fulldestfilename, "wb");
185
  if (filefd == NULL) return(-2);  /* failed to open the dst file */
186
 
187
  /* allocate buffers for data I/O */
188
  buff = malloc(buffsize);
189
  if (buff == NULL) {
190
    fclose(filefd);
191
    unlink(fulldestfilename); /* remove the failed file once it is closed */
192
    return(-6);
193
  }
194
 
195
  if (fseek(zipfd, curzipnode->dataoffset, SEEK_SET) != 0) { /* set the reading position inside the zip file */
196
    free(buff);
197
    fclose(filefd);
198
    unlink(fulldestfilename); /* remove the failed file once it is closed */
199
    return(-7);
200
  }
201
  extract_res = -255;
202
 
203
  cksum = crc32_init(); /* init the crc32 */
204
 
205
  if (curzipnode->compmethod == 0) { /* if the file is stored, copy it over */
206
    long i, toread;
207
    extract_res = 0;   /* assume we will succeed */
208
    for (i = 0; i < curzipnode->filelen;) {
209
      toread = curzipnode->filelen - i;
210
      if (toread > buffsize) toread = buffsize;
211
      if (fread(buff, toread, 1, zipfd) != 1) extract_res = -3;   /* read a chunk of data */
212
      crc32_feed(&cksum, buff, toread); /* update the crc32 checksum */
213
      if (fwrite(buff, toread, 1, filefd) != 1) extract_res = -4; /* write data chunk to dst file */
214
      i += toread;
215
    }
216
  } else if (curzipnode->compmethod == 8) {  /* if the file is deflated, inflate it */
217
    extract_res = inf(zipfd, filefd, buff, &cksum, curzipnode->compressedfilelen);
218
  }
219
 
220
  /* clean up memory, close the dst file and terminates crc32 */
221
  free(buff);
222
  fclose(filefd);   /* close the dst file */
223
  crc32_finish(&cksum);
224
 
225
  /* printf("extract_res=%d / cksum_expected=%08lX / cksum_obtained=%08lX\n", extract_res, curzipnode->crc32, cksum); */
226
  if (extract_res != 0) {  /* was the extraction process successful? */
227
    unlink(fulldestfilename); /* remove the failed file */
228
    return(extract_res);
229
  }
230
  if (cksum != curzipnode->crc32) { /* is the crc32 ok after extraction? */
231
    unlink(fulldestfilename); /* remove the failed file */
232
    return(-9);
233
  }
234
  /* Set the timestamp of the new file to what was set in the zip file */
235
  filetimestamp.actime  = curzipnode->timestamp;
236
  filetimestamp.modtime = curzipnode->timestamp;
237
  utime(fulldestfilename, &filetimestamp);
238
  return(0);
239
}
240
 
241
 
242
 
243
/* Call this to free a ziplist computed by zip_listfiles() */
244
void zip_freelist(struct ziplist **ziplist) {
245
  struct ziplist *zipentrytobefreed;
246
  while (*ziplist != NULL) { /* iterate through the linked list and free all nodes */
247
    zipentrytobefreed = *ziplist;
248
    *ziplist = zipentrytobefreed->nextfile;
249
    /* free the node entry */
250
    free(zipentrytobefreed);
251
  }
252
  *ziplist = NULL;
253
}