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