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 }