misc/ver.c

   1 /*
   2  * Implementation of VER.DLL
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  */
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <ctype.h>
  10 #include "windows.h"
  11 #include "win.h"
  12 #include "winerror.h"
  13 #include "heap.h"
  14 #include "ver.h"
  15 #include "lzexpand.h"
  16 #include "module.h"
  17 #include "neexe.h"
  18 #include "stddebug.h"
  19 #include "debug.h"
  20 #include "xmalloc.h"
  21 #include "winreg.h"
  22
  23 #define LZREAD(what) \
  24   if (sizeof(*what)!=LZRead32(lzfd,what,sizeof(*what))) return 0;
  25 #define LZTELL(lzfd) LZSeek32(lzfd, 0, SEEK_CUR);
  26
  27 int
  28 read_ne_header(HFILE32 lzfd,struct ne_header_s *nehd) {
  29         struct  mz_header_s     mzh;
  30
  31         LZSeek32(lzfd,0,SEEK_SET);
  32         if (sizeof(mzh)!=LZRead32(lzfd,&mzh,sizeof(mzh)))
  33                 return 0;
  34         if (mzh.mz_magic!=MZ_SIGNATURE)
  35                 return 0;
  36         LZSeek32(lzfd,mzh.ne_offset,SEEK_SET);
  37         LZREAD(nehd);
  38         if (nehd->ne_magic == NE_SIGNATURE) {
  39                 LZSeek32(lzfd,mzh.ne_offset,SEEK_SET);
  40                 return 1;
  41         }
  42         fprintf(stderr,"misc/ver.c:read_ne_header:can't handle PE files yet.\n");
  43         /* must handle PE files too. Later. */
  44         return 0;
  45 }
  46
  47
  48 int
  49 find_ne_resource(
  50         HFILE32 lzfd,struct ne_header_s *nehd,SEGPTR typeid,SEGPTR resid,
  51         BYTE **resdata,int *reslen,DWORD *off
  52 ) {
  53         NE_TYPEINFO     ti;
  54         NE_NAMEINFO     ni;
  55         int             i;
  56         WORD            shiftcount;
  57         DWORD           nehdoffset;
  58
  59         nehdoffset = LZTELL(lzfd);
  60         LZSeek32(lzfd,nehd->resource_tab_offset,SEEK_CUR);
  61         LZREAD(&shiftcount);
  62         dprintf_ver(stddeb,"shiftcount is %d\n",shiftcount);
  63         dprintf_ver(stddeb,"reading resource typeinfo dir.\n");
  64
  65         if (!HIWORD(typeid)) typeid = (SEGPTR)(LOWORD(typeid) | 0x8000);
  66         if (!HIWORD(resid))  resid  = (SEGPTR)(LOWORD(resid) | 0x8000);
  67         while (1) {
  68                 int     skipflag;
  69
  70                 LZREAD(&ti);
  71                 if (!ti.type_id)
  72                         return 0;
  73                 dprintf_ver(stddeb,"    ti.typeid =%04x,count=%d\n",ti.type_id,ti.count);
  74                 skipflag=0;
  75                 if (!HIWORD(typeid)) {
  76                         if ((ti.type_id&0x8000)&&(typeid!=ti.type_id))
  77                                 skipflag=1;
  78                 } else {
  79                         if (ti.type_id & 0x8000) {
  80                                 skipflag=1;
  81                         } else {
  82                                 BYTE    len;
  83                                 char    *str;
  84                                 DWORD   whereleft;
  85
  86                                 whereleft = LZTELL(lzfd);
  87                                 LZSeek32(
  88                                         lzfd,
  89                                         nehdoffset+nehd->resource_tab_offset+ti.type_id,
  90                                         SEEK_SET
  91                                 );
  92                                 LZREAD(&len);
  93                                 str=xmalloc(len);
  94                                 if (len!=LZRead32(lzfd,str,len))
  95                                         return 0;
  96                                 dprintf_ver(stddeb,"read %s to compare it with %s\n",
  97                                         str,(char*)PTR_SEG_TO_LIN(typeid)
  98                                 );
  99                                 if (lstrcmpi32A(str,(char*)PTR_SEG_TO_LIN(typeid)))
 100                                         skipflag=1;
 101                                 free(str);
 102                                 LZSeek32(lzfd,whereleft,SEEK_SET);
 103                         }
 104                 }
 105                 if (skipflag) {
 106                         LZSeek32(lzfd,ti.count*sizeof(ni),SEEK_CUR);
 107                         continue;
 108                 }
 109                 for (i=0;i<ti.count;i++) {
 110                         WORD    *rdata;
 111                         int     len;
 112
 113                         LZREAD(&ni);
 114                         dprintf_ver(stddeb,"    ni.id=%4x,offset=%d,length=%d\n",
 115                                 ni.id,ni.offset,ni.length
 116                         );
 117                         skipflag=1;
 118                         if (!HIWORD(resid)) {
 119                                 if (ni.id == resid)
 120                                         skipflag=0;
 121                         } else {
 122                                 if (!(ni.id & 0x8000)) {
 123                                         BYTE    len;
 124                                         char    *str;
 125                                         DWORD   whereleft;
 126
 127                                         whereleft = LZTELL(lzfd);
 128                                           LZSeek32(
 129                                                 lzfd,
 130                                                 nehdoffset+nehd->resource_tab_offset+ni.id,
 131                                                 SEEK_SET
 132                                         );
 133                                         LZREAD(&len);
 134                                         str=xmalloc(len);
 135                                         if (len!=LZRead32(lzfd,str,len))
 136                                                 return 0;
 137                                         dprintf_ver(stddeb,"read %s to compare it with %s\n",
 138                                                 str,(char*)PTR_SEG_TO_LIN(typeid)
 139                                         );
 140                                         if (!lstrcmpi32A(str,(char*)PTR_SEG_TO_LIN(typeid)))
 141                                                 skipflag=0;
 142                                         free(str);
 143                                         LZSeek32(lzfd,whereleft,SEEK_SET);
 144                                 }
 145                         }
 146                         if (skipflag)
 147                                 continue;
 148                         LZSeek32(lzfd,((int)ni.offset<<shiftcount),SEEK_SET);
 149                         *off    = (int)ni.offset<<shiftcount;
 150                         len     = ni.length<<shiftcount;
 151                         rdata=(WORD*)xmalloc(len);
 152                         if (len!=LZRead32(lzfd,rdata,len)) {
 153                                 free(rdata);
 154                                 return 0;
 155                         }
 156                         dprintf_ver(stddeb,"resource found.\n");
 157                         *resdata= (BYTE*)rdata;
 158                         *reslen = len;
 159                         return 1;
 160                 }
 161         }
 162 }
 163
 164 /* GetFileResourceSize                          [VER.2] */
 165 DWORD
 166 GetFileResourceSize(LPCSTR filename,SEGPTR restype,SEGPTR resid,LPDWORD off) {
 167         HFILE32 lzfd;
 168         OFSTRUCT        ofs;
 169         BYTE    *resdata;
 170         int     reslen;
 171         struct  ne_header_s     nehd;
 172
 173         dprintf_ver(stddeb,"GetFileResourceSize(%s,%lx,%lx,%p)\n",
 174                 filename,(LONG)restype,(LONG)resid,off
 175         );
 176         lzfd=LZOpenFile32A(filename,&ofs,OF_READ);
 177         if (lzfd==0)
 178                 return 0;
 179         if (!read_ne_header(lzfd,&nehd)) {
 180                 LZClose32(lzfd);
 181                 return 0;
 182         }
 183         if (!find_ne_resource(lzfd,&nehd,restype,resid,&resdata,&reslen,off)) {
 184                 LZClose32(lzfd);
 185                 return 0;
 186         }
 187         free(resdata);
 188         LZClose32(lzfd);
 189         return reslen;
 190 }
 191
 192 /* GetFileResource                              [VER.3] */
 193 DWORD
 194 GetFileResource(LPCSTR filename,SEGPTR restype,SEGPTR resid,
 195                 DWORD off,DWORD datalen,LPVOID data
 196 ) {
 197         HFILE32 lzfd;
 198         OFSTRUCT        ofs;
 199         BYTE    *resdata;
 200         int     reslen=datalen;
 201         struct  ne_header_s     nehd;
 202         dprintf_ver(stddeb,"GetFileResource(%s,%lx,%lx,%ld,%ld,%p)\n",
 203                 filename,(LONG)restype,(LONG)resid,off,datalen,data
 204         );
 205
 206         lzfd=LZOpenFile32A(filename,&ofs,OF_READ);
 207         if (lzfd==0)
 208                 return 0;
 209         if (!off) {
 210                 if (!read_ne_header(lzfd,&nehd)) {
 211                         LZClose32(lzfd);
 212                         return 0;
 213                 }
 214                 if (!find_ne_resource(lzfd,&nehd,restype,resid,&resdata,&reslen,&off)) {
 215                         LZClose32(lzfd);
 216                         return 0;
 217                 }
 218                 free(resdata);
 219         }
 220         LZSeek32(lzfd,off,SEEK_SET);
 221         if (reslen>datalen)
 222                 reslen=datalen;
 223         LZRead32(lzfd,data,reslen);
 224         LZClose32(lzfd);
 225         return reslen;
 226 }
 227
 228 /* GetFileVersionInfoSize                       [VER.6] */
 229 DWORD
 230 GetFileVersionInfoSize16(LPCSTR filename,LPDWORD handle) {
 231         DWORD   len,ret;
 232         BYTE    buf[72];
 233         VS_FIXEDFILEINFO *vffi;
 234
 235         dprintf_ver(stddeb,"GetFileVersionInfoSize16(%s,%p)\n",filename,handle);
 236         len=GetFileResourceSize(filename,VS_FILE_INFO,VS_VERSION_INFO,handle);
 237         if (!len)
 238                 return 0;
 239         ret=GetFileResource(
 240                 filename,VS_FILE_INFO,VS_VERSION_INFO,*handle,sizeof(buf),buf
 241         );
 242         if (!ret)
 243                 return 0;
 244
 245         vffi=(VS_FIXEDFILEINFO*)(buf+0x14);
 246         if (vffi->dwSignature != VS_FFI_SIGNATURE)
 247                 return 0;
 248         if (*(WORD*)buf < len)
 249                 len = *(WORD*)buf;
 250         dprintf_ver(stddeb,"->strucver=%ld.%ld,filever=%ld.%ld,productver=%ld.%ld,flagmask=%lx,flags=%lx,OS=",
 251                 (vffi->dwStrucVersion>>16),vffi->dwStrucVersion&0xFFFF,
 252                 vffi->dwFileVersionMS,vffi->dwFileVersionLS,
 253                 vffi->dwProductVersionMS,vffi->dwProductVersionLS,
 254                 vffi->dwFileFlagsMask,vffi->dwFileFlags
 255         );
 256         switch (vffi->dwFileOS&0xFFFF0000) {
 257         case VOS_DOS:dprintf_ver(stddeb,"DOS,");break;
 258         case VOS_OS216:dprintf_ver(stddeb,"OS/2-16,");break;
 259         case VOS_OS232:dprintf_ver(stddeb,"OS/2-32,");break;
 260         case VOS_NT:dprintf_ver(stddeb,"NT,");break;
 261         case VOS_UNKNOWN:
 262         default:
 263                 dprintf_ver(stddeb,"UNKNOWN(%ld),",vffi->dwFileOS&0xFFFF0000);break;
 264         }
 265         switch (vffi->dwFileOS & 0xFFFF) {
 266         case VOS__BASE:dprintf_ver(stddeb,"BASE");break;
 267         case VOS__WINDOWS16:dprintf_ver(stddeb,"WIN16");break;
 268         case VOS__WINDOWS32:dprintf_ver(stddeb,"WIN32");break;
 269         case VOS__PM16:dprintf_ver(stddeb,"PM16");break;
 270         case VOS__PM32:dprintf_ver(stddeb,"PM32");break;
 271         default:dprintf_ver(stddeb,"UNKNOWN(%ld)",vffi->dwFileOS&0xFFFF);break;
 272         }
 273         switch (vffi->dwFileType) {
 274         default:
 275         case VFT_UNKNOWN:
 276                 dprintf_ver(stddeb,"filetype=Unknown(%ld)",vffi->dwFileType);
 277                 break;
 278         case VFT_APP:dprintf_ver(stddeb,"filetype=APP");break;
 279         case VFT_DLL:dprintf_ver(stddeb,"filetype=DLL");break;
 280         case VFT_DRV:
 281                 dprintf_ver(stddeb,"filetype=DRV,");
 282                 switch(vffi->dwFileSubtype) {
 283                 default:
 284                 case VFT2_UNKNOWN:
 285                         dprintf_ver(stddeb,"UNKNOWN(%ld)",vffi->dwFileSubtype);
 286                         break;
 287                 case VFT2_DRV_PRINTER:
 288                         dprintf_ver(stddeb,"PRINTER");
 289                         break;
 290                 case VFT2_DRV_KEYBOARD:
 291                         dprintf_ver(stddeb,"KEYBOARD");
 292                         break;
 293                 case VFT2_DRV_LANGUAGE:
 294                         dprintf_ver(stddeb,"LANGUAGE");
 295                         break;
 296                 case VFT2_DRV_DISPLAY:
 297                         dprintf_ver(stddeb,"DISPLAY");
 298                         break;
 299                 case VFT2_DRV_MOUSE:
 300                         dprintf_ver(stddeb,"MOUSE");
 301                         break;
 302                 case VFT2_DRV_NETWORK:
 303                         dprintf_ver(stddeb,"NETWORK");
 304                         break;
 305                 case VFT2_DRV_SYSTEM:
 306                         dprintf_ver(stddeb,"SYSTEM");
 307                         break;
 308                 case VFT2_DRV_INSTALLABLE:
 309                         dprintf_ver(stddeb,"INSTALLABLE");
 310                         break;
 311                 case VFT2_DRV_SOUND:
 312                         dprintf_ver(stddeb,"SOUND");
 313                         break;
 314                 case VFT2_DRV_COMM:
 315                         dprintf_ver(stddeb,"COMM");
 316                         break;
 317                 case VFT2_DRV_INPUTMETHOD:
 318                         dprintf_ver(stddeb,"INPUTMETHOD");
 319                         break;
 320                 }
 321                 break;
 322         case VFT_FONT:
 323                 dprintf_ver(stddeb,"filetype=FONT.");
 324                 switch (vffi->dwFileSubtype) {
 325                 default:
 326                         dprintf_ver(stddeb,"UNKNOWN(%ld)",vffi->dwFileSubtype);
 327                         break;
 328                 case VFT2_FONT_RASTER:dprintf_ver(stddeb,"RASTER");break;
 329                 case VFT2_FONT_VECTOR:dprintf_ver(stddeb,"VECTOR");break;
 330                 case VFT2_FONT_TRUETYPE:dprintf_ver(stddeb,"TRUETYPE");break;
 331                 }
 332                 break;
 333         case VFT_VXD:dprintf_ver(stddeb,"filetype=VXD");break;
 334         case VFT_STATIC_LIB:dprintf_ver(stddeb,"filetype=STATIC_LIB");break;
 335         }
 336         dprintf_ver(stddeb,"filedata=%lx.%lx\n",vffi->dwFileDateMS,vffi->dwFileDateLS);
 337         return len;
 338 }
 339
 340 /* GetFileVersionInfoSize32A                    [VERSION.1] */
 341 DWORD
 342 GetFileVersionInfoSize32A(LPCSTR filename,LPDWORD handle) {
 343         dprintf_ver(stddeb,"GetFileVersionInfoSize32A(%s,%p)\n",filename,handle);
 344         return GetFileVersionInfoSize16(filename,handle);
 345 }
 346
 347 /* GetFileVersionInfoSize32W                    [VERSION.2] */
 348 DWORD GetFileVersionInfoSize32W( LPCWSTR filename, LPDWORD handle )
 349 {
 350     LPSTR xfn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
 351     DWORD ret = GetFileVersionInfoSize16( xfn, handle );
 352     HeapFree( GetProcessHeap(), 0, xfn );
 353     return ret;
 354 }
 355
 356 /* GetFileVersionInfo                           [VER.7] */
 357 DWORD
 358 GetFileVersionInfo16(LPCSTR filename,DWORD handle,DWORD datasize,LPVOID data) {
 359         dprintf_ver(stddeb,"GetFileVersionInfo16(%s,%ld,%ld,%p)\n->",
 360                 filename,handle,datasize,data
 361         );
 362         return GetFileResource(
 363                 filename,VS_FILE_INFO,VS_VERSION_INFO,handle,datasize,data
 364         );
 365 }
 366
 367 /* GetFileVersionInfoA                          [VERSION.0] */
 368 DWORD
 369 GetFileVersionInfo32A(LPCSTR filename,DWORD handle,DWORD datasize,LPVOID data) {
 370         return GetFileVersionInfo16(filename,handle,datasize,data);
 371 }
 372
 373 /* GetFileVersionInfoW                          [VERSION.3] */
 374 DWORD GetFileVersionInfo32W( LPCWSTR filename, DWORD handle, DWORD datasize,
 375                              LPVOID data)
 376 {
 377     LPSTR fn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
 378     DWORD ret = GetFileVersionInfo16( fn, handle, datasize, data );
 379     HeapFree( GetProcessHeap(), 0, fn );
 380     return ret;
 381 }
 382
 383 /* VerFindFile                          [VER.8] */
 384 DWORD
 385 VerFindFile16(
 386         UINT16 flags,LPCSTR filename,LPCSTR windir,LPCSTR appdir,
 387         LPSTR curdir,UINT16 *curdirlen,LPSTR destdir,UINT16 *destdirlen
 388 ) {
 389         dprintf_ver(stddeb,"VerFindFile(%x,%s,%s,%s,%p,%d,%p,%d)\n",
 390                 flags,filename,windir,appdir,curdir,*curdirlen,destdir,*destdirlen
 391         );
 392         strcpy(curdir,"Z:\\ROOT\\.WINE\\");/*FIXME*/
 393         *curdirlen=strlen(curdir);
 394         strcpy(destdir,"Z:\\ROOT\\.WINE\\");/*FIXME*/
 395         *destdirlen=strlen(destdir);
 396         return 0;
 397 }
 398
 399 /* VerFindFileA                                         [VERSION.5] */
 400 DWORD
 401 VerFindFile32A(
 402         UINT32 flags,LPCSTR filename,LPCSTR windir,LPCSTR appdir,
 403         LPSTR curdir,UINT32 *pcurdirlen,LPSTR destdir,UINT32 *pdestdirlen )
 404 {
 405     UINT16 curdirlen, destdirlen;
 406     DWORD ret = VerFindFile16(flags,filename,windir,appdir,
 407                               curdir,&curdirlen,destdir,&destdirlen);
 408     *pcurdirlen = curdirlen;
 409     *pdestdirlen = destdirlen;
 410     return ret;
 411 }
 412
 413 /* VerFindFileW                                         [VERSION.6] */
 414 DWORD
 415 VerFindFile32W(
 416         UINT32 flags,LPCWSTR filename,LPCWSTR windir,LPCWSTR appdir,
 417         LPWSTR curdir,UINT32 *pcurdirlen,LPWSTR destdir,UINT32 *pdestdirlen )
 418 {
 419     UINT16 curdirlen, destdirlen;
 420     LPSTR wfn,wwd,wad,wdd,wcd;
 421     DWORD ret;
 422
 423     wfn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
 424     wwd = HEAP_strdupWtoA( GetProcessHeap(), 0, windir );
 425     wad = HEAP_strdupWtoA( GetProcessHeap(), 0, appdir );
 426     wcd = HeapAlloc( GetProcessHeap(), 0, *pcurdirlen );
 427     wdd = HeapAlloc( GetProcessHeap(), 0, *pdestdirlen );
 428     ret = VerFindFile16(flags,wfn,wwd,wad,wcd,&curdirlen,wdd,&destdirlen);
 429     lstrcpynAtoW(curdir,wcd,*pcurdirlen);
 430     lstrcpynAtoW(destdir,wdd,*pdestdirlen);
 431     *pcurdirlen = strlen(wcd);
 432     *pdestdirlen = strlen(wdd);
 433     HeapFree( GetProcessHeap(), 0, wfn );
 434     HeapFree( GetProcessHeap(), 0, wwd );
 435     HeapFree( GetProcessHeap(), 0, wad );
 436     HeapFree( GetProcessHeap(), 0, wcd );
 437     HeapFree( GetProcessHeap(), 0, wdd );
 438     return ret;
 439 }
 440
 441 /* VerInstallFile                                       [VER.9] */
 442 DWORD
 443 VerInstallFile16(
 444         UINT16 flags,LPCSTR srcfilename,LPCSTR destfilename,LPCSTR srcdir,
 445         LPCSTR destdir,LPCSTR curdir,LPSTR tmpfile,UINT16 *tmpfilelen )
 446 {
 447     UINT32      filelen;
 448     DWORD ret= VerInstallFile32A(flags,srcfilename,destfilename,srcdir,
 449                                  destdir,curdir,tmpfile,&filelen);
 450
 451     *tmpfilelen = filelen;
 452     return ret;
 453 }
 454
 455 /* VerInstallFileA                              [VERSION.7] */
 456 static LPBYTE
 457 _fetch_versioninfo(LPSTR fn) {
 458     DWORD       alloclen;
 459     LPBYTE      buf;
 460     DWORD       ret;
 461
 462     alloclen = 1000;
 463     buf= xmalloc(alloclen);
 464     while (1) {
 465         ret = GetFileVersionInfo32A(fn,0,alloclen,buf);
 466         if (!ret) {
 467             free(buf);
 468             return 0;
 469         }
 470         if (alloclen<*(WORD*)buf) {
 471             free(buf);
 472             alloclen = *(WORD*)buf;
 473             buf = xmalloc(alloclen);
 474         } else
 475             return buf;
 476     }
 477 }
 478
 479 static DWORD
 480 _error2vif(DWORD error) {
 481     switch (error) {
 482     case ERROR_ACCESS_DENIED:
 483         return VIF_ACCESSVIOLATION;
 484     case ERROR_SHARING_VIOLATION:
 485         return VIF_SHARINGVIOLATION;
 486     default:
 487         return 0;
 488     }
 489 }
 490
 491 DWORD
 492 VerInstallFile32A(
 493         UINT32 flags,LPCSTR srcfilename,LPCSTR destfilename,LPCSTR srcdir,
 494         LPCSTR destdir,LPCSTR curdir,LPSTR tmpfile,UINT32 *tmpfilelen )
 495 {
 496     char        destfn[260],tmpfn[260],srcfn[260];
 497     HFILE32     hfsrc,hfdst;
 498     DWORD       attr,ret,xret,tmplast;
 499     LPBYTE      buf1,buf2;
 500     OFSTRUCT    ofs;
 501
 502     fprintf(stddeb,"VerInstallFile(%x,%s,%s,%s,%s,%s,%p,%d)\n",
 503             flags,srcfilename,destfilename,srcdir,destdir,curdir,tmpfile,*tmpfilelen
 504     );
 505     xret = 0;
 506     sprintf(srcfn,"%s\\%s",srcdir,srcfilename);
 507     sprintf(destfn,"%s\\%s",destdir,destfilename);
 508     hfsrc=LZOpenFile32A(srcfn,&ofs,OF_READ);
 509     if (hfsrc==HFILE_ERROR32)
 510         return VIF_CANNOTREADSRC;
 511     sprintf(tmpfn,"%s\\%s",destdir,destfilename);
 512     tmplast=strlen(destdir)+1;
 513     attr = GetFileAttributes32A(tmpfn);
 514     if (attr!=-1) {
 515         if (attr & FILE_ATTRIBUTE_READONLY) {
 516             LZClose32(hfsrc);
 517             return VIF_WRITEPROT;
 518         }
 519         /* FIXME: check if file currently in use and return VIF_FILEINUSE */
 520     }
 521     attr = -1;
 522     if (flags & VIFF_FORCEINSTALL) {
 523         if (tmpfile[0]) {
 524             sprintf(tmpfn,"%s\\%s",destdir,tmpfile);
 525             tmplast = strlen(destdir)+1;
 526             attr = GetFileAttributes32A(tmpfn);
 527             /* if it exists, it has been copied by the call before.
 528              * we jump over the copy part...
 529              */
 530         }
 531     }
 532     if (attr == -1) {
 533         char    *s;
 534
 535         GetTempFileName32A(destdir,"ver",0,tmpfn); /* should not fail ... */
 536         s=strrchr(tmpfn,'\\');
 537         if (s)
 538             tmplast = s-tmpfn;
 539         else
 540             tmplast = 0;
 541         hfdst = OpenFile32(tmpfn,&ofs,OF_CREATE);
 542         if (hfdst == HFILE_ERROR32) {
 543             LZClose32(hfsrc);
 544             return VIF_CANNOTCREATE; /* | translated dos error */
 545         }
 546         ret = LZCopy32(hfsrc,hfdst);
 547         _lclose32(hfdst);
 548         if (((long) ret) < 0) {
 549             /* translate LZ errors into VIF_xxx */
 550             switch (ret) {
 551             case LZERROR_BADINHANDLE:
 552             case LZERROR_READ:
 553             case LZERROR_BADVALUE:
 554             case LZERROR_UNKNOWNALG:
 555                 ret = VIF_CANNOTREADSRC;
 556                 break;
 557             case LZERROR_BADOUTHANDLE:
 558             case LZERROR_WRITE:
 559                 ret = VIF_OUTOFMEMORY; /* FIXME: correct? */
 560                 break;
 561             case LZERROR_GLOBALLOC:
 562             case LZERROR_GLOBLOCK:
 563                 ret = VIF_OUTOFSPACE;
 564                 break;
 565             default: /* unknown error, should not happen */
 566                 ret = 0;
 567                 break;
 568             }
 569             if (ret) {
 570                 LZClose32(hfsrc);
 571                 return ret;
 572             }
 573         }
 574     }
 575     xret = 0;
 576     if (!(flags & VIFF_FORCEINSTALL)) {
 577         buf1 = _fetch_versioninfo(destfn);
 578         if (buf1) {
 579             buf2 = _fetch_versioninfo(tmpfn);
 580             if (buf2) {
 581                 char    *tbuf1,*tbuf2;
 582                 VS_FIXEDFILEINFO *destvffi,*tmpvffi;
 583                 UINT32  len1,len2;
 584
 585                 destvffi= (VS_FIXEDFILEINFO*)(buf1+0x14);
 586                 tmpvffi = (VS_FIXEDFILEINFO*)(buf2+0x14);
 587                 len1=len2=40;
 588
 589                 /* compare file versions */
 590                 if ((destvffi->dwFileVersionMS > tmpvffi->dwFileVersionMS)||
 591                     ((destvffi->dwFileVersionMS==tmpvffi->dwFileVersionMS)&&
 592                      (destvffi->dwFileVersionLS > tmpvffi->dwFileVersionLS)
 593                     )
 594                 )
 595                     xret |= VIF_MISMATCH|VIF_SRCOLD;
 596                 /* compare filetypes and filesubtypes */
 597                 if ((destvffi->dwFileType!=tmpvffi->dwFileType) ||
 598                     (destvffi->dwFileSubtype!=tmpvffi->dwFileSubtype)
 599                 )
 600                     xret |= VIF_MISMATCH|VIF_DIFFTYPE;
 601                 if (VerQueryValue32A(buf1,"\\VarFileInfo\\Translation",(LPVOID*)&tbuf1,&len1) &&
 602                     VerQueryValue32A(buf2,"\\VarFileInfo\\Translation",(LPVOID*)&tbuf2,&len2)
 603                 ) {
 604                     /* irgendwas mit tbuf1 und tbuf2 machen
 605                      * generiert DIFFLANG|MISMATCH
 606                      */
 607                 }
 608                 free(buf2);
 609             } else
 610                 xret=VIF_MISMATCH|VIF_SRCOLD;
 611             free(buf1);
 612         }
 613     }
 614     if (xret) {
 615         if (*tmpfilelen<strlen(tmpfn+tmplast)) {
 616             xret|=VIF_BUFTOSMALL;
 617             DeleteFile32A(tmpfn);
 618         } else {
 619             strcpy(tmpfile,tmpfn+tmplast);
 620             *tmpfilelen = strlen(tmpfn+tmplast)+1;
 621             xret|=VIF_TEMPFILE;
 622         }
 623     } else {
 624         if (-1!=GetFileAttributes32A(destfn))
 625             if (!DeleteFile32A(destfn)) {
 626                 xret|=_error2vif(GetLastError())|VIF_CANNOTDELETE;
 627                 DeleteFile32A(tmpfn);
 628                 LZClose32(hfsrc);
 629                 return xret;
 630             }
 631         if ((!(flags & VIFF_DONTDELETEOLD))     &&
 632             curdir                              &&
 633             *curdir                             &&
 634             lstrcmpi32A(curdir,destdir)
 635         ) {
 636             char curfn[260];
 637
 638             sprintf(curfn,"%s\\%s",curdir,destfilename);
 639             if (-1!=GetFileAttributes32A(curfn)) {
 640                 /* FIXME: check if in use ... if it is, VIF_CANNOTDELETECUR */
 641                 if (!DeleteFile32A(curfn))
 642                     xret|=_error2vif(GetLastError())|VIF_CANNOTDELETECUR;
 643             }
 644         }
 645         if (!MoveFile32A(tmpfn,destfn)) {
 646             xret|=_error2vif(GetLastError())|VIF_CANNOTRENAME;
 647             DeleteFile32A(tmpfn);
 648         }
 649     }
 650     LZClose32(hfsrc);
 651     return xret;
 652 }
 653
 654 /* VerInstallFileW                              [VERSION.8] */
 655 DWORD
 656 VerInstallFile32W(
 657         UINT32 flags,LPCWSTR srcfilename,LPCWSTR destfilename,LPCWSTR srcdir,
 658         LPCWSTR destdir,LPCWSTR curdir,LPWSTR tmpfile,UINT32 *tmpfilelen )
 659 {
 660     LPSTR wsrcf,wsrcd,wdestf,wdestd,wtmpf,wcurd;
 661     DWORD ret;
 662
 663     wsrcf  = HEAP_strdupWtoA( GetProcessHeap(), 0, srcfilename );
 664     wsrcd  = HEAP_strdupWtoA( GetProcessHeap(), 0, srcdir );
 665     wdestf = HEAP_strdupWtoA( GetProcessHeap(), 0, destfilename );
 666     wdestd = HEAP_strdupWtoA( GetProcessHeap(), 0, destdir );
 667     wtmpf  = HEAP_strdupWtoA( GetProcessHeap(), 0, tmpfile );
 668     wcurd  = HEAP_strdupWtoA( GetProcessHeap(), 0, curdir );
 669     ret = VerInstallFile32A(flags,wsrcf,wdestf,wsrcd,wdestd,wcurd,wtmpf,tmpfilelen);
 670     if (!ret)
 671         lstrcpynAtoW(tmpfile,wtmpf,*tmpfilelen);
 672     HeapFree( GetProcessHeap(), 0, wsrcf );
 673     HeapFree( GetProcessHeap(), 0, wsrcd );
 674     HeapFree( GetProcessHeap(), 0, wdestf );
 675     HeapFree( GetProcessHeap(), 0, wdestd );
 676     HeapFree( GetProcessHeap(), 0, wtmpf );
 677     if (wcurd)
 678         HeapFree( GetProcessHeap(), 0, wcurd );
 679     return ret;
 680 }
 681
 682 /* FIXME: This table should, of course, be language dependend */
 683 static const struct map_id2str {
 684         UINT16  langid;
 685         const char *langname;
 686 } languages[]={
 687         {0x0401,"Arabisch"},
 688         {0x0402,"Bulgarisch"},
 689         {0x0403,"Katalanisch"},
 690         {0x0404,"Traditionales Chinesisch"},
 691         {0x0405,"Tschecisch"},
 692         {0x0406,"Dänisch"},
 693         {0x0407,"Deutsch"},
 694         {0x0408,"Griechisch"},
 695         {0x0409,"Amerikanisches Englisch"},
 696         {0x040A,"Kastilisches Spanisch"},
 697         {0x040B,"Finnisch"},
 698         {0x040C,"Französisch"},
 699         {0x040D,"Hebräisch"},
 700         {0x040E,"Ungarisch"},
 701         {0x040F,"Isländisch"},
 702         {0x0410,"Italienisch"},
 703         {0x0411,"Japanisch"},
 704         {0x0412,"Koreanisch"},
 705         {0x0413,"Niederländisch"},
 706         {0x0414,"Norwegisch-Bokmal"},
 707         {0x0415,"Polnisch"},
 708         {0x0416,"Brasilianisches Portugiesisch"},
 709         {0x0417,"Rätoromanisch"},
 710         {0x0418,"Rumänisch"},
 711         {0x0419,"Russisch"},
 712         {0x041A,"Kroatoserbisch (lateinisch)"},
 713         {0x041B,"Slowenisch"},
 714         {0x041C,"Albanisch"},
 715         {0x041D,"Schwedisch"},
 716         {0x041E,"Thai"},
 717         {0x041F,"Türkisch"},
 718         {0x0420,"Urdu"},
 719         {0x0421,"Bahasa"},
 720         {0x0804,"Vereinfachtes Chinesisch"},
 721         {0x0807,"Schweizerdeutsch"},
 722         {0x0809,"Britisches Englisch"},
 723         {0x080A,"Mexikanisches Spanisch"},
 724         {0x080C,"Belgisches Französisch"},
 725         {0x0810,"Schweizerisches Italienisch"},
 726         {0x0813,"Belgisches Niederländisch"},
 727         {0x0814,"Norgwegisch-Nynorsk"},
 728         {0x0816,"Portugiesisch"},
 729         {0x081A,"Serbokratisch (kyrillisch)"},
 730         {0x0C1C,"Kanadisches Französisch"},
 731         {0x100C,"Schweizerisches Französisch"},
 732         {0x0000,"Unbekannt"},
 733 };
 734
 735 /* VerLanguageName                              [VER.10] */
 736 DWORD
 737 VerLanguageName16(UINT16 langid,LPSTR langname,UINT16 langnamelen) {
 738         int     i;
 739         char    *buf;
 740
 741         dprintf_ver(stddeb,"VerLanguageName(%d,%p,%d)\n",langid,langname,langnamelen);
 742         /* First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
 743          * from the registry.
 744          */
 745         buf=(char*)malloc(strlen("\\System\\CurrentControlSet\\control\\Nls\\Locale\\")+9);
 746         sprintf(buf,"\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",langid);
 747         if (ERROR_SUCCESS==RegQueryValue16(HKEY_LOCAL_MACHINE,buf,langname,(LPDWORD)&langnamelen)) {
 748                 langname[langnamelen-1]='\0';
 749                 return langnamelen;
 750         }
 751         /* if that fails, use the interal table */
 752         for (i=0;languages[i].langid!=0;i++)
 753                 if (langid==languages[i].langid)
 754                         break;
 755         strncpy(langname,languages[i].langname,langnamelen);
 756         langname[langnamelen-1]='\0';
 757         return strlen(languages[i].langname);
 758 }
 759
 760 /* VerLanguageNameA                             [VERSION.9] */
 761 DWORD
 762 VerLanguageName32A(UINT32 langid,LPSTR langname,UINT32 langnamelen) {
 763         return VerLanguageName16(langid,langname,langnamelen);
 764 }
 765
 766 /* VerLanguageNameW                             [VERSION.10] */
 767 DWORD
 768 VerLanguageName32W(UINT32 langid,LPWSTR langname,UINT32 langnamelen) {
 769         int     i;
 770         char    buffer[80];
 771         LPWSTR  keyname;
 772
 773         /* First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
 774          * from the registry.
 775          */
 776         sprintf(buffer,"\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",langid);
 777         keyname = HEAP_strdupAtoW( GetProcessHeap(), 0, buffer );
 778         if (ERROR_SUCCESS==RegQueryValue32W(HKEY_LOCAL_MACHINE,keyname,langname,(LPDWORD)&langnamelen)) {
 779                 HeapFree( GetProcessHeap(), 0, keyname );
 780                 return langnamelen;
 781         }
 782         HeapFree( GetProcessHeap(), 0, keyname );
 783         /* if that fails, use the interal table */
 784         for (i=0;languages[i].langid!=0;i++)
 785                 if (langid==languages[i].langid)
 786                         break;
 787         lstrcpyAtoW( langname, languages[i].langname );
 788         return strlen(languages[i].langname); /* same as strlenW(langname); */
 789 }
 790
 791 /* FIXME: UNICODE? */
 792 struct db {
 793         WORD    nextoff;
 794         WORD    datalen;
 795 /* in memory structure... */
 796         char    name[1];        /* padded to dword alignment */
 797 /* ....
 798         char    data[datalen];     padded to dword alignemnt
 799         BYTE    subdirdata[];      until nextoff
 800  */
 801 };
 802
 803 static BYTE*
 804 _find_data(BYTE *block,LPCSTR str) {
 805         char    *nextslash;
 806         int     substrlen;
 807         struct  db      *db;
 808
 809         while (*str && *str=='\\')
 810                 str++;
 811         if (NULL!=(nextslash=strchr(str,'\\')))
 812                 substrlen=nextslash-str;
 813         else
 814                 substrlen=strlen(str);
 815         if (nextslash!=NULL) {
 816                 while (*nextslash && *nextslash=='\\')
 817                         nextslash++;
 818                 if (!*nextslash)
 819                         nextslash=NULL;
 820         }
 821
 822
 823         while (1) {
 824                 db=(struct db*)block;
 825                 dprintf_ver(stddeb,"db=%p,db->nextoff=%d,db->datalen=%d,db->name=%s,db->data=%s\n",
 826                         db,db->nextoff,db->datalen,db->name,(char*)((char*)db+4+((strlen(db->name)+4)&~3))
 827                 );
 828                 if (!db->nextoff)
 829                         return NULL;
 830
 831                 dprintf_ver(stddeb,"comparing with %s\n",db->name);
 832                 if (!strncmp(db->name,str,substrlen)) {
 833                         if (nextslash)
 834                                 return _find_data(
 835                                         block+4+((strlen(db->name)+4)&~3)+((db->datalen+3)&~3)
 836                                         ,nextslash
 837                                 );
 838                         else
 839                                 return block;
 840                 }
 841                 block=block+((db->nextoff+3)&~3);
 842         }
 843 }
 844
 845 /* VerQueryValue                        [VER.11] */
 846 /* take care, 'buffer' is NOT a SEGPTR, it just points to one */
 847 DWORD
 848 VerQueryValue16(SEGPTR segblock,LPCSTR subblock,SEGPTR *buffer,UINT16 *buflen)
 849 {
 850         BYTE    *block=PTR_SEG_TO_LIN(segblock),*b;
 851         struct  db      *db;
 852         char    *s;
 853
 854         dprintf_ver(stddeb,"VerQueryValue16(%p,%s,%p,%d)\n",
 855                 block,subblock,buffer,*buflen
 856         );
 857         s=(char*)xmalloc(strlen("VS_VERSION_INFO\\")+strlen(subblock)+1);
 858         strcpy(s,"VS_VERSION_INFO\\");strcat(s,subblock);
 859         b=_find_data(block,s);
 860         if (b==NULL) {
 861                 *buflen=0;
 862                 return 0;
 863         }
 864         db=(struct db*)b;
 865         *buflen = db->datalen;
 866         /* let b point to data area */
 867         b       = b+4+((strlen(db->name)+4)&~3);
 868         /* now look up what the resp. SEGPTR would be ... */
 869         *buffer = (b-block)+segblock;
 870         dprintf_ver(stddeb,"    -> %s=%s\n",subblock,b);
 871         return 1;
 872 }
 873
 874 DWORD
 875 VerQueryValue32A(LPVOID vblock,LPCSTR subblock,LPVOID *vbuffer,UINT32 *buflen)
 876 {
 877         BYTE    *b,*block=(LPBYTE)vblock,**buffer=(LPBYTE*)vbuffer;
 878         struct  db      *db;
 879         char    *s;
 880
 881         dprintf_ver(stddeb,"VerQueryValue32A(%p,%s,%p,%d)\n",
 882                 block,subblock,buffer,*buflen
 883         );
 884         s=(char*)xmalloc(strlen("VS_VERSION_INFO\\")+strlen(subblock)+1);
 885         strcpy(s,"VS_VERSION_INFO\\");strcat(s,subblock);
 886         b=_find_data(block,s);
 887         if (b==NULL) {
 888                 *buflen=0;
 889                 return 0;
 890         }
 891         db=(struct db*)b;
 892         *buflen = db->datalen;
 893         /* let b point to data area */
 894         b       = b+4+((strlen(db->name)+4)&~3);
 895         *buffer = b;
 896         dprintf_ver(stddeb,"    -> %s=%s\n",subblock,b);
 897         return 1;
 898 }
 899
 900 DWORD
 901 VerQueryValue32W(LPVOID vblock,LPCWSTR subblock,LPVOID *vbuffer,UINT32 *buflen)
 902 {
 903         /* FIXME: hmm, we not only need to convert subblock, but also
 904          *        the content...or?
 905          * And what about UNICODE version info?
 906          * And the NAMES of the values?
 907          */
 908         BYTE            *b,**buffer=(LPBYTE*)vbuffer,*block=(LPBYTE)vblock;
 909         struct  db      *db;
 910         char            *s,*sb;
 911
 912         sb = HEAP_strdupWtoA( GetProcessHeap(), 0, subblock );
 913         s=(char*)xmalloc(strlen("VS_VERSION_INFO\\")+strlen(sb)+1);
 914         strcpy(s,"VS_VERSION_INFO\\");strcat(s,sb);
 915         b=_find_data(block,s);
 916         if (b==NULL) {
 917                 *buflen=0;
 918                 HeapFree( GetProcessHeap(), 0, sb );
 919                 return 0;
 920         }
 921         db=(struct db*)b;
 922         *buflen = db->datalen;
 923         /* let b point to data area */
 924         b       = b+4+((strlen(db->name)+4)&~3);
 925         *buffer = b;
 926         dprintf_ver(stddeb,"    -> %s=%s\n",sb,b);
 927         HeapFree( GetProcessHeap(), 0, sb );
 928         return 1;
 929 }
 930 /* 20 GETFILEVERSIONINFORAW */