misc/ver.c

   1 /*
   2  * Implementation of VER.DLL
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  */
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <ctype.h>
  11 #include "windows.h"
  12 #include "win.h"
  13 #include "winerror.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 #include "string32.h"
  23
  24 #define LZREAD(what) \
  25   if (sizeof(*what)!=LZRead32(lzfd,what,sizeof(*what))) return 0;
  26 #define LZTELL(lzfd) LZSeek(lzfd, 0, SEEK_CUR);
  27
  28 #define strdupW2A(x)    STRING32_DupUniToAnsi(x)
  29 #define strdupA2W(x)    STRING32_DupAnsiToUni(x)
  30
  31 int
  32 read_ne_header(HFILE lzfd,struct ne_header_s *nehd) {
  33         struct  mz_header_s     mzh;
  34
  35         LZSeek(lzfd,0,SEEK_SET);
  36         if (sizeof(mzh)!=LZRead32(lzfd,&mzh,sizeof(mzh)))
  37                 return 0;
  38         if (mzh.mz_magic!=MZ_SIGNATURE)
  39                 return 0;
  40         LZSeek(lzfd,mzh.ne_offset,SEEK_SET);
  41         LZREAD(nehd);
  42         if (nehd->ne_magic == NE_SIGNATURE) {
  43                 LZSeek(lzfd,mzh.ne_offset,SEEK_SET);
  44                 return 1;
  45         }
  46         /* must handle PE files too. Later. */
  47         return 0;
  48 }
  49
  50
  51 int
  52 find_ne_resource(
  53         HFILE lzfd,struct ne_header_s *nehd,SEGPTR typeid,SEGPTR resid,
  54         BYTE **resdata,int *reslen,DWORD *off
  55 ) {
  56         NE_TYPEINFO     ti;
  57         NE_NAMEINFO     ni;
  58         int             i;
  59         WORD            shiftcount;
  60         DWORD           nehdoffset;
  61
  62         nehdoffset = LZTELL(lzfd);
  63         LZSeek(lzfd,nehd->resource_tab_offset,SEEK_CUR);
  64         LZREAD(&shiftcount);
  65         dprintf_resource(stderr,"shiftcount is %d\n",shiftcount);
  66         dprintf_resource(stderr,"reading resource typeinfo dir.\n");
  67
  68         if (!HIWORD(typeid)) typeid = (SEGPTR)(LOWORD(typeid) | 0x8000);
  69         if (!HIWORD(resid))  resid  = (SEGPTR)(LOWORD(resid) | 0x8000);
  70         while (1) {
  71                 int     skipflag;
  72
  73                 LZREAD(&ti);
  74                 if (!ti.type_id)
  75                         return 0;
  76                 dprintf_resource(stderr,"    ti.typeid =%04x,count=%d\n",ti.type_id,ti.count);
  77                 skipflag=0;
  78                 if (!HIWORD(typeid)) {
  79                         if ((ti.type_id&0x8000)&&(typeid!=ti.type_id))
  80                                 skipflag=1;
  81                 } else {
  82                         if (ti.type_id & 0x8000) {
  83                                 skipflag=1;
  84                         } else {
  85                                 BYTE    len;
  86                                 char    *str;
  87                                 DWORD   whereleft;
  88
  89                                 whereleft = LZTELL(lzfd);
  90                                 LZSeek(
  91                                         lzfd,
  92                                         nehdoffset+nehd->resource_tab_offset+ti.type_id,
  93                                         SEEK_SET
  94                                 );
  95                                 LZREAD(&len);
  96                                 str=xmalloc(len);
  97                                 if (len!=LZRead32(lzfd,str,len))
  98                                         return 0;
  99                                 dprintf_resource(stderr,"read %s to compare it with %s\n",
 100                                         str,(char*)PTR_SEG_TO_LIN(typeid)
 101                                 );
 102                                 if (lstrcmpi32A(str,(char*)PTR_SEG_TO_LIN(typeid)))
 103                                         skipflag=1;
 104                                 free(str);
 105                                 LZSeek(lzfd,whereleft,SEEK_SET);
 106                         }
 107                 }
 108                 if (skipflag) {
 109                         LZSeek(lzfd,ti.count*sizeof(ni),SEEK_CUR);
 110                         continue;
 111                 }
 112                 for (i=0;i<ti.count;i++) {
 113                         WORD    *rdata;
 114                         int     len;
 115
 116                         LZREAD(&ni);
 117                         dprintf_resource(stderr,"       ni.id=%4x,offset=%d,length=%d\n",
 118                                 ni.id,ni.offset,ni.length
 119                         );
 120                         skipflag=1;
 121                         if (!HIWORD(resid)) {
 122                                 if (ni.id == resid)
 123                                         skipflag=0;
 124                         } else {
 125                                 if (!(ni.id & 0x8000)) {
 126                                         BYTE    len;
 127                                         char    *str;
 128                                         DWORD   whereleft;
 129
 130                                         whereleft = LZTELL(lzfd);
 131                                           LZSeek(
 132                                                 lzfd,
 133                                                 nehdoffset+nehd->resource_tab_offset+ni.id,
 134                                                 SEEK_SET
 135                                         );
 136                                         LZREAD(&len);
 137                                         str=xmalloc(len);
 138                                         if (len!=LZRead32(lzfd,str,len))
 139                                                 return 0;
 140                                         dprintf_resource(stderr,"read %s to compare it with %s\n",
 141                                                 str,(char*)PTR_SEG_TO_LIN(typeid)
 142                                         );
 143                                         if (!lstrcmpi32A(str,(char*)PTR_SEG_TO_LIN(typeid)))
 144                                                 skipflag=0;
 145                                         free(str);
 146                                         LZSeek(lzfd,whereleft,SEEK_SET);
 147                                 }
 148                         }
 149                         if (skipflag)
 150                                 continue;
 151                         LZSeek(lzfd,((int)ni.offset<<shiftcount),SEEK_SET);
 152                         *off    = (int)ni.offset<<shiftcount;
 153                         len     = ni.length<<shiftcount;
 154                         rdata=(WORD*)xmalloc(len);
 155                         if (len!=LZRead32(lzfd,rdata,len)) {
 156                                 free(rdata);
 157                                 return 0;
 158                         }
 159                         dprintf_resource(stderr,"resource found.\n");
 160                         *resdata= (BYTE*)rdata;
 161                         *reslen = len;
 162                         return 1;
 163                 }
 164         }
 165 }
 166
 167 /* GetFileResourceSize                          [VER.2] */
 168 DWORD
 169 GetFileResourceSize(LPCSTR filename,SEGPTR restype,SEGPTR resid,LPDWORD off) {
 170         HFILE   lzfd;
 171         OFSTRUCT        ofs;
 172         BYTE    *resdata;
 173         int     reslen;
 174         struct  ne_header_s     nehd;
 175
 176         fprintf(stderr,"GetFileResourceSize(%s,%lx,%lx,%p)\n",
 177                 filename,(LONG)restype,(LONG)resid,off
 178         );
 179         lzfd=LZOpenFile16(filename,&ofs,OF_READ);
 180         if (lzfd==0)
 181                 return 0;
 182         if (!read_ne_header(lzfd,&nehd)) {
 183                 LZClose(lzfd);
 184                 return 0;
 185         }
 186         if (!find_ne_resource(lzfd,&nehd,restype,resid,&resdata,&reslen,off)) {
 187                 LZClose(lzfd);
 188                 return 0;
 189         }
 190         free(resdata);
 191         LZClose(lzfd);
 192         return reslen;
 193 }
 194
 195 /* GetFileResource                              [VER.3] */
 196 DWORD
 197 GetFileResource(LPCSTR filename,SEGPTR restype,SEGPTR resid,
 198                 DWORD off,DWORD datalen,LPVOID data
 199 ) {
 200         HFILE   lzfd;
 201         OFSTRUCT        ofs;
 202         BYTE    *resdata;
 203         int     reslen=datalen;
 204         struct  ne_header_s     nehd;
 205         fprintf(stderr,"GetFileResource(%s,%lx,%lx,%ld,%ld,%p)\n",
 206                 filename,(LONG)restype,(LONG)resid,off,datalen,data
 207         );
 208
 209         lzfd=LZOpenFile16(filename,&ofs,OF_READ);
 210         if (lzfd==0)
 211                 return 0;
 212         if (!off) {
 213                 if (!read_ne_header(lzfd,&nehd)) {
 214                         LZClose(lzfd);
 215                         return 0;
 216                 }
 217                 if (!find_ne_resource(lzfd,&nehd,restype,resid,&resdata,&reslen,&off)) {
 218                         LZClose(lzfd);
 219                         return 0;
 220                 }
 221                 free(resdata);
 222         }
 223         LZSeek(lzfd,off,SEEK_SET);
 224         if (reslen>datalen)
 225                 reslen=datalen;
 226         LZRead32(lzfd,data,reslen);
 227         LZClose(lzfd);
 228         return reslen;
 229 }
 230
 231 /* GetFileVersionInfoSize                       [VER.6] */
 232 DWORD
 233 GetFileVersionInfoSize16(LPCSTR filename,LPDWORD handle) {
 234         DWORD   len,ret;
 235         BYTE    buf[72];
 236         VS_FIXEDFILEINFO *vffi;
 237
 238         dprintf_resource(stderr,"GetFileVersionInfoSize16(%s,%p)\n",filename,handle);
 239         len=GetFileResourceSize(filename,VS_FILE_INFO,VS_VERSION_INFO,handle);
 240         if (!len)
 241                 return 0;
 242         ret=GetFileResource(
 243                 filename,VS_FILE_INFO,VS_VERSION_INFO,*handle,sizeof(buf),buf
 244         );
 245         if (!ret)
 246                 return 0;
 247
 248         vffi=(VS_FIXEDFILEINFO*)(buf+0x14);
 249         if (vffi->dwSignature != VS_FFI_SIGNATURE)
 250                 return 0;
 251         if (*(WORD*)buf < len)
 252                 len = *(WORD*)buf;
 253         fprintf(stderr,"->strucver=%ld.%ld,filever=%ld.%ld,productver=%ld.%ld,flagmask=%lx,flags=%lx,OS=",
 254                 (vffi->dwStrucVersion>>16),vffi->dwStrucVersion&0xFFFF,
 255                 vffi->dwFileVersionMS,vffi->dwFileVersionLS,
 256                 vffi->dwProductVersionMS,vffi->dwProductVersionLS,
 257                 vffi->dwFileFlagsMask,vffi->dwFileFlags
 258         );
 259         switch (vffi->dwFileOS&0xFFFF0000) {
 260         case VOS_DOS:fprintf(stderr,"DOS,");break;
 261         case VOS_OS216:fprintf(stderr,"OS/2-16,");break;
 262         case VOS_OS232:fprintf(stderr,"OS/2-32,");break;
 263         case VOS_NT:fprintf(stderr,"NT,");break;
 264         case VOS_UNKNOWN:
 265         default:
 266                 fprintf(stderr,"UNKNOWN(%ld),",vffi->dwFileOS&0xFFFF0000);break;
 267         }
 268         switch (vffi->dwFileOS & 0xFFFF) {
 269         case VOS__BASE:fprintf(stderr,"BASE");break;
 270         case VOS__WINDOWS16:fprintf(stderr,"WIN16");break;
 271         case VOS__WINDOWS32:fprintf(stderr,"WIN32");break;
 272         case VOS__PM16:fprintf(stderr,"PM16");break;
 273         case VOS__PM32:fprintf(stderr,"PM32");break;
 274         default:fprintf(stderr,"UNKNOWN(%ld)",vffi->dwFileOS&0xFFFF);break;
 275         }
 276         switch (vffi->dwFileType) {
 277         default:
 278         case VFT_UNKNOWN:
 279                 fprintf(stderr,"filetype=Unknown(%ld)",vffi->dwFileType);
 280                 break;
 281         case VFT_APP:fprintf(stderr,"filetype=APP");break;
 282         case VFT_DLL:fprintf(stderr,"filetype=DLL");break;
 283         case VFT_DRV:
 284                 fprintf(stderr,"filetype=DRV,");
 285                 switch(vffi->dwFileSubtype) {
 286                 default:
 287                 case VFT2_UNKNOWN:
 288                         fprintf(stderr,"UNKNOWN(%ld)",vffi->dwFileSubtype);
 289                         break;
 290                 case VFT2_DRV_PRINTER:
 291                         fprintf(stderr,"PRINTER");
 292                         break;
 293                 case VFT2_DRV_KEYBOARD:
 294                         fprintf(stderr,"KEYBOARD");
 295                         break;
 296                 case VFT2_DRV_LANGUAGE:
 297                         fprintf(stderr,"LANGUAGE");
 298                         break;
 299                 case VFT2_DRV_DISPLAY:
 300                         fprintf(stderr,"DISPLAY");
 301                         break;
 302                 case VFT2_DRV_MOUSE:
 303                         fprintf(stderr,"MOUSE");
 304                         break;
 305                 case VFT2_DRV_NETWORK:
 306                         fprintf(stderr,"NETWORK");
 307                         break;
 308                 case VFT2_DRV_SYSTEM:
 309                         fprintf(stderr,"SYSTEM");
 310                         break;
 311                 case VFT2_DRV_INSTALLABLE:
 312                         fprintf(stderr,"INSTALLABLE");
 313                         break;
 314                 case VFT2_DRV_SOUND:
 315                         fprintf(stderr,"SOUND");
 316                         break;
 317                 case VFT2_DRV_COMM:
 318                         fprintf(stderr,"COMM");
 319                         break;
 320                 case VFT2_DRV_INPUTMETHOD:
 321                         fprintf(stderr,"INPUTMETHOD");
 322                         break;
 323                 }
 324                 break;
 325         case VFT_FONT:
 326                 fprintf(stderr,"filetype=FONT.");
 327                 switch (vffi->dwFileSubtype) {
 328                 default:
 329                         fprintf(stderr,"UNKNOWN(%ld)",vffi->dwFileSubtype);
 330                         break;
 331                 case VFT2_FONT_RASTER:fprintf(stderr,"RASTER");break;
 332                 case VFT2_FONT_VECTOR:fprintf(stderr,"VECTOR");break;
 333                 case VFT2_FONT_TRUETYPE:fprintf(stderr,"TRUETYPE");break;
 334                 }
 335                 break;
 336         case VFT_VXD:fprintf(stderr,"filetype=VXD");break;
 337         case VFT_STATIC_LIB:fprintf(stderr,"filetype=STATIC_LIB");break;
 338         }
 339         fprintf(stderr,"filedata=%lx.%lx\n",vffi->dwFileDateMS,vffi->dwFileDateLS);
 340         return len;
 341 }
 342
 343 /* GetFileVersionInfoSize32A                    [VERSION.1] */
 344 DWORD
 345 GetFileVersionInfoSize32A(LPCSTR filename,LPDWORD handle) {
 346         dprintf_resource(stderr,"GetFileVersionInfoSize32A(%s,%p)\n",filename,handle);
 347         return GetFileVersionInfoSize16(filename,handle);
 348 }
 349
 350 /* GetFileVersionInfoSize32W                    [VERSION.2] */
 351 DWORD
 352 GetFileVersionInfoSize32W(LPCWSTR filename,LPDWORD handle) {
 353         LPSTR   xfn;
 354         DWORD   ret;
 355
 356         xfn     = strdupW2A(filename);
 357         ret=GetFileVersionInfoSize16(xfn,handle);
 358         free(xfn);
 359         return  ret;
 360 }
 361
 362 /* GetFileVersionInfo                           [VER.7] */
 363 DWORD
 364 GetFileVersionInfo16(LPCSTR filename,DWORD handle,DWORD datasize,LPVOID data) {
 365         dprintf_resource(stderr,"GetFileVersionInfo16(%s,%ld,%ld,%p)\n->",
 366                 filename,handle,datasize,data
 367         );
 368         return GetFileResource(
 369                 filename,VS_FILE_INFO,VS_VERSION_INFO,handle,datasize,data
 370         );
 371 }
 372
 373 /* GetFileVersionInfoA                          [VERSION.0] */
 374 DWORD
 375 GetFileVersionInfo32A(LPCSTR filename,DWORD handle,DWORD datasize,LPVOID data) {
 376         return GetFileVersionInfo16(filename,handle,datasize,data);
 377 }
 378
 379 /* GetFileVersionInfoW                          [VERSION.3] */
 380 DWORD
 381 GetFileVersionInfo32W(LPCWSTR filename,DWORD handle,DWORD datasize,LPVOID data){
 382         DWORD   ret;
 383         LPSTR   fn;
 384
 385         fn      = strdupW2A(filename);
 386         ret     = GetFileVersionInfo16(fn,handle,datasize,data);
 387         free(fn);
 388         return  ret;
 389 }
 390
 391 /* VerFindFile                          [VER.8] */
 392 DWORD
 393 VerFindFile16(
 394         UINT16 flags,LPCSTR filename,LPCSTR windir,LPCSTR appdir,
 395         LPSTR curdir,UINT16 *curdirlen,LPSTR destdir,UINT16 *destdirlen
 396 ) {
 397         fprintf(stderr,"VerFindFile(%x,%s,%s,%s,%p,%d,%p,%d)\n",
 398                 flags,filename,windir,appdir,curdir,*curdirlen,destdir,*destdirlen
 399         );
 400         strcpy(curdir,"Z:\\ROOT\\.WINE\\");/*FIXME*/
 401         *curdirlen=strlen(curdir);
 402         strcpy(destdir,"Z:\\ROOT\\.WINE\\");/*FIXME*/
 403         *destdirlen=strlen(destdir);
 404         return 0;
 405 }
 406
 407 /* VerFindFileA                                         [VERSION.5] */
 408 DWORD
 409 VerFindFile32A(
 410         UINT32 flags,LPCSTR filename,LPCSTR windir,LPCSTR appdir,
 411         LPSTR curdir,UINT32 *curdirlen,LPSTR destdir,UINT32 *destdirlen
 412 ) {
 413         return VerFindFile16(flags,filename,windir,appdir,curdir,curdirlen,destdir,destdirlen);
 414 }
 415
 416 /* VerFindFileW                                         [VERSION.6] */
 417 DWORD
 418 VerFindFile32W(
 419         UINT32 flags,LPCWSTR filename,LPCWSTR windir,LPCWSTR appdir,
 420         LPWSTR curdir,UINT32 *curdirlen,LPWSTR destdir,UINT32 *destdirlen
 421 ) {
 422         LPSTR   wfn,wwd,wad,wdd,wcd;
 423         DWORD   ret;
 424
 425         wfn = strdupW2A(filename);
 426         wwd = strdupW2A(windir);
 427         wad = strdupW2A(appdir);
 428         wcd = (LPSTR)malloc(*curdirlen);
 429         wdd = (LPSTR)malloc(*destdirlen);
 430         ret=VerFindFile16(flags,wfn,wwd,wad,wcd,curdirlen,wdd,destdirlen);
 431         STRING32_AnsiToUni(curdir,wcd);
 432         STRING32_AnsiToUni(destdir,wdd);
 433         *curdirlen      = strlen(wcd);
 434         *destdirlen     = strlen(wdd);
 435         return ret;
 436 }
 437
 438 /* VerInstallFile                                       [VER.9] */
 439 DWORD
 440 VerInstallFile16(
 441         UINT16 flags,LPCSTR srcfilename,LPCSTR destfilename,LPCSTR srcdir,
 442         LPCSTR destdir,LPSTR tmpfile,UINT16 *tmpfilelen
 443 ) {
 444         fprintf(stderr,"VerInstallFile(%x,%s,%s,%s,%s,%p,%d)\n",
 445                 flags,srcfilename,destfilename,srcdir,destdir,tmpfile,*tmpfilelen
 446         );
 447
 448         /* FIXME: Implementation still missing .... */
 449
 450         return VIF_SRCOLD;
 451 }
 452
 453 /* VerFindFileA                                 [VERSION.5] */
 454 DWORD
 455 VerInstallFile32A(
 456         UINT32 flags,LPCSTR srcfilename,LPCSTR destfilename,LPCSTR srcdir,
 457         LPCSTR destdir,LPSTR tmpfile,UINT32 *tmpfilelen
 458 ) {
 459         return VerInstallFile16(flags,srcfilename,destfilename,srcdir,destdir,tmpfile,tmpfilelen);
 460 }
 461
 462 /* VerFindFileW                                 [VERSION.6] */
 463 DWORD
 464 VerInstallFile32W(
 465         UINT32 flags,LPCWSTR srcfilename,LPCWSTR destfilename,LPCWSTR srcdir,
 466         LPCWSTR destdir,LPWSTR tmpfile,UINT32 *tmpfilelen
 467 ) {
 468         LPSTR   wsrcf,wsrcd,wdestf,wdestd,wtmpf;
 469         DWORD   ret;
 470
 471         wsrcf   = strdupW2A(srcfilename);
 472         wsrcd   = strdupW2A(srcdir);
 473         wdestf  = strdupW2A(destfilename);
 474         wdestd  = strdupW2A(destdir);
 475         wtmpf   = strdupW2A(tmpfile);
 476         ret=VerInstallFile32A(flags,wsrcf,wdestf,wsrcd,wdestd,wtmpf,tmpfilelen);
 477         free(wsrcf);
 478         free(wsrcd);
 479         free(wdestf);
 480         free(wdestd);
 481         free(wtmpf);
 482         return ret;
 483 }
 484
 485 /* FIXME: This table should, of course, be language dependend */
 486 static const struct map_id2str {
 487         UINT    langid;
 488         const char *langname;
 489 } languages[]={
 490         {0x0401,"Arabisch"},
 491         {0x0402,"Bulgarisch"},
 492         {0x0403,"Katalanisch"},
 493         {0x0404,"Traditionales Chinesisch"},
 494         {0x0405,"Tschecisch"},
 495         {0x0406,"Dänisch"},
 496         {0x0407,"Deutsch"},
 497         {0x0408,"Griechisch"},
 498         {0x0409,"Amerikanisches Englisch"},
 499         {0x040A,"Kastilisches Spanisch"},
 500         {0x040B,"Finnisch"},
 501         {0x040C,"Französisch"},
 502         {0x040D,"Hebräisch"},
 503         {0x040E,"Ungarisch"},
 504         {0x040F,"Isländisch"},
 505         {0x0410,"Italienisch"},
 506         {0x0411,"Japanisch"},
 507         {0x0412,"Koreanisch"},
 508         {0x0413,"Niederländisch"},
 509         {0x0414,"Norwegisch-Bokmal"},
 510         {0x0415,"Polnisch"},
 511         {0x0416,"Brasilianisches Portugiesisch"},
 512         {0x0417,"Rätoromanisch"},
 513         {0x0418,"Rumänisch"},
 514         {0x0419,"Russisch"},
 515         {0x041A,"Kroatoserbisch (lateinisch)"},
 516         {0x041B,"Slowenisch"},
 517         {0x041C,"Albanisch"},
 518         {0x041D,"Schwedisch"},
 519         {0x041E,"Thai"},
 520         {0x041F,"Türkisch"},
 521         {0x0420,"Urdu"},
 522         {0x0421,"Bahasa"},
 523         {0x0804,"Vereinfachtes Chinesisch"},
 524         {0x0807,"Schweizerdeutsch"},
 525         {0x0809,"Britisches Englisch"},
 526         {0x080A,"Mexikanisches Spanisch"},
 527         {0x080C,"Belgisches Französisch"},
 528         {0x0810,"Schweizerisches Italienisch"},
 529         {0x0813,"Belgisches Niederländisch"},
 530         {0x0814,"Norgwegisch-Nynorsk"},
 531         {0x0816,"Portugiesisch"},
 532         {0x081A,"Serbokratisch (kyrillisch)"},
 533         {0x0C1C,"Kanadisches Französisch"},
 534         {0x100C,"Schweizerisches Französisch"},
 535         {0x0000,"Unbekannt"},
 536 };
 537
 538 /* VerLanguageName                              [VER.10] */
 539 DWORD
 540 VerLanguageName16(UINT16 langid,LPSTR langname,UINT16 langnamelen) {
 541         int     i;
 542         char    *buf;
 543
 544         fprintf(stderr,"VerLanguageName(%d,%p,%d)\n",langid,langname,langnamelen);
 545         /* First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
 546          * from the registry.
 547          */
 548         buf=(char*)malloc(strlen("\\System\\CurrentControlSet\\control\\Nls\\Locale\\")+9);
 549         sprintf(buf,"\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",langid);
 550         if (ERROR_SUCCESS==RegQueryValue16(HKEY_LOCAL_MACHINE,buf,langname,(LPDWORD)&langnamelen)) {
 551                 langname[langnamelen-1]='\0';
 552                 return langnamelen;
 553         }
 554         /* if that fails, use the interal table */
 555         for (i=0;languages[i].langid!=0;i++)
 556                 if (langid==languages[i].langid)
 557                         break;
 558         strncpy(langname,languages[i].langname,langnamelen);
 559         langname[langnamelen-1]='\0';
 560         return strlen(languages[i].langname);
 561 }
 562
 563 /* VerLanguageNameA                             [VERSION.9] */
 564 DWORD
 565 VerLanguageName32A(UINT32 langid,LPSTR langname,UINT32 langnamelen) {
 566         return VerLanguageName16(langid,langname,langnamelen);
 567 }
 568
 569 /* VerLanguageNameW                             [VERSION.10] */
 570 DWORD
 571 VerLanguageName32W(UINT32 langid,LPWSTR langname,UINT32 langnamelen) {
 572         int     i;
 573         char    *buf;
 574         LPWSTR  keyname,result;
 575
 576         /* First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
 577          * from the registry.
 578          */
 579         buf=(char*)malloc(strlen("\\System\\CurrentControlSet\\control\\Nls\\Locale\\")+9);
 580         sprintf(buf,"\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",langid);
 581         keyname=strdupA2W(buf);free(buf);
 582         if (ERROR_SUCCESS==RegQueryValue32W(HKEY_LOCAL_MACHINE,keyname,langname,(LPDWORD)&langnamelen)) {
 583                 free(keyname);
 584                 return langnamelen;
 585         }
 586         free(keyname);
 587         /* if that fails, use the interal table */
 588         for (i=0;languages[i].langid!=0;i++)
 589                 if (langid==languages[i].langid)
 590                         break;
 591         result=strdupA2W(languages[i].langname);
 592         i=lstrlen32W(result)*sizeof(WCHAR);
 593         if (i>langnamelen)
 594                 i=langnamelen;
 595         memcpy(langname,result,i);
 596         langname[langnamelen-1]='\0';
 597         free(result);
 598         return strlen(languages[i].langname); /* same as strlenW(result); */
 599 }
 600
 601 /* FIXME: UNICODE? */
 602 struct db {
 603         WORD    nextoff;
 604         WORD    datalen;
 605 /* in memory structure... */
 606         char    name[1];        /* padded to dword alignment */
 607 /* ....
 608         char    data[datalen];     padded to dword alignemnt
 609         BYTE    subdirdata[];      until nextoff
 610  */
 611 };
 612
 613 static BYTE*
 614 _find_data(BYTE *block,LPCSTR str) {
 615         char    *nextslash;
 616         int     substrlen;
 617         struct  db      *db;
 618
 619         while (*str && *str=='\\')
 620                 str++;
 621         if (NULL!=(nextslash=strchr(str,'\\')))
 622                 substrlen=nextslash-str;
 623         else
 624                 substrlen=strlen(str);
 625         if (nextslash!=NULL) {
 626                 while (*nextslash && *nextslash=='\\')
 627                         nextslash++;
 628                 if (!*nextslash)
 629                         nextslash=NULL;
 630         }
 631
 632
 633         while (1) {
 634                 db=(struct db*)block;
 635                 fprintf(stderr,"db=%p,db->nextoff=%d,db->datalen=%d,db->name=%s,db->data=%s\n",
 636                         db,db->nextoff,db->datalen,db->name,(char*)((char*)db+4+((strlen(db->name)+4)&~3))
 637                 );
 638                 if (!db->nextoff)
 639                         return NULL;
 640
 641                 fprintf(stderr,"comparing with %s\n",db->name);
 642                 if (!strncmp(db->name,str,substrlen)) {
 643                         if (nextslash)
 644                                 return _find_data(
 645                                         block+4+((strlen(db->name)+4)&~3)+((db->datalen+3)&~3)
 646                                         ,nextslash
 647                                 );
 648                         else
 649                                 return block;
 650                 }
 651                 block=block+((db->nextoff+3)&~3);
 652         }
 653 }
 654
 655 /* VerQueryValue                        [VER.11] */
 656 /* take care, 'buffer' is NOT a SEGPTR, it just points to one */
 657 DWORD
 658 VerQueryValue16(SEGPTR segblock,LPCSTR subblock,SEGPTR *buffer,UINT16 *buflen)
 659 {
 660         BYTE    *block=PTR_SEG_TO_LIN(segblock),*b;
 661         struct  db      *db;
 662         char    *s;
 663
 664         fprintf(stderr,"VerQueryValue16(%p,%s,%p,%d)\n",
 665                 block,subblock,buffer,*buflen
 666         );
 667         s=(char*)xmalloc(strlen("VS_VERSION_INFO")+strlen(subblock)+1);
 668         strcpy(s,"VS_VERSION_INFO");strcat(s,subblock);
 669         b=_find_data(block,s);
 670         if (b==NULL) {
 671                 *buflen=0;
 672                 return 0;
 673         }
 674         db=(struct db*)b;
 675         *buflen = db->datalen;
 676         /* let b point to data area */
 677         b       = b+4+((strlen(db->name)+4)&~3);
 678         /* now look up what the resp. SEGPTR would be ... */
 679         *buffer = (b-block)+segblock;
 680         fprintf(stderr,"        -> %s=%s\n",subblock,b);
 681         return 1;
 682 }
 683
 684 DWORD
 685 VerQueryValue32A(LPVOID vblock,LPCSTR subblock,LPVOID *vbuffer,UINT32 *buflen)
 686 {
 687         BYTE    *b,*block=(LPBYTE)vblock,**buffer=(LPBYTE*)vbuffer;
 688         struct  db      *db;
 689         char    *s;
 690
 691         fprintf(stderr,"VerQueryValue32A(%p,%s,%p,%d)\n",
 692                 block,subblock,buffer,*buflen
 693         );
 694         s=(char*)xmalloc(strlen("VS_VERSION_INFO")+strlen(subblock)+1);
 695         strcpy(s,"VS_VERSION_INFO");strcat(s,subblock);
 696         b=_find_data(block,s);
 697         if (b==NULL) {
 698                 *buflen=0;
 699                 return 0;
 700         }
 701         db=(struct db*)b;
 702         *buflen = db->datalen;
 703         /* let b point to data area */
 704         b       = b+4+((strlen(db->name)+4)&~3);
 705         *buffer = b;
 706         fprintf(stderr,"        -> %s=%s\n",subblock,b);
 707         return 1;
 708 }
 709
 710 DWORD
 711 VerQueryValue32W(LPVOID vblock,LPCWSTR subblock,LPVOID *vbuffer,UINT32 *buflen)
 712 {
 713         /* FIXME: hmm, we not only need to convert subblock, but also
 714          *        the content...or?
 715          * And what about UNICODE version info?
 716          * And the NAMES of the values?
 717          */
 718         BYTE            *b,**buffer=(LPBYTE*)vbuffer,*block=(LPBYTE)vblock;
 719         struct  db      *db;
 720         char            *s,*sb;
 721
 722         sb=strdupW2A(subblock);
 723         s=(char*)xmalloc(strlen("VS_VERSION_INFO")+strlen(sb)+1);
 724         strcpy(s,"VS_VERSION_INFO");strcat(s,sb);
 725         b=_find_data(block,s);
 726         if (b==NULL) {
 727                 *buflen=0;
 728                 free(sb);
 729                 return 0;
 730         }
 731         db=(struct db*)b;
 732         *buflen = db->datalen;
 733         /* let b point to data area */
 734         b       = b+4+((strlen(db->name)+4)&~3);
 735         *buffer = b;
 736         fprintf(stderr,"        -> %s=%s\n",sb,b);
 737         free(sb);
 738         return 1;
 739 }
 740 /* 20 GETFILEVERSIONINFORAW */