*** empty log message ***
[swftools.git] / installer / archive.c
1 /* archive.c
2
3    Part of the swftools installer.
4    
5    Copyright (c) 2004 Matthias Kramm <kramm@quiss.org> 
6  
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
20
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <stdarg.h>
24 #ifdef WIN32
25 #include <windows.h>
26 #include <shlwapi.h>
27 #else
28 #include <sys/stat.h>
29 #endif
30 #include "archive.h"
31
32 #ifdef ZLIB
33 #include "../z/zlib.h"
34 #define ZLIB_BUFFER_SIZE 16384
35 #else
36 #include "lzma/LzmaDecode.h"
37 #endif
38
39 static int verbose = 0;
40 static void msg(char*format, ...)
41 {
42     char buf[1024];
43     int l;
44     va_list arglist;
45     if(!verbose)
46         return;
47     va_start(arglist, format);
48     vsprintf(buf, format, arglist);
49     va_end(arglist);
50     l = strlen(buf);
51     while(l && buf[l-1]=='\n') {
52         buf[l-1] = 0;
53         l--;
54     }
55     printf("(archive) %s\n", buf);
56     fflush(stdout);
57 }
58
59
60 typedef struct _reader
61 {
62     int (*read)(struct _reader*, void*data, int len);
63     void (*dealloc)(struct _reader*);
64     void *internal;
65     int pos;
66 } reader_t;
67
68 /* ---------------------------- mem reader ------------------------------- */
69
70 struct memread_t
71 {
72     unsigned char*data;
73     int length;
74 };
75 static int reader_memread(reader_t*reader, void* data, int _len) 
76 {
77     struct memread_t*mr = (struct memread_t*)reader->internal;
78
79     int len = _len;
80     if(mr->length - reader->pos < len) {
81         len = mr->length - reader->pos;
82     }
83     memcpy(data, &mr->data[reader->pos], len);
84     msg("at pos %d, asked to read %d bytes, did read %d bytes\n", reader->pos, _len, len);
85     reader->pos += len;
86     return len;
87 }
88 static void reader_memread_dealloc(reader_t*reader)
89 {
90     if(reader->internal)
91         free(reader->internal);
92     memset(reader, 0, sizeof(reader_t));
93 }
94 reader_t*reader_init_memreader(void*newdata, int newlength)
95 {
96     reader_t*r = malloc(sizeof(reader_t));
97     struct memread_t*mr = (struct memread_t*)malloc(sizeof(struct memread_t));
98     mr->data = (unsigned char*)newdata;
99     mr->length = newlength;
100     r->read = reader_memread;
101     r->dealloc = reader_memread_dealloc;
102     r->internal = (void*)mr;
103     r->pos = 0;
104     return r;
105
106 /* ---------------------------- lzma reader -------------------------- */
107 typedef struct
108 {
109     reader_t*input;
110     CLzmaDecoderState state;
111     unsigned char*mem;
112     int pos;
113     int len;
114     int lzmapos;
115     int available;
116 } lzma_t;
117
118 static void reader_lzma_dealloc(reader_t*reader)
119 {
120     lzma_t*i = (lzma_t*)reader->internal;
121     free(i->state.Probs);i->state.Probs = 0;
122     free(i->state.Dictionary);i->state.Dictionary = 0;
123     free(reader->internal);reader->internal=0;
124 }
125
126 static int reader_lzma_read(reader_t*reader, void*data, int len)
127 {
128     lzma_t*i = (lzma_t*)reader->internal;
129
130     SizeT processed = 0;
131     if(len>i->available)
132         len = i->available;
133     int ret = LzmaDecode(&i->state, 
134                          &i->mem[i->pos], i->len-i->pos, &i->lzmapos, 
135                          data, len, &processed);
136     i->available -= processed;
137     i->pos += i->lzmapos;
138     return processed;
139 }
140
141 reader_t* reader_init_lzma(void*mem, int len)
142 {
143     reader_t*r = malloc(sizeof(reader_t));
144     memset(r, 0, sizeof(reader_t));
145
146     lzma_t*i = (lzma_t*)malloc(sizeof(lzma_t));
147     memset(i, 0, sizeof(lzma_t));
148     r->internal = i;
149     r->read = reader_lzma_read;
150     r->dealloc = reader_lzma_dealloc;
151     r->pos = 0;
152
153     i->mem = mem;
154     i->len = len;
155     i->lzmapos = 0;
156
157     if(LzmaDecodeProperties(&i->state.Properties, mem, LZMA_PROPERTIES_SIZE)) {
158         printf("Couldn't decode properties\n");
159         return 0;
160     }
161     i->pos += LZMA_PROPERTIES_SIZE;
162
163     unsigned char*l = &i->mem[i->pos];
164     i->available = (long long)l[0]     | (long long)l[1]<<8  | (long long)l[2]<<16 | (long long)l[3]<<24 | 
165                   (long long)l[4]<<32 | (long long)l[5]<<40 | (long long)l[6]<<48 | (long long)l[7]<<56;
166     i->pos += 8; //uncompressed size
167
168     i->state.Probs = (CProb *)malloc(LzmaGetNumProbs(&i->state.Properties) * sizeof(CProb));
169     i->state.Dictionary = (unsigned char *)malloc(i->state.Properties.DictionarySize);
170     LzmaDecoderInit(&i->state);
171
172     return r;
173 }
174
175 #ifdef ZLIB
176 /* ---------------------------- zlibinflate reader -------------------------- */
177 struct zlibinflate_t
178 {
179     z_stream zs;
180     reader_t*input;
181     unsigned char readbuffer[ZLIB_BUFFER_SIZE];
182 };
183
184 static void zlib_error(int ret, char* msg, z_stream*zs)
185 {
186     fprintf(stderr, "%s: zlib error (%d): last zlib error: %s\n", msg, ret, zs->msg?zs->msg:"unknown");
187     perror("errno:");
188     exit(1);
189 }
190
191 static int reader_zlibinflate(reader_t*reader, void* data, int len) 
192 {
193     struct zlibinflate_t*z = (struct zlibinflate_t*)reader->internal;
194     int ret;
195     if(!z) {
196         return 0;
197     }
198     if(!len)
199         return 0;
200     
201     z->zs.next_out = (Bytef *)data;
202     z->zs.avail_out = len;
203
204     while(1) {
205         if(!z->zs.avail_in) {
206             z->zs.avail_in = z->input->read(z->input, z->readbuffer, ZLIB_BUFFER_SIZE);
207             z->zs.next_in = z->readbuffer;
208         }
209         if(z->zs.avail_in)
210             ret = inflate(&z->zs, Z_NO_FLUSH);
211         else
212             ret = inflate(&z->zs, Z_FINISH);
213     
214         if (ret != Z_OK &&
215             ret != Z_STREAM_END) zlib_error(ret, "bitio:inflate_inflate", &z->zs);
216
217         if (ret == Z_STREAM_END) {
218                 int pos = z->zs.next_out - (Bytef*)data;
219                 ret = inflateEnd(&z->zs);
220                 if (ret != Z_OK) zlib_error(ret, "bitio:inflate_end", &z->zs);
221                 free(reader->internal);
222                 reader->internal = 0;
223                 reader->pos += pos;
224                 return pos;
225         }
226         if(!z->zs.avail_out) {
227             break;
228         }
229     }
230     reader->pos += len;
231     return len;
232 }
233 static void reader_zlibinflate_dealloc(reader_t*reader)
234 {
235     struct zlibinflate_t*z = (struct zlibinflate_t*)reader->internal;
236     if(z) {
237         if(z->input) {
238             z->input->dealloc(z->input);z->input = 0;
239         }
240         inflateEnd(&z->zs);
241         free(reader->internal);
242     }
243     memset(reader, 0, sizeof(reader_t));
244 }
245 reader_t* reader_init_zlibinflate(reader_t*input)
246 {
247     reader_t*r = malloc(sizeof(reader_t));
248     struct zlibinflate_t*z;
249     int ret;
250     memset(r, 0, sizeof(reader_t));
251     z = (struct zlibinflate_t*)malloc(sizeof(struct zlibinflate_t));
252     memset(z, 0, sizeof(struct zlibinflate_t));
253     r->internal = z;
254     r->read = reader_zlibinflate;
255     r->dealloc = reader_zlibinflate_dealloc;
256     r->pos = 0;
257     z->input = input;
258     memset(&z->zs,0,sizeof(z_stream));
259     z->zs.zalloc = Z_NULL;
260     z->zs.zfree  = Z_NULL;
261     z->zs.opaque = Z_NULL;
262     ret = inflateInit(&z->zs);
263     if (ret != Z_OK) zlib_error(ret, "bitio:inflate_init", &z->zs);
264     return r;
265 }
266
267 /* -------------------------------------------------------------------------- */
268 #endif
269
270
271 static int create_directory(char*path,statusfunc_t f)
272 {
273     if(!path || !*path || (*path=='.' && (!path[1] || path[1]=='.')))
274         return 1; //nothing to do
275     while(path[0]=='.' && (path[1]=='/' || path[1]=='\\'))
276         path+=2;
277
278 #ifdef WIN32
279     if(PathIsDirectoryA(path))
280         return 1;
281 #else
282     struct stat st;
283     if(stat(path, &st)>=0) {
284         if(S_ISDIR(st.st_mode)) {
285             return 1; /* already exists */
286         }
287     }
288 #endif
289
290     if(mkdir(path,0755)<0) {
291         perror("mkdir");
292         char buf[1024];
293         sprintf(buf, "create directory \"%s\" FAILED", path);
294         f(-1, buf);
295         return 0;
296     }
297     return 1;
298 }
299 static int goto_directory(char*path,statusfunc_t f)
300 {
301     if(chdir(path)<0) {
302         char buf[1024];
303         sprintf(buf, "changing to directory \"%s\" FAILED", path);
304         f(-1, buf);
305         return 0;
306     }
307     return 1;
308 }
309 static char basenamebuf[256];
310 static char*get_directory(char*filename)
311 {
312     char*r1 = strrchr(filename, '\\');
313     char*r2 = strrchr(filename, '/');
314     char*r = r1>r2?r1:r2;
315     if(!r)
316         return "";
317     memcpy(basenamebuf, filename, r-filename);
318     basenamebuf[r-filename] = 0;
319     //msg("directory name of \"%s\" is \"%s\"", filename, basenamebuf);
320     return basenamebuf;
321 }
322 static int write_file(char*filename, reader_t*r, int len,statusfunc_t f)
323 {
324     while(filename[0]=='.' && (filename[1]=='/' || filename[1]=='\\'))
325         filename+=2;
326
327     filename=strdup(filename);
328
329     char*p = filename;
330     while(*p) {
331         if(*p=='/') *p='\\';
332         p++;
333     }
334
335     msg("create file \"%s\" (%d bytes)", filename, len);
336     FILE*fo = fopen(filename, "wb");
337
338     if(!fo) {
339         char buf[1024];
340         sprintf(buf, "Couldn't create file %s", filename);
341         f(-1, buf);
342         free(filename);
343         return 0;
344     }
345     int pos=0;
346     char buf[4096];
347     while(pos<len) {
348         int l = 4096;
349         if(pos+l>len)
350             l = len-pos;
351         int n = r->read(r, buf, l);
352         if(n < l) {
353             char buf[1024];
354             sprintf(buf, "Couldn't read byte %d (pos+%d) from input buffer for file %s", pos+n, n, filename);
355             f(-1, buf);
356             return 0;
357         }
358         fwrite(buf, l, 1, fo);
359         pos+=l;
360     }
361     fclose(fo);
362     free(filename);
363     return 1;
364 }
365
366 int unpack_archive(void*data, int len, char*destdir, statusfunc_t f)
367 {
368     reader_t*m = reader_init_memreader(data, len);
369 #ifdef ZLIB
370     reader_t*z = reader_init_zlibinflate(m);
371 #else
372     reader_t*z = reader_init_lzma(data, len);
373 #endif
374     if(!z) {
375         f(1, "Couldn't decompress installation files");
376         return 0;
377     }
378
379     f(0, "Creating installation directory");
380     if(!create_directory(destdir,f)) return 0;
381     f(0, "Changing to installation directory");
382     if(!goto_directory(destdir,f)) return 0;
383     
384     f(0, "Uncompressing files...");
385     while(1) {
386         /* read id */
387         unsigned char id[4];
388         id[3] = 0;
389         if(z->read(z, id, 3)<3) {
390             f(-1, "Unexpected end of archive");
391             return 0;
392         }
393         if(!strcmp(id, "END"))
394             break;
395
396         unsigned b1=0,b2=0,b3=0,b4=0;
397         int l = 0;
398         l+=z->read(z, &b1, 1);
399         l+=z->read(z, &b2, 1);
400         l+=z->read(z, &b3, 1);
401         l+=z->read(z, &b4, 1);
402         if(l<4)
403             return 0;
404
405         /* read size */
406         int len = b1|b2<<8|b3<<16|b4<<24;
407         
408         /* read filename */
409         unsigned char filename_len;
410         z->read(z, &filename_len, 1);
411         char*filename = malloc(filename_len+1);
412         z->read(z, filename, filename_len);
413         filename[(int)filename_len] = 0;
414
415         if(verbose) printf("[%s] %s %d\n", id, filename, len);
416         char buf[2048];
417         sprintf(buf, "[%s] %s (%d bytes)", id, filename, len);
418         f(0, buf);
419         if(!strcmp(id, "DIR")) {
420             if(!create_directory(filename,f)) return 0;
421         } else {
422             if(!create_directory(get_directory(filename),f)) return 0;
423
424             if(!write_file(filename,z,len,f)) return 0;
425         }
426     }
427     f(0, "Finishing Installation");
428     return 1;
429 }
430