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