2 * LZ Decompression functions
4 * Copyright 1996 Marcus Meissner
7 * FIXME: return values might be wrong
15 #include <sys/types.h>
25 /* The readahead length of the decompressor. Reading single bytes
26 * using _lread() would be SLOW.
30 /* Format of first 14 byte of LZ compressed file */
37 static BYTE LZMagic[8]={'S','Z','D','D',0x88,0xf0,0x27,0x33};
39 static struct lzstate {
40 HFILE32 lzfd; /* the handle used by the program */
41 HFILE32 realfd; /* the real filedescriptor */
42 CHAR lastchar; /* the last char of the filename */
44 DWORD reallength; /* the decompressed length of the file */
45 DWORD realcurrent; /* the position the decompressor currently is */
46 DWORD realwanted; /* the position the user wants to read from */
48 BYTE table[0x1000]; /* the rotating LZ table */
49 UINT32 curtabent; /* CURrent TABle ENTry */
51 BYTE stringlen; /* length and position of current string */
52 DWORD stringpos; /* from stringtable */
55 WORD bytetype; /* bitmask within blocks */
57 BYTE *get; /* GETLEN bytes */
58 DWORD getcur; /* current read */
59 DWORD getlen; /* length last got */
61 static int nroflzstates=0;
63 /* reads one compressed byte, including buffering */
64 #define GET(lzs,b) _lzget(lzs,&b)
65 #define GET_FLUSH(lzs) lzs->getcur=lzs->getlen;
68 _lzget(struct lzstate *lzs,BYTE *b) {
69 if (lzs->getcur<lzs->getlen) {
70 *b = lzs->get[lzs->getcur++];
73 int ret = _lread32(lzs->realfd,lzs->get,GETLEN);
74 if (ret==HFILE_ERROR32)
84 /* internal function, reads lzheader
85 * returns BADINHANDLE for non filedescriptors
86 * return 0 for file not compressed using LZ
87 * return UNKNOWNALG for unknown algorithm
88 * returns lzfileheader in *head
90 static INT32 read_header(HFILE32 fd,struct lzfileheader *head)
94 if (_llseek32(fd,0,SEEK_SET)==-1)
95 return LZERROR_BADINHANDLE;
97 /* We can't directly read the lzfileheader struct due to
98 * structure element alignment
100 if (_lread32(fd,buf,14)<14)
102 memcpy(head->magic,buf,8);
103 memcpy(&(head->compressiontype),buf+8,1);
104 memcpy(&(head->lastchar),buf+9,1);
106 /* FIXME: consider endianess on non-intel architectures */
107 memcpy(&(head->reallength),buf+10,4);
109 if (memcmp(head->magic,LZMagic,8))
111 if (head->compressiontype!='A')
112 return LZERROR_UNKNOWNALG;
116 /***********************************************************************
117 * LZStart16 (LZEXPAND.7)
119 INT16 WINAPI LZStart16(void)
121 dprintf_info(file,"LZStart16(void)\n");
126 /***********************************************************************
129 INT32 WINAPI LZStart32(void)
131 dprintf_info(file,"LZStart32(void)\n");
136 /***********************************************************************
137 * LZInit16 (LZEXPAND.3)
139 HFILE16 WINAPI LZInit16( HFILE16 hfSrc )
141 return LZInit32( hfSrc );
145 /***********************************************************************
148 * initializes internal decompression buffers, returns lzfiledescriptor.
149 * (return value the same as hfSrc, if hfSrc is not compressed)
150 * on failure, returns error code <0
151 * lzfiledescriptors range from 0x400 to 0x410 (only 16 open files per process)
152 * we use as much as we need, we just OR 0x400 to the passed HFILE.
154 * since _llseek uses the same types as libc.lseek, we just use the macros of
157 HFILE32 WINAPI LZInit32( HFILE32 hfSrc )
160 struct lzfileheader head;
164 dprintf_info(file,"LZInit(%d)\n",hfSrc);
165 ret=read_header(hfSrc,&head);
167 _llseek32(hfSrc,0,SEEK_SET);
168 return ret?ret:hfSrc;
170 lzstates = HeapReAlloc( SystemHeap, 0, lzstates,
171 (++nroflzstates)*sizeof(struct lzstate) );
172 lzs = lzstates+(nroflzstates-1);
174 memset(lzs,'\0',sizeof(*lzs));
176 lzs->lzfd = hfSrc | 0x400;
177 lzs->lastchar = head.lastchar;
178 lzs->reallength = head.reallength;
180 lzs->get = HEAP_xalloc( GetProcessHeap(), 0, GETLEN );
184 /* Yes, preinitialize with spaces */
185 memset(lzs->table,' ',0x1000);
186 /* Yes, start 16 byte from the END of the table */
187 lzs->curtabent = 0xff0;
192 /***********************************************************************
193 * LZDone (LZEXPAND.9) (LZ32.8)
195 void WINAPI LZDone(void)
197 dprintf_info(file,"LZDone()\n");
201 /***********************************************************************
202 * GetExpandedName16 (LZEXPAND.10)
204 INT16 WINAPI GetExpandedName16( LPCSTR in, LPSTR out )
206 return (INT16)GetExpandedName32A( in, out );
210 /***********************************************************************
211 * GetExpandedName32A (LZ32.9)
213 * gets the full filename of the compressed file 'in' by opening it
214 * and reading the header
216 * "file." is being translated to "file"
217 * "file.bl_" (with lastchar 'a') is being translated to "file.bla"
218 * "FILE.BL_" (with lastchar 'a') is being translated to "FILE.BLA"
221 INT32 WINAPI GetExpandedName32A( LPCSTR in, LPSTR out )
223 struct lzfileheader head;
226 INT32 fnislowercased,ret,len;
229 dprintf_info(file,"GetExpandedName(%s)\n",in);
230 fd=OpenFile32(in,&ofs,OF_READ);
231 if (fd==HFILE_ERROR32)
232 return (INT32)(INT16)LZERROR_BADINHANDLE;
234 ret=read_header(fd,&head);
236 /* not a LZ compressed file, so the expanded name is the same
237 * as the input name */
243 /* look for directory prefix and skip it. */
245 while (NULL!=(t=strpbrk(s,"/\\:")))
248 /* now mangle the basename */
250 /* FIXME: hmm. shouldn't happen? */
251 fprintf(stddeb,__FILE__":GetExpandedFileName(), specified a directory or what? (%s)\n",in);
255 /* see if we should use lowercase or uppercase on the last char */
263 fnislowercased=islower(*t);
266 if (isalpha(head.lastchar)) {
268 head.lastchar=tolower(head.lastchar);
270 head.lastchar=toupper(head.lastchar);
273 /* now look where to replace the last character */
274 if (NULL!=(t=strchr(s,'.'))) {
280 t[len]=head.lastchar;
282 } /* else no modification necessary */
288 /***********************************************************************
289 * GetExpandedName32W (LZ32.11)
291 INT32 WINAPI GetExpandedName32W( LPCWSTR in, LPWSTR out )
296 xout = HeapAlloc( GetProcessHeap(), 0, lstrlen32W(in)+3 );
297 xin = HEAP_strdupWtoA( GetProcessHeap(), 0, in );
298 ret = GetExpandedName16(xin,xout);
299 if (ret>0) lstrcpyAtoW(out,xout);
300 HeapFree( GetProcessHeap(), 0, xin );
301 HeapFree( GetProcessHeap(), 0, xout );
306 /***********************************************************************
307 * LZRead16 (LZEXPAND.5)
309 INT16 WINAPI LZRead16( HFILE16 fd, LPVOID buf, UINT16 toread )
311 return LZRead32(fd,buf,toread);
315 /***********************************************************************
318 INT32 WINAPI LZRead32( HFILE32 fd, LPVOID vbuf, UINT32 toread )
325 dprintf_info(file,"LZRead32(%d,%p,%d)\n",fd,buf,toread);
327 for (i=0;i<nroflzstates;i++)
328 if (lzstates[i].lzfd==fd)
331 return _lread32(fd,buf,toread);
334 /* The decompressor itself is in a define, cause we need it twice
335 * in this function. (the decompressed byte will be in b)
337 #define DECOMPRESS_ONE_BYTE \
338 if (lzs->stringlen) { \
339 b = lzs->table[lzs->stringpos]; \
340 lzs->stringpos = (lzs->stringpos+1)&0xFFF; \
343 if (!(lzs->bytetype&0x100)) { \
345 return toread-howmuch; \
346 lzs->bytetype = b|0xFF00; \
348 if (lzs->bytetype & 1) { \
350 return toread-howmuch; \
354 if (1!=GET(lzs,b1)) \
355 return toread-howmuch; \
356 if (1!=GET(lzs,b2)) \
357 return toread-howmuch; \
361 * where CAB is the stringoffset in the table\
362 * and D+3 is the len of the string \
364 lzs->stringpos = b1|((b2&0xf0)<<4); \
365 lzs->stringlen = (b2&0xf)+2; \
366 /* 3, but we use a byte already below ... */\
367 b = lzs->table[lzs->stringpos];\
368 lzs->stringpos = (lzs->stringpos+1)&0xFFF;\
372 /* store b in table */ \
373 lzs->table[lzs->curtabent++]= b; \
374 lzs->curtabent &= 0xFFF; \
377 /* if someone has seeked, we have to bring the decompressor
380 if (lzs->realcurrent!=lzs->realwanted) {
381 /* if the wanted position is before the current position
382 * I see no easy way to unroll ... We have to restart at
383 * the beginning. *sigh*
385 if (lzs->realcurrent>lzs->realwanted) {
386 /* flush decompressor state */
387 _llseek32(lzs->realfd,14,SEEK_SET);
392 memset(lzs->table,' ',0x1000);
393 lzs->curtabent = 0xFF0;
395 while (lzs->realcurrent<lzs->realwanted) {
407 #undef DECOMPRESS_ONE_BYTE
411 /***********************************************************************
412 * LZSeek16 (LZEXPAND.4)
414 LONG WINAPI LZSeek16( HFILE16 fd, LONG off, INT16 type )
416 return LZSeek32( fd, off, type );
420 /***********************************************************************
423 LONG WINAPI LZSeek32( HFILE32 fd, LONG off, INT32 type )
429 dprintf_info(file,"LZSeek(%d,%ld,%d)\n",fd,off,type);
430 for (i=0;i<nroflzstates;i++)
431 if (lzstates[i].lzfd==fd)
433 /* not compressed? just use normal _llseek() */
435 return _llseek32(fd,off,type);
437 newwanted = lzs->realwanted;
439 case 1: /* SEEK_CUR */
442 case 2: /* SEEK_END */
443 newwanted = lzs->reallength-off;
445 default:/* SEEK_SET */
449 if (newwanted>lzs->reallength)
450 return LZERROR_BADVALUE;
452 return LZERROR_BADVALUE;
453 lzs->realwanted = newwanted;
458 /***********************************************************************
459 * LZCopy16 (LZEXPAND.1)
461 LONG WINAPI LZCopy16( HFILE16 src, HFILE16 dest )
463 return LZCopy32( src, dest );
467 /***********************************************************************
470 * Copies everything from src to dest
471 * if src is a LZ compressed file, it will be uncompressed.
472 * will return the number of bytes written to dest or errors.
474 LONG WINAPI LZCopy32( HFILE32 src, HFILE32 dest )
480 INT32 WINAPI (*xread)(HFILE32,LPVOID,UINT32);
482 dprintf_info(file,"LZCopy(%d,%d)\n",src,dest);
483 for (i=0;i<nroflzstates;i++)
484 if (src==lzstates[i].lzfd)
487 /* not compressed? just copy */
489 xread=(INT32(*)(HFILE32,LPVOID,UINT32))_lread32;
494 ret=xread(src,buf,BUFLEN);
503 wret = _lwrite32(dest,buf,ret);
505 return LZERROR_WRITE;
511 /* reverses GetExpandedPathname */
512 static LPSTR LZEXPAND_MangleName( LPCSTR fn )
515 char *mfn = (char *)HEAP_xalloc( GetProcessHeap(), 0,
516 strlen(fn) + 3 ); /* "._" and \0 */
518 if (!(p = strrchr( mfn, '\\' ))) p = mfn;
519 if ((p = strchr( p, '.' )))
522 if (strlen(p) < 3) strcat( p, "_" ); /* append '_' */
523 else p[strlen(p)-1] = '_'; /* replace last character */
525 else strcat( mfn, "._" ); /* append "._" */
530 /***********************************************************************
531 * LZOpenFile16 (LZEXPAND.2)
533 HFILE16 WINAPI LZOpenFile16( LPCSTR fn, LPOFSTRUCT ofs, UINT16 mode )
535 return LZOpenFile32A( fn, ofs, mode );
539 /***********************************************************************
540 * LZOpenFile32A (LZ32.1)
542 * Opens a file. If not compressed, open it as a normal file.
544 HFILE32 WINAPI LZOpenFile32A( LPCSTR fn, LPOFSTRUCT ofs, UINT32 mode )
548 dprintf_info(file,"LZOpenFile(%s,%p,%d)\n",fn,ofs,mode);
549 /* 0x70 represents all OF_SHARE_* flags, ignore them for the check */
550 fd=OpenFile32(fn,ofs,mode);
551 if (fd==HFILE_ERROR32)
553 LPSTR mfn = LZEXPAND_MangleName(fn);
554 fd = OpenFile32(mfn,ofs,mode);
555 HeapFree( GetProcessHeap(), 0, mfn );
557 if ((mode&~0x70)!=OF_READ)
559 if (fd==HFILE_ERROR32)
560 return HFILE_ERROR32;
568 /***********************************************************************
569 * LZOpenFile32W (LZ32.10)
571 HFILE32 WINAPI LZOpenFile32W( LPCWSTR fn, LPOFSTRUCT ofs, UINT32 mode )
577 xfn = HEAP_strdupWtoA( GetProcessHeap(), 0, fn);
578 ret = LZOpenFile16(xfn,ofs,mode);
579 HeapFree( GetProcessHeap(), 0, xfn );
580 if (ret!=HFILE_ERROR32) {
581 /* ofs->szPathName is an array with the OFSTRUCT */
582 yfn = HEAP_strdupAtoW( GetProcessHeap(), 0, ofs->szPathName );
583 memcpy(ofs->szPathName,yfn,lstrlen32W(yfn)*2+2);
584 HeapFree( GetProcessHeap(), 0, yfn );
590 /***********************************************************************
591 * LZClose16 (LZEXPAND.6)
593 void WINAPI LZClose16( HFILE16 fd )
595 return LZClose32( fd );
599 /***********************************************************************
602 void WINAPI LZClose32( HFILE32 fd )
606 dprintf_info(file,"LZClose(%d)\n",fd);
607 for (i=0;i<nroflzstates;i++)
608 if (lzstates[i].lzfd==fd)
610 if (i==nroflzstates) {
615 HeapFree( GetProcessHeap(), 0, lzstates[i].get );
616 _lclose32(lzstates[i].realfd);
617 memmove(lzstates+i,lzstates+i+1,
618 sizeof(struct lzstate)*(nroflzstates-i-1));
620 lzstates = HeapReAlloc( SystemHeap, 0, lzstates,
621 sizeof(struct lzstate)*nroflzstates );
624 /***********************************************************************
625 * CopyLZFile16 (LZEXPAND.8)
627 LONG WINAPI CopyLZFile16( HFILE16 src, HFILE16 dest )
629 dprintf_info(file,"CopyLZFile16(%d,%d)\n",src,dest);
630 return LZCopy32(src,dest);
634 /***********************************************************************
635 * CopyLZFile32 (LZ32.7)
637 * Copy src to dest (including uncompressing src).
638 * NOTE: Yes. This is exactly the same function as LZCopy.
640 LONG WINAPI CopyLZFile32( HFILE32 src, HFILE32 dest )
642 dprintf_info(file,"CopyLZFile32(%d,%d)\n",src,dest);
643 return LZCopy32(src,dest);