urlmon: Added FIXME about unsupported pmkToLeft to BindToStorage.
[wine] / dlls / kernel32 / lzexpand.c
1 /*
2  * LZ Decompression functions
3  *
4  * Copyright 1996 Marcus Meissner
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  *
20  * NOTES
21  *
22  * The LZ (Lempel Ziv) decompression was used in win16 installation programs.
23  * It is a simple tabledriven decompression engine, the algorithm is not
24  * documented as far as I know. WINE does not contain a compressor for
25  * this format.
26  *
27  * The implementation is complete and there have been no reports of failures
28  * for some time.
29  *
30  * TODO:
31  *
32  *   o Check whether the return values are correct
33  *
34  */
35
36 #include "config.h"
37
38 #include <string.h>
39 #include <ctype.h>
40 #include <sys/types.h>
41 #include <stdarg.h>
42 #include <stdio.h>
43 #ifdef HAVE_UNISTD_H
44 # include <unistd.h>
45 #endif
46
47 #include "windef.h"
48 #include "winbase.h"
49 #include "lzexpand.h"
50
51 #include "wine/unicode.h"
52 #include "wine/debug.h"
53
54 WINE_DEFAULT_DEBUG_CHANNEL(file);
55
56 /* The readahead length of the decompressor. Reading single bytes
57  * using _lread() would be SLOW.
58  */
59 #define GETLEN  2048
60
61 #define LZ_MAGIC_LEN    8
62 #define LZ_HEADER_LEN   14
63
64 /* Format of first 14 byte of LZ compressed file */
65 struct lzfileheader {
66         BYTE    magic[LZ_MAGIC_LEN];
67         BYTE    compressiontype;
68         CHAR    lastchar;
69         DWORD   reallength;
70 };
71 static const BYTE LZMagic[LZ_MAGIC_LEN]={'S','Z','D','D',0x88,0xf0,0x27,0x33};
72
73 #define LZ_TABLE_SIZE    0x1000
74
75 struct lzstate {
76         HFILE   realfd;         /* the real filedescriptor */
77         CHAR    lastchar;       /* the last char of the filename */
78
79         DWORD   reallength;     /* the decompressed length of the file */
80         DWORD   realcurrent;    /* the position the decompressor currently is */
81         DWORD   realwanted;     /* the position the user wants to read from */
82
83         BYTE    table[LZ_TABLE_SIZE];   /* the rotating LZ table */
84         UINT    curtabent;      /* CURrent TABle ENTry */
85
86         BYTE    stringlen;      /* length and position of current string */
87         DWORD   stringpos;      /* from stringtable */
88
89
90         WORD    bytetype;       /* bitmask within blocks */
91
92         BYTE    *get;           /* GETLEN bytes */
93         DWORD   getcur;         /* current read */
94         DWORD   getlen;         /* length last got */
95 };
96
97 #define MAX_LZSTATES 16
98 static struct lzstate *lzstates[MAX_LZSTATES];
99
100 #define LZ_MIN_HANDLE  0x400
101 #define IS_LZ_HANDLE(h) (((h) >= LZ_MIN_HANDLE) && ((h) < LZ_MIN_HANDLE+MAX_LZSTATES))
102 #define GET_LZ_STATE(h) (IS_LZ_HANDLE(h) ? lzstates[(h)-LZ_MIN_HANDLE] : NULL)
103
104 /* reads one compressed byte, including buffering */
105 #define GET(lzs,b)      _lzget(lzs,&b)
106 #define GET_FLUSH(lzs)  lzs->getcur=lzs->getlen;
107
108 static int
109 _lzget(struct lzstate *lzs,BYTE *b) {
110         if (lzs->getcur<lzs->getlen) {
111                 *b              = lzs->get[lzs->getcur++];
112                 return          1;
113         } else {
114                 int ret = _lread(lzs->realfd,lzs->get,GETLEN);
115                 if (ret==HFILE_ERROR)
116                         return HFILE_ERROR;
117                 if (ret==0)
118                         return 0;
119                 lzs->getlen     = ret;
120                 lzs->getcur     = 1;
121                 *b              = *(lzs->get);
122                 return 1;
123         }
124 }
125 /* internal function, reads lzheader
126  * returns BADINHANDLE for non filedescriptors
127  * return 0 for file not compressed using LZ
128  * return UNKNOWNALG for unknown algorithm
129  * returns lzfileheader in *head
130  */
131 static INT read_header(HFILE fd,struct lzfileheader *head)
132 {
133         BYTE    buf[LZ_HEADER_LEN];
134
135         if (_llseek(fd,0,SEEK_SET)==-1)
136                 return LZERROR_BADINHANDLE;
137
138         /* We can't directly read the lzfileheader struct due to
139          * structure element alignment
140          */
141         if (_lread(fd,buf,LZ_HEADER_LEN)<LZ_HEADER_LEN)
142                 return 0;
143         memcpy(head->magic,buf,LZ_MAGIC_LEN);
144         memcpy(&(head->compressiontype),buf+LZ_MAGIC_LEN,1);
145         memcpy(&(head->lastchar),buf+LZ_MAGIC_LEN+1,1);
146
147         /* FIXME: consider endianess on non-intel architectures */
148         memcpy(&(head->reallength),buf+LZ_MAGIC_LEN+2,4);
149
150         if (memcmp(head->magic,LZMagic,LZ_MAGIC_LEN))
151                 return 0;
152         if (head->compressiontype!='A')
153                 return LZERROR_UNKNOWNALG;
154         return 1;
155 }
156
157
158 /***********************************************************************
159  *           LZStart   (KERNEL32.@)
160  */
161 INT WINAPI LZStart(void)
162 {
163     TRACE("(void)\n");
164     return 1;
165 }
166
167
168 /***********************************************************************
169  *           LZInit   (KERNEL32.@)
170  *
171  * initializes internal decompression buffers, returns lzfiledescriptor.
172  * (return value the same as hfSrc, if hfSrc is not compressed)
173  * on failure, returns error code <0
174  * lzfiledescriptors range from 0x400 to 0x410 (only 16 open files per process)
175  *
176  * since _llseek uses the same types as libc.lseek, we just use the macros of
177  *  libc
178  */
179 HFILE WINAPI LZInit( HFILE hfSrc )
180 {
181
182         struct  lzfileheader    head;
183         struct  lzstate         *lzs;
184         DWORD   ret;
185         int i;
186
187         TRACE("(%d)\n",hfSrc);
188         ret=read_header(hfSrc,&head);
189         if (ret<=0) {
190                 _llseek(hfSrc,0,SEEK_SET);
191                 return ret?ret:hfSrc;
192         }
193         for (i = 0; i < MAX_LZSTATES; i++) if (!lzstates[i]) break;
194         if (i == MAX_LZSTATES) return LZERROR_GLOBALLOC;
195         lzstates[i] = lzs = HeapAlloc( GetProcessHeap(), 0, sizeof(struct lzstate) );
196         if(lzs == NULL) return LZERROR_GLOBALLOC;
197
198         memset(lzs,'\0',sizeof(*lzs));
199         lzs->realfd     = hfSrc;
200         lzs->lastchar   = head.lastchar;
201         lzs->reallength = head.reallength;
202
203         lzs->get        = HeapAlloc( GetProcessHeap(), 0, GETLEN );
204         lzs->getlen     = 0;
205         lzs->getcur     = 0;
206
207         if(lzs->get == NULL) {
208                 HeapFree(GetProcessHeap(), 0, lzs);
209                 lzstates[i] = NULL;
210                 return LZERROR_GLOBALLOC;
211         }
212
213         /* Yes, preinitialize with spaces */
214         memset(lzs->table,' ',LZ_TABLE_SIZE);
215         /* Yes, start 16 byte from the END of the table */
216         lzs->curtabent  = 0xff0;
217         return LZ_MIN_HANDLE + i;
218 }
219
220
221 /***********************************************************************
222  *           LZDone   (KERNEL32.@)
223  */
224 void WINAPI LZDone(void)
225 {
226     TRACE("(void)\n");
227 }
228
229
230 /***********************************************************************
231  *           GetExpandedNameA   (KERNEL32.@)
232  *
233  * gets the full filename of the compressed file 'in' by opening it
234  * and reading the header
235  *
236  * "file." is being translated to "file"
237  * "file.bl_" (with lastchar 'a') is being translated to "file.bla"
238  * "FILE.BL_" (with lastchar 'a') is being translated to "FILE.BLA"
239  */
240
241 INT WINAPI GetExpandedNameA( LPSTR in, LPSTR out )
242 {
243         struct lzfileheader     head;
244         HFILE           fd;
245         OFSTRUCT        ofs;
246         INT             fnislowercased,ret,len;
247         LPSTR           s,t;
248
249         TRACE("(%s)\n",in);
250         fd=OpenFile(in,&ofs,OF_READ);
251         if (fd==HFILE_ERROR)
252                 return (INT)(INT16)LZERROR_BADINHANDLE;
253         strcpy(out,in);
254         ret=read_header(fd,&head);
255         if (ret<=0) {
256                 /* not a LZ compressed file, so the expanded name is the same
257                  * as the input name */
258                 _lclose(fd);
259                 return 1;
260         }
261
262
263         /* look for directory prefix and skip it. */
264         s=out;
265         while (NULL!=(t=strpbrk(s,"/\\:")))
266                 s=t+1;
267
268         /* now mangle the basename */
269         if (!*s) {
270                 /* FIXME: hmm. shouldn't happen? */
271                 WARN("Specified a directory or what? (%s)\n",in);
272                 _lclose(fd);
273                 return 1;
274         }
275         /* see if we should use lowercase or uppercase on the last char */
276         fnislowercased=1;
277         t=s+strlen(s)-1;
278         while (t>=out) {
279                 if (!isalpha(*t)) {
280                         t--;
281                         continue;
282                 }
283                 fnislowercased=islower(*t);
284                 break;
285         }
286         if (isalpha(head.lastchar)) {
287                 if (fnislowercased)
288                         head.lastchar=tolower(head.lastchar);
289                 else
290                         head.lastchar=toupper(head.lastchar);
291         }
292
293         /* now look where to replace the last character */
294         if (NULL!=(t=strchr(s,'.'))) {
295                 if (t[1]=='\0') {
296                         t[0]='\0';
297                 } else {
298                         len=strlen(t)-1;
299                         if (t[len]=='_')
300                                 t[len]=head.lastchar;
301                 }
302         } /* else no modification necessary */
303         _lclose(fd);
304         return 1;
305 }
306
307
308 /***********************************************************************
309  *           GetExpandedNameW   (KERNEL32.@)
310  */
311 INT WINAPI GetExpandedNameW( LPWSTR in, LPWSTR out )
312 {
313     INT ret;
314     DWORD len = WideCharToMultiByte( CP_ACP, 0, in, -1, NULL, 0, NULL, NULL );
315     char *xin = HeapAlloc( GetProcessHeap(), 0, len );
316     char *xout = HeapAlloc( GetProcessHeap(), 0, len+3 );
317     WideCharToMultiByte( CP_ACP, 0, in, -1, xin, len, NULL, NULL );
318     if ((ret = GetExpandedNameA( xin, xout )) > 0)
319         MultiByteToWideChar( CP_ACP, 0, xout, -1, out, strlenW(in)+4 );
320     HeapFree( GetProcessHeap(), 0, xin );
321     HeapFree( GetProcessHeap(), 0, xout );
322     return ret;
323 }
324
325
326 /***********************************************************************
327  *           LZRead   (KERNEL32.@)
328  */
329 INT WINAPI LZRead( HFILE fd, LPSTR vbuf, INT toread )
330 {
331         int     howmuch;
332         BYTE    b,*buf;
333         struct  lzstate *lzs;
334
335         buf=(LPBYTE)vbuf;
336         TRACE("(%d,%p,%d)\n",fd,buf,toread);
337         howmuch=toread;
338         if (!(lzs = GET_LZ_STATE(fd))) return _lread(fd,buf,toread);
339
340 /* The decompressor itself is in a define, cause we need it twice
341  * in this function. (the decompressed byte will be in b)
342  */
343 #define DECOMPRESS_ONE_BYTE                                             \
344                 if (lzs->stringlen) {                                   \
345                         b               = lzs->table[lzs->stringpos];   \
346                         lzs->stringpos  = (lzs->stringpos+1)&0xFFF;     \
347                         lzs->stringlen--;                               \
348                 } else {                                                \
349                         if (!(lzs->bytetype&0x100)) {                   \
350                                 if (1!=GET(lzs,b))                      \
351                                         return toread-howmuch;          \
352                                 lzs->bytetype = b|0xFF00;               \
353                         }                                               \
354                         if (lzs->bytetype & 1) {                        \
355                                 if (1!=GET(lzs,b))                      \
356                                         return toread-howmuch;          \
357                         } else {                                        \
358                                 BYTE    b1,b2;                          \
359                                                                         \
360                                 if (1!=GET(lzs,b1))                     \
361                                         return toread-howmuch;          \
362                                 if (1!=GET(lzs,b2))                     \
363                                         return toread-howmuch;          \
364                                 /* Format:                              \
365                                  * b1 b2                                \
366                                  * AB CD                                \
367                                  * where CAB is the stringoffset in the table\
368                                  * and D+3 is the len of the string     \
369                                  */                                     \
370                                 lzs->stringpos  = b1|((b2&0xf0)<<4);    \
371                                 lzs->stringlen  = (b2&0xf)+2;           \
372                                 /* 3, but we use a  byte already below ... */\
373                                 b               = lzs->table[lzs->stringpos];\
374                                 lzs->stringpos  = (lzs->stringpos+1)&0xFFF;\
375                         }                                               \
376                         lzs->bytetype>>=1;                              \
377                 }                                                       \
378                 /* store b in table */                                  \
379                 lzs->table[lzs->curtabent++]= b;                        \
380                 lzs->curtabent  &= 0xFFF;                               \
381                 lzs->realcurrent++;
382
383         /* if someone has seeked, we have to bring the decompressor
384          * to that position
385          */
386         if (lzs->realcurrent!=lzs->realwanted) {
387                 /* if the wanted position is before the current position
388                  * I see no easy way to unroll ... We have to restart at
389                  * the beginning. *sigh*
390                  */
391                 if (lzs->realcurrent>lzs->realwanted) {
392                         /* flush decompressor state */
393                         _llseek(lzs->realfd,LZ_HEADER_LEN,SEEK_SET);
394                         GET_FLUSH(lzs);
395                         lzs->realcurrent= 0;
396                         lzs->bytetype   = 0;
397                         lzs->stringlen  = 0;
398                         memset(lzs->table,' ',LZ_TABLE_SIZE);
399                         lzs->curtabent  = 0xFF0;
400                 }
401                 while (lzs->realcurrent<lzs->realwanted) {
402                         DECOMPRESS_ONE_BYTE;
403                 }
404         }
405
406         while (howmuch) {
407                 DECOMPRESS_ONE_BYTE;
408                 lzs->realwanted++;
409                 *buf++          = b;
410                 howmuch--;
411         }
412         return  toread;
413 #undef DECOMPRESS_ONE_BYTE
414 }
415
416
417 /***********************************************************************
418  *           LZSeek   (KERNEL32.@)
419  */
420 LONG WINAPI LZSeek( HFILE fd, LONG off, INT type )
421 {
422         struct  lzstate *lzs;
423         LONG    newwanted;
424
425         TRACE("(%d,%d,%d)\n",fd,off,type);
426         /* not compressed? just use normal _llseek() */
427         if (!(lzs = GET_LZ_STATE(fd))) return _llseek(fd,off,type);
428         newwanted = lzs->realwanted;
429         switch (type) {
430         case 1: /* SEEK_CUR */
431                 newwanted      += off;
432                 break;
433         case 2: /* SEEK_END */
434                 newwanted       = lzs->reallength-off;
435                 break;
436         default:/* SEEK_SET */
437                 newwanted       = off;
438                 break;
439         }
440         if (newwanted>lzs->reallength)
441                 return LZERROR_BADVALUE;
442         if (newwanted<0)
443                 return LZERROR_BADVALUE;
444         lzs->realwanted = newwanted;
445         return newwanted;
446 }
447
448
449 /***********************************************************************
450  *           LZCopy   (KERNEL32.@)
451  *
452  * Copies everything from src to dest
453  * if src is a LZ compressed file, it will be uncompressed.
454  * will return the number of bytes written to dest or errors.
455  */
456 LONG WINAPI LZCopy( HFILE src, HFILE dest )
457 {
458         int     usedlzinit = 0, ret, wret;
459         LONG    len;
460         HFILE   oldsrc = src, srcfd;
461         FILETIME filetime;
462         struct  lzstate *lzs;
463 #define BUFLEN  1000
464         CHAR    buf[BUFLEN];
465         /* we need that weird typedef, for i can't seem to get function pointer
466          * casts right. (Or they probably just do not like WINAPI in general)
467          */
468         typedef UINT    (WINAPI *_readfun)(HFILE,LPVOID,UINT);
469
470         _readfun        xread;
471
472         TRACE("(%d,%d)\n",src,dest);
473         if (!IS_LZ_HANDLE(src)) {
474                 src = LZInit(src);
475                 if ((INT)src <= 0) return 0;
476                 if (src != oldsrc) usedlzinit=1;
477         }
478
479         /* not compressed? just copy */
480         if (!IS_LZ_HANDLE(src))
481                 xread=_lread;
482         else
483                 xread=(_readfun)LZRead;
484         len=0;
485         while (1) {
486                 ret=xread(src,buf,BUFLEN);
487                 if (ret<=0) {
488                         if (ret==0)
489                                 break;
490                         if (ret==-1)
491                                 return LZERROR_READ;
492                         return ret;
493                 }
494                 len    += ret;
495                 wret    = _lwrite(dest,buf,ret);
496                 if (wret!=ret)
497                         return LZERROR_WRITE;
498         }
499
500         /* Maintain the timestamp of source file to destination file */
501         srcfd = (!(lzs = GET_LZ_STATE(src))) ? src : lzs->realfd;
502         GetFileTime( LongToHandle(srcfd), NULL, NULL, &filetime );
503         SetFileTime( LongToHandle(dest), NULL, NULL, &filetime );
504
505         /* close handle */
506         if (usedlzinit)
507                 LZClose(src);
508         return len;
509 #undef BUFLEN
510 }
511
512 /* reverses GetExpandedPathname */
513 static LPSTR LZEXPAND_MangleName( LPCSTR fn )
514 {
515     char *p;
516     char *mfn = HeapAlloc( GetProcessHeap(), 0, strlen(fn) + 3 ); /* "._" and \0 */
517     if(mfn == NULL) return NULL;
518     strcpy( mfn, fn );
519     if (!(p = strrchr( mfn, '\\' ))) p = mfn;
520     if ((p = strchr( p, '.' )))
521     {
522         p++;
523         if (strlen(p) < 3) strcat( p, "_" );  /* append '_' */
524         else p[strlen(p)-1] = '_';  /* replace last character */
525     }
526     else strcat( mfn, "._" );   /* append "._" */
527     return mfn;
528 }
529
530
531 /***********************************************************************
532  *           LZOpenFileA   (KERNEL32.@)
533  *
534  * Opens a file. If not compressed, open it as a normal file.
535  */
536 HFILE WINAPI LZOpenFileA( LPSTR fn, LPOFSTRUCT ofs, WORD mode )
537 {
538         HFILE   fd,cfd;
539
540         TRACE("(%s,%p,%d)\n",fn,ofs,mode);
541         /* 0x70 represents all OF_SHARE_* flags, ignore them for the check */
542         fd=OpenFile(fn,ofs,mode);
543         if (fd==HFILE_ERROR)
544         {
545             LPSTR mfn = LZEXPAND_MangleName(fn);
546             fd = OpenFile(mfn,ofs,mode);
547             HeapFree( GetProcessHeap(), 0, mfn );
548         }
549         if ((mode&~0x70)!=OF_READ)
550                 return fd;
551         if (fd==HFILE_ERROR)
552                 return HFILE_ERROR;
553         cfd=LZInit(fd);
554         if ((INT)cfd <= 0) return fd;
555         return cfd;
556 }
557
558
559 /***********************************************************************
560  *           LZOpenFileW   (KERNEL32.@)
561  */
562 HFILE WINAPI LZOpenFileW( LPWSTR fn, LPOFSTRUCT ofs, WORD mode )
563 {
564     HFILE ret;
565     DWORD len = WideCharToMultiByte( CP_ACP, 0, fn, -1, NULL, 0, NULL, NULL );
566     LPSTR xfn = HeapAlloc( GetProcessHeap(), 0, len );
567     WideCharToMultiByte( CP_ACP, 0, fn, -1, xfn, len, NULL, NULL );
568     ret = LZOpenFileA(xfn,ofs,mode);
569     HeapFree( GetProcessHeap(), 0, xfn );
570     return ret;
571 }
572
573
574 /***********************************************************************
575  *           LZClose   (KERNEL32.@)
576  */
577 void WINAPI LZClose( HFILE fd )
578 {
579         struct lzstate *lzs;
580
581         TRACE("(%d)\n",fd);
582         if (!(lzs = GET_LZ_STATE(fd))) _lclose(fd);
583         else
584         {
585             HeapFree( GetProcessHeap(), 0, lzs->get );
586             CloseHandle( LongToHandle(lzs->realfd) );
587             lzstates[fd - LZ_MIN_HANDLE] = NULL;
588             HeapFree( GetProcessHeap(), 0, lzs );
589         }
590 }