?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 971130
[wine/hacks.git] / misc / ver.c
blob422e6c3a5ba71bdcff94f4abe943982d9221b93c
1 /*
2 * Implementation of VER.DLL
3 *
4 * Copyright 1996,1997 Marcus Meissner
5 * Copyright 1997 David Cuthbert
6 */
7 #include <stdlib.h>
8 #include <stdio.h>
9 #include <string.h>
10 #include <ctype.h>
11 #include <unistd.h>
12 #include "windows.h"
13 #include "win.h"
14 #include "winerror.h"
15 #include "heap.h"
16 #include "ver.h"
17 #include "lzexpand.h"
18 #include "module.h"
19 #include "neexe.h"
20 #include "stddebug.h"
21 #include "debug.h"
22 #include "xmalloc.h"
23 #include "winreg.h"
24
25 #define LZREAD(what) \
26 if (sizeof(*what)!=LZRead32(lzfd,what,sizeof(*what))) return 0;
27 #define LZTELL(lzfd) LZSeek32(lzfd, 0, SEEK_CUR);
28
29 /******************************************************************************
30 *
31 * void ver_dstring(
32 * char const * prologue,
33 * char const * teststring,
34 * char const * epilogue )
35 *
36 * This function will print via dprintf_ver to stddeb the prologue string,
37 * followed by the address of teststring and the string it contains if
38 * teststring is non-null or "(null)" otherwise, and then the epilogue
39 * string.
40 *
41 * Revision history
42 * 30-May-1997 Dave Cuthbert (dacut@ece.cmu.edu)
43 * Original implementation as dprintf[_]ver_string
44 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
45 * Fixed problem that caused bug with tools/make_debug -- renaming
46 * this function should fix the problem.
47 *
48 *****************************************************************************/
49
50 static void ver_dstring(
51 char const * prologue,
52 char const * teststring,
53 char const * epilogue )
54 {
55 dprintf_ver(stddeb, "%s", prologue);
56
57 if(teststring)
58 dprintf_ver(stddeb, "%p (\"%s\")", (void const *) teststring,
59 teststring);
60 else
61 dprintf_ver(stddeb, "(null)");
62
63 dprintf_ver(stddeb, "%s", epilogue);
64
65 return;
66 }
67
68 /******************************************************************************
69 *
70 * int testFileExistence(
71 * char const * path,
72 * char const * file )
73 *
74 * Tests whether a given path/file combination exists. If the file does
75 * not exist, the return value is zero. If it does exist, the return
76 * value is non-zero.
77 *
78 * Revision history
79 * 30-May-1997 Dave Cuthbert (dacut@ece.cmu.edu)
80 * Original implementation
81 *
82 *****************************************************************************/
83
84 static int testFileExistence(
85 char const * path,
86 char const * file )
87 {
88 char filename[1024];
89 int filenamelen;
90 OFSTRUCT fileinfo;
91 int retval;
92
93 fileinfo.cBytes = sizeof(OFSTRUCT);
94
95 strcpy(filename, path);
96 filenamelen = strlen(filename);
97
98 /* Add a trailing \ if necessary */
99 if(filenamelen) {
100 if(filename[filenamelen - 1] != '\\')
101 strcat(filename, "\\");
102 }
103 else /* specify the current directory */
104 strcpy(filename, ".\\");
105
106 /* Create the full pathname */
107 strcat(filename, file);
108
109 if(OpenFile32(filename, &fileinfo, OF_EXIST) == HFILE_ERROR32)
110 retval = 0;
111 else
112 retval = 1;
113
114 return retval;
115 }
116
117 /******************************************************************************
118 *
119 * int testFileExclusiveExistence(
120 * char const * path,
121 * char const * file )
122 *
123 * Tests whether a given path/file combination exists and ensures that no
124 * other programs have handles to the given file. If the file does not
125 * exist or is open, the return value is zero. If it does exist, the
126 * return value is non-zero.
127 *
128 * Revision history
129 * 30-May-1997 Dave Cuthbert (dacut@ece.cmu.edu)
130 * Original implementation
131 *
132 *****************************************************************************/
133
134 static int testFileExclusiveExistence(
135 char const * path,
136 char const * file )
137 {
138 char filename[1024];
139 int filenamelen;
140 OFSTRUCT fileinfo;
141 int retval;
142
143 fileinfo.cBytes = sizeof(OFSTRUCT);
144
145 strcpy(filename, path);
146 filenamelen = strlen(filename);
147
148 /* Add a trailing \ if necessary */
149 if(filenamelen) {
150 if(filename[filenamelen - 1] != '\\')
151 strcat(filename, "\\");
152 }
153 else /* specify the current directory */
154 strcpy(filename, ".\\");
155
156 /* Create the full pathname */
157 strcat(filename, file);
158
159 if(OpenFile32(filename, &fileinfo, OF_EXIST | OF_SHARE_EXCLUSIVE) ==
160 HFILE_ERROR32)
161 retval = 0;
162 else
163 retval = 1;
164
165 return retval;
166 }
167
168
169 static int read_xx_header(HFILE32 lzfd) {
170 IMAGE_DOS_HEADER mzh;
171 char magic[2];
172
173 LZSeek32(lzfd,0,SEEK_SET);
174 if (sizeof(mzh)!=LZRead32(lzfd,&mzh,sizeof(mzh)))
175 return 0;
176 if (mzh.e_magic!=IMAGE_DOS_SIGNATURE)
177 return 0;
178 LZSeek32(lzfd,mzh.e_lfanew,SEEK_SET);
179 if (2!=LZRead32(lzfd,magic,2))
180 return 0;
181 LZSeek32(lzfd,mzh.e_lfanew,SEEK_SET);
182 if (magic[0] == 'N' && magic[1] == 'E')
183 return IMAGE_OS2_SIGNATURE;
184 if (magic[0] == 'P' && magic[1] == 'E')
185 return IMAGE_NT_SIGNATURE;
186 fprintf(stderr,"misc/ver.c:read_ne_header:can't handle %*s files.\n",2,magic);
187 return 0;
188 }
189
190
191 static int find_ne_resource(
192 HFILE32 lzfd,SEGPTR typeid,SEGPTR resid,
193 BYTE **resdata,int *reslen,DWORD *off
194 ) {
195 IMAGE_OS2_HEADER nehd;
196 NE_TYPEINFO ti;
197 NE_NAMEINFO ni;
198 int i;
199 WORD shiftcount;
200 DWORD nehdoffset;
201
202 nehdoffset = LZTELL(lzfd);
203 LZREAD(&nehd);
204 if (nehd.resource_tab_offset==nehd.rname_tab_offset) {
205 dprintf_ver(stddeb,"no resources in NE dll\n");
206 return 0;
207 }
208 LZSeek32(lzfd,nehd.resource_tab_offset+nehdoffset,SEEK_SET);
209 LZREAD(&shiftcount);
210 dprintf_ver(stddeb,"shiftcount is %d\n",shiftcount);
211 dprintf_ver(stddeb,"reading resource typeinfo dir.\n");
212
213 if (!HIWORD(typeid)) typeid = (SEGPTR)(LOWORD(typeid) | 0x8000);
214 if (!HIWORD(resid)) resid = (SEGPTR)(LOWORD(resid) | 0x8000);
215 while (1) {
216 int skipflag;
217
218 LZREAD(&ti);
219 if (!ti.type_id)
220 return 0;
221 dprintf_ver(stddeb," ti.typeid =%04x,count=%d\n",ti.type_id,ti.count);
222
223 skipflag=0;
224 if (!HIWORD(typeid)) {
225 if ((ti.type_id&0x8000)&&(typeid!=ti.type_id))
226 skipflag=1;
227 } else {
228 if (ti.type_id & 0x8000) {
229 skipflag=1;
230 } else {
231 BYTE len;
232 char *str;
233 DWORD whereleft;
234
235 whereleft = LZTELL(lzfd);
236 LZSeek32(
237 lzfd,
238 nehdoffset+nehd.resource_tab_offset+ti.type_id,
239 SEEK_SET
240 );
241 LZREAD(&len);
242 str=xmalloc(len);
243 if (len!=LZRead32(lzfd,str,len))
244 return 0;
245 dprintf_ver(stddeb,"read %s to compare it with %s\n",
246 str,(char*)PTR_SEG_TO_LIN(typeid)
247 );
248 if (lstrcmpi32A(str,(char*)PTR_SEG_TO_LIN(typeid)))
249 skipflag=1;
250 free(str);
251 LZSeek32(lzfd,whereleft,SEEK_SET);
252 }
253 }
254 if (skipflag) {
255 LZSeek32(lzfd,ti.count*sizeof(ni),SEEK_CUR);
256 continue;
257 }
258 for (i=0;i<ti.count;i++) {
259 WORD *rdata;
260 int len;
261
262 LZREAD(&ni);
263 dprintf_ver(stddeb," ni.id=%4x,offset=%d,length=%d\n",
264 ni.id,ni.offset,ni.length
265 );
266 skipflag=1;
267 if (!HIWORD(resid)) {
268 if (ni.id == resid)
269 skipflag=0;
270 } else {
271 if (!(ni.id & 0x8000)) {
272 BYTE len;
273 char *str;
274 DWORD whereleft;
275
276 whereleft = LZTELL(lzfd);
277 LZSeek32(
278 lzfd,
279 nehdoffset+nehd.resource_tab_offset+ni.id,
280 SEEK_SET
281 );
282 LZREAD(&len);
283 str=xmalloc(len);
284 if (len!=LZRead32(lzfd,str,len))
285 return 0;
286 dprintf_ver(stddeb,"read %s to compare it with %s\n",
287 str,(char*)PTR_SEG_TO_LIN(typeid)
288 );
289 if (!lstrcmpi32A(str,(char*)PTR_SEG_TO_LIN(typeid)))
290 skipflag=0;
291 free(str);
292 LZSeek32(lzfd,whereleft,SEEK_SET);
293 }
294 }
295 if (skipflag)
296 continue;
297 LZSeek32(lzfd,((int)ni.offset<<shiftcount),SEEK_SET);
298 *off = (int)ni.offset<<shiftcount;
299 len = ni.length<<shiftcount;
300 rdata=(WORD*)xmalloc(len);
301 if (len!=LZRead32(lzfd,rdata,len)) {
302 free(rdata);
303 return 0;
304 }
305 dprintf_ver(stddeb,"resource found.\n");
306 *resdata= (BYTE*)rdata;
307 *reslen = len;
308 return 1;
309 }
310 }
311 }
312
313 extern LPIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(
314 LPIMAGE_RESOURCE_DIRECTORY resdirptr,LPCWSTR name,DWORD root
315 );
316
317 /* Loads the specified PE resource.
318 * FIXME: shouldn't load the whole image
319 */
320 static int
321 find_pe_resource(
322 HFILE32 lzfd,LPWSTR typeid,LPWSTR resid,
323 BYTE **resdata,int *reslen,DWORD *off
324 ) {
325 IMAGE_NT_HEADERS pehd;
326 int i;
327 UINT32 nrofsections;
328 DWORD imagesize,pehdoffset;
329 BYTE *image;
330 IMAGE_DATA_DIRECTORY resdir;
331 LPIMAGE_RESOURCE_DIRECTORY resourcedir,xresdir;
332 LPIMAGE_RESOURCE_DATA_ENTRY xresdata;
333 LPIMAGE_SECTION_HEADER sections;
334
335 pehdoffset = LZTELL(lzfd);
336 LZREAD(&pehd);
337 resdir = pehd.OptionalHeader.DataDirectory[IMAGE_FILE_RESOURCE_DIRECTORY];
338 dprintf_ver(stddeb,"find_pe_resource(.,%p,%p,....)\n",typeid,resid);
339 if (!resdir.Size) {
340 fprintf(stderr,"misc/ver.c:find_pe_resource() no resource directory found in PE file.\n");
341 return 0;
342 }
343 imagesize = pehd.OptionalHeader.SizeOfImage;
344 image = HeapAlloc(GetProcessHeap(),0,imagesize);
345 nrofsections = pehd.FileHeader.NumberOfSections;
346
347 sections = (LPIMAGE_SECTION_HEADER)HeapAlloc(GetProcessHeap(),0,pehd.FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER));
348 LZSeek32(lzfd,
349 pehdoffset+
350 sizeof(DWORD)+ /* Signature */
351 sizeof(IMAGE_FILE_HEADER)+
352 pehd.FileHeader.SizeOfOptionalHeader,
353 SEEK_SET
354 );
355 if ( nrofsections*sizeof(IMAGE_SECTION_HEADER)!=
356 LZRead32(lzfd,sections,nrofsections*sizeof(IMAGE_SECTION_HEADER))
357 ) {
358 HeapFree(GetProcessHeap(),0,image);
359 return 0;
360 }
361 for (i=0;i<nrofsections;i++) {
362 if (sections[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
363 continue;
364 LZSeek32(lzfd,sections[i].PointerToRawData,SEEK_SET);
365 if ( sections[i].SizeOfRawData!=
366 LZRead32(lzfd,image+sections[i].VirtualAddress,sections[i].SizeOfRawData)
367 )
368 continue;
369 }
370 resourcedir = (LPIMAGE_RESOURCE_DIRECTORY)(image+resdir.VirtualAddress);
371 xresdir = GetResDirEntryW(resourcedir,typeid,(DWORD)resourcedir);
372 if (!xresdir) {
373 dprintf_ver(stddeb,"...no typeid entry found for %p\n",typeid);
374 HeapFree(GetProcessHeap(),0,image);
375 return 0;
376 }
377 xresdir = GetResDirEntryW(xresdir,resid,(DWORD)resourcedir);
378 if (!xresdir) {
379 dprintf_ver(stddeb,"...no resid entry found for %p\n",resid);
380 HeapFree(GetProcessHeap(),0,image);
381 return 0;
382 }
383
384 xresdir = GetResDirEntryW(xresdir,0,(DWORD)resourcedir);
385 if (!xresdir) {
386 dprintf_ver(stddeb,"...no 0 (default language) entry found for %p\n",resid);
387 HeapFree(GetProcessHeap(),0,image);
388 return 0;
389 }
390 xresdata = (LPIMAGE_RESOURCE_DATA_ENTRY)xresdir;
391 *reslen = xresdata->Size;
392 *resdata= (LPBYTE)xmalloc(*reslen);
393 memcpy(*resdata,image+xresdata->OffsetToData,*reslen);
394 /* find physical address for virtual offset */
395 for (i=0;i<nrofsections;i++) {
396 if (sections[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
397 continue;
398 if ( (xresdata->OffsetToData >= sections[i].VirtualAddress)&&
399 (xresdata->OffsetToData < sections[i].VirtualAddress+sections[i].SizeOfRawData)
400 ) {
401 *off = (DWORD)(xresdata->OffsetToData)-(DWORD)(sections[i].VirtualAddress)+(DWORD)(sections[i].PointerToRawData);
402 break;
403 }
404 }
405 HeapFree(GetProcessHeap(),0,image);
406 HeapFree(GetProcessHeap(),0,sections);
407 return 1;
408 }
409
410 /* GetFileResourceSize [VER.2] */
411 DWORD WINAPI GetFileResourceSize(LPCSTR filename,SEGPTR restype,SEGPTR resid,
412 LPDWORD off)
413 {
414 HFILE32 lzfd;
415 OFSTRUCT ofs;
416 BYTE *resdata = NULL;
417 int reslen=0;
418 int res=0;
419
420 dprintf_ver(stddeb,"GetFileResourceSize(%s,%lx,%lx,%p)\n",
421 filename,(LONG)restype,(LONG)resid,off
422 );
423 lzfd=LZOpenFile32A(filename,&ofs,OF_READ);
424 if (!lzfd)
425 return 0;
426 switch (read_xx_header(lzfd)) {
427 case 0:
428 res=0;
429 break;
430 case IMAGE_OS2_SIGNATURE:
431 res=find_ne_resource(lzfd,restype,resid,&resdata,&reslen,off);
432 break;
433 case IMAGE_NT_SIGNATURE:
434 res=find_pe_resource(lzfd,(LPWSTR)restype,(LPWSTR)resid,&resdata,&reslen,off);
435 break;
436 }
437 if (!res) {
438 LZClose32(lzfd);
439 return 0;
440 }
441 if (resdata)
442 free(resdata);
443 LZClose32(lzfd);
444 return reslen;
445 }
446
447 /* GetFileResource [VER.3] */
448 DWORD WINAPI GetFileResource(LPCSTR filename,SEGPTR restype,SEGPTR resid,
449 DWORD off,DWORD datalen,LPVOID data )
450 {
451 HFILE32 lzfd;
452 OFSTRUCT ofs;
453 BYTE *resdata=NULL;
454 int res=0;
455 int reslen=datalen;
456
457 dprintf_ver(stddeb,"GetFileResource(%s,%lx,%lx,%ld,%ld,%p)\n",
458 filename,(LONG)restype,(LONG)resid,off,datalen,data
459 );
460
461 lzfd=LZOpenFile32A(filename,&ofs,OF_READ);
462 if (lzfd==0)
463 return 0;
464 if (!off) {
465 switch (read_xx_header(lzfd)) {
466 case 0: res=0;
467 break;
468 case IMAGE_OS2_SIGNATURE:
469 res= find_ne_resource(lzfd,restype,resid,&resdata,&reslen,&off);
470 break;
471 case IMAGE_NT_SIGNATURE:
472 res= find_pe_resource(lzfd,(LPWSTR)restype,(LPWSTR)resid,&resdata,&reslen,&off);
473 break;
474 }
475 LZClose32(lzfd);
476 if (!res)
477 return 0;
478 if (reslen>datalen) reslen = datalen;
479 memcpy(data,resdata,reslen);
480 free(resdata);
481 return reslen;
482 }
483 LZSeek32(lzfd,off,SEEK_SET);
484 reslen = LZRead32(lzfd,data,datalen);
485 LZClose32(lzfd);
486 return reslen;
487 }
488
489 /* GetFileVersionInfoSize [VER.6] */
490 DWORD WINAPI GetFileVersionInfoSize16(LPCSTR filename,LPDWORD handle)
491 {
492 DWORD len,ret,isuni=0;
493 BYTE buf[144];
494 VS_FIXEDFILEINFO *vffi;
495
496 dprintf_ver(stddeb,"GetFileVersionInfoSize16(%s,%p)\n",filename,handle);
497 len=GetFileResourceSize(filename,VS_FILE_INFO,VS_VERSION_INFO,handle);
498 if (!len)
499 return 0;
500 ret=GetFileResource(
501 filename,VS_FILE_INFO,VS_VERSION_INFO,*handle,sizeof(buf),buf
502 );
503 if (!ret)
504 return 0;
505
506 vffi=(VS_FIXEDFILEINFO*)(buf+0x14);
507 if (vffi->dwSignature != VS_FFI_SIGNATURE) {
508 /* unicode resource */
509 if (vffi->dwSignature == 0x004f0049) {
510 isuni = 1;
511 vffi = (VS_FIXEDFILEINFO*)(buf+0x28);
512 } else {
513 fprintf(stderr,"vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
514 vffi->dwSignature,VS_FFI_SIGNATURE
515 );
516 return 0;
517 }
518 }
519 if (*(WORD*)buf < len)
520 len = *(WORD*)buf;
521 dprintf_ver(stddeb," structversion=0x%lx.0x%lx,\n fileversion=0x%lx.0x%lx,\n productversion=0x%lx.0x%lx,\n flagmask=0x%lx,\n flags=",
522 (vffi->dwStrucVersion>>16),vffi->dwStrucVersion&0xFFFF,
523 vffi->dwFileVersionMS,vffi->dwFileVersionLS,
524 vffi->dwProductVersionMS,vffi->dwProductVersionLS,
525 vffi->dwFileFlagsMask
526 );
527 if (vffi->dwFileFlags & VS_FF_DEBUG)
528 dprintf_ver(stddeb,"DEBUG,");
529 if (vffi->dwFileFlags & VS_FF_PRERELEASE)
530 dprintf_ver(stddeb,"PRERELEASE,");
531 if (vffi->dwFileFlags & VS_FF_PATCHED)
532 dprintf_ver(stddeb,"PATCHED,");
533 if (vffi->dwFileFlags & VS_FF_PRIVATEBUILD)
534 dprintf_ver(stddeb,"PRIVATEBUILD,");
535 if (vffi->dwFileFlags & VS_FF_INFOINFERRED)
536 dprintf_ver(stddeb,"INFOINFERRED,");
537 if (vffi->dwFileFlags & VS_FF_SPECIALBUILD)
538 dprintf_ver(stddeb,"SPECIALBUILD,");
539 dprintf_ver(stddeb,"\n OS=0x%lx.0x%lx (",
540 (vffi->dwFileOS&0xFFFF0000)>>16,
541 vffi->dwFileOS&0x0000FFFF
542 );
543 switch (vffi->dwFileOS&0xFFFF0000) {
544 case VOS_DOS:dprintf_ver(stddeb,"DOS,");break;
545 case VOS_OS216:dprintf_ver(stddeb,"OS/2-16,");break;
546 case VOS_OS232:dprintf_ver(stddeb,"OS/2-32,");break;
547 case VOS_NT:dprintf_ver(stddeb,"NT,");break;
548 case VOS_UNKNOWN:
549 default:
550 dprintf_ver(stddeb,"UNKNOWN(0x%lx),",vffi->dwFileOS&0xFFFF0000);break;
551 }
552 switch (vffi->dwFileOS & 0xFFFF) {
553 case VOS__BASE:dprintf_ver(stddeb,"BASE");break;
554 case VOS__WINDOWS16:dprintf_ver(stddeb,"WIN16");break;
555 case VOS__WINDOWS32:dprintf_ver(stddeb,"WIN32");break;
556 case VOS__PM16:dprintf_ver(stddeb,"PM16");break;
557 case VOS__PM32:dprintf_ver(stddeb,"PM32");break;
558 default:dprintf_ver(stddeb,"UNKNOWN(0x%lx)",vffi->dwFileOS&0xFFFF);break;
559 }
560 dprintf_ver(stddeb,")\n ");
561 switch (vffi->dwFileType) {
562 default:
563 case VFT_UNKNOWN:
564 dprintf_ver(stddeb,"filetype=Unknown(0x%lx)",vffi->dwFileType);
565 break;
566 case VFT_APP:dprintf_ver(stddeb,"filetype=APP,");break;
567 case VFT_DLL:dprintf_ver(stddeb,"filetype=DLL,");break;
568 case VFT_DRV:
569 dprintf_ver(stddeb,"filetype=DRV,");
570 switch(vffi->dwFileSubtype) {
571 default:
572 case VFT2_UNKNOWN:
573 dprintf_ver(stddeb,"UNKNOWN(0x%lx)",vffi->dwFileSubtype);
574 break;
575 case VFT2_DRV_PRINTER:
576 dprintf_ver(stddeb,"PRINTER");
577 break;
578 case VFT2_DRV_KEYBOARD:
579 dprintf_ver(stddeb,"KEYBOARD");
580 break;
581 case VFT2_DRV_LANGUAGE:
582 dprintf_ver(stddeb,"LANGUAGE");
583 break;
584 case VFT2_DRV_DISPLAY:
585 dprintf_ver(stddeb,"DISPLAY");
586 break;
587 case VFT2_DRV_MOUSE:
588 dprintf_ver(stddeb,"MOUSE");
589 break;
590 case VFT2_DRV_NETWORK:
591 dprintf_ver(stddeb,"NETWORK");
592 break;
593 case VFT2_DRV_SYSTEM:
594 dprintf_ver(stddeb,"SYSTEM");
595 break;
596 case VFT2_DRV_INSTALLABLE:
597 dprintf_ver(stddeb,"INSTALLABLE");
598 break;
599 case VFT2_DRV_SOUND:
600 dprintf_ver(stddeb,"SOUND");
601 break;
602 case VFT2_DRV_COMM:
603 dprintf_ver(stddeb,"COMM");
604 break;
605 case VFT2_DRV_INPUTMETHOD:
606 dprintf_ver(stddeb,"INPUTMETHOD");
607 break;
608 }
609 break;
610 case VFT_FONT:
611 dprintf_ver(stddeb,"filetype=FONT.");
612 switch (vffi->dwFileSubtype) {
613 default:
614 dprintf_ver(stddeb,"UNKNOWN(0x%lx)",vffi->dwFileSubtype);
615 break;
616 case VFT2_FONT_RASTER:dprintf_ver(stddeb,"RASTER");break;
617 case VFT2_FONT_VECTOR:dprintf_ver(stddeb,"VECTOR");break;
618 case VFT2_FONT_TRUETYPE:dprintf_ver(stddeb,"TRUETYPE");break;
619 }
620 break;
621 case VFT_VXD:dprintf_ver(stddeb,"filetype=VXD");break;
622 case VFT_STATIC_LIB:dprintf_ver(stddeb,"filetype=STATIC_LIB");break;
623 }
624 dprintf_ver(stddeb,"\n filedata=0x%lx.0x%lx\n",vffi->dwFileDateMS,vffi->dwFileDateLS);
625 return len;
626 }
627
628 /* GetFileVersionInfoSize32A [VERSION.1] */
629 DWORD WINAPI GetFileVersionInfoSize32A(LPCSTR filename,LPDWORD handle)
630 {
631 dprintf_ver(stddeb,"GetFileVersionInfoSize32A(%s,%p)\n",filename,handle);
632 return GetFileVersionInfoSize16(filename,handle);
633 }
634
635 /* GetFileVersionInfoSize32W [VERSION.2] */
636 DWORD WINAPI GetFileVersionInfoSize32W( LPCWSTR filename, LPDWORD handle )
637 {
638 LPSTR xfn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
639 DWORD ret = GetFileVersionInfoSize16( xfn, handle );
640 HeapFree( GetProcessHeap(), 0, xfn );
641 return ret;
642 }
643
644 /* GetFileVersionInfo [VER.7] */
645 DWORD WINAPI GetFileVersionInfo16(LPCSTR filename,DWORD handle,DWORD datasize,
646 LPVOID data)
647 {
648 dprintf_ver(stddeb,"GetFileVersionInfo16(%s,%ld,%ld,%p)\n->",
649 filename,handle,datasize,data
650 );
651 return GetFileResource(
652 filename,VS_FILE_INFO,VS_VERSION_INFO,handle,datasize,data
653 );
654 }
655
656 /* GetFileVersionInfoA [VERSION.0] */
657 DWORD WINAPI GetFileVersionInfo32A(LPCSTR filename,DWORD handle,
658 DWORD datasize,LPVOID data)
659 {
660 return GetFileVersionInfo16(filename,handle,datasize,data);
661 }
662
663 /* GetFileVersionInfoW [VERSION.3] */
664 DWORD WINAPI GetFileVersionInfo32W( LPCWSTR filename, DWORD handle,
665 DWORD datasize, LPVOID data)
666 {
667 LPSTR fn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
668 DWORD ret = GetFileVersionInfo16( fn, handle, datasize, data );
669 HeapFree( GetProcessHeap(), 0, fn );
670 return ret;
671 }
672
673 /*****************************************************************************
674 *
675 * VerFindFile() [VER.8]
676 * Determines where to install a file based on whether it locates another
677 * version of the file in the system. The values VerFindFile returns are
678 * used in a subsequent call to the VerInstallFile function.
679 *
680 * Revision history:
681 * 30-May-1997 Dave Cuthbert (dacut@ece.cmu.edu)
682 * Reimplementation of VerFindFile from original stub.
683 *
684 ****************************************************************************/
685
686 DWORD WINAPI VerFindFile16(
687 UINT16 flags,
688 LPCSTR lpszFilename,
689 LPCSTR lpszWinDir,
690 LPCSTR lpszAppDir,
691 LPSTR lpszCurDir,
692 UINT16 *lpuCurDirLen,
693 LPSTR lpszDestDir,
694 UINT16 *lpuDestDirLen )
695 {
696 DWORD retval;
697 char curDir[256];
698 char destDir[256];
699 unsigned int curDirSizeReq;
700 unsigned int destDirSizeReq;
701
702 retval = 0;
703
704 /* Print out debugging information */
705 dprintf_ver(stddeb, "VerFindFile() called with parameters:\n"
706 "\tflags = %x", flags);
707 if(flags & VFFF_ISSHAREDFILE)
708 dprintf_ver(stddeb, " (VFFF_ISSHAREDFILE)\n");
709 else
710 dprintf_ver(stddeb, "\n");
711
712 ver_dstring("\tlpszFilename = ", lpszFilename, "\n");
713 ver_dstring("\tlpszWinDir = ", lpszWinDir, "\n");
714 ver_dstring("\tlpszAppDir = ", lpszAppDir, "\n");
715
716 dprintf_ver(stddeb, "\tlpszCurDir = %p\n", lpszCurDir);
717 if(lpuCurDirLen)
718 dprintf_ver(stddeb, "\tlpuCurDirLen = %p (%u)\n",
719 lpuCurDirLen, *lpuCurDirLen);
720 else
721 dprintf_ver(stddeb, "\tlpuCurDirLen = (null)\n");
722
723 dprintf_ver(stddeb, "\tlpszDestDir = %p\n", lpszDestDir);
724 if(lpuDestDirLen)
725 dprintf_ver(stddeb, "\tlpuDestDirLen = %p (%u)\n",
726 lpuDestDirLen, *lpuDestDirLen);
727
728 /* Figure out where the file should go; shared files default to the
729 system directory */
730
731 strcpy(curDir, "");
732 strcpy(destDir, "");
733
734 if(flags & VFFF_ISSHAREDFILE && !getuid()) {
735 GetSystemDirectory32A(destDir, 256);
736
737 /* Were we given a filename? If so, try to find the file. */
738 if(lpszFilename) {
739 if(testFileExistence(destDir, lpszFilename)) {
740 strcpy(curDir, destDir);
741
742 if(!testFileExclusiveExistence(destDir, lpszFilename))
743 retval |= VFF_FILEINUSE;
744 }
745 else if(lpszAppDir && testFileExistence(lpszAppDir,
746 lpszFilename)) {
747 strcpy(curDir, lpszAppDir);
748 retval |= VFF_CURNEDEST;
749
750 if(!testFileExclusiveExistence(lpszAppDir, lpszFilename))
751 retval |= VFF_FILEINUSE;
752 }
753 }
754 }
755 else if(!(flags & VFFF_ISSHAREDFILE)) { /* not a shared file */
756 if(lpszAppDir) {
757 char systemDir[256];
758 GetSystemDirectory32A(systemDir, 256);
759
760 strcpy(destDir, lpszAppDir);
761
762 if(lpszFilename) {
763 if(testFileExistence(lpszAppDir, lpszFilename)) {
764 strcpy(curDir, lpszAppDir);
765
766 if(!testFileExclusiveExistence(lpszAppDir, lpszFilename))
767 retval |= VFF_FILEINUSE;
768 }
769 else if(testFileExistence(systemDir, lpszFilename)) {
770 strcpy(curDir, systemDir);
771 retval |= VFF_CURNEDEST;
772
773 if(!testFileExclusiveExistence(systemDir, lpszFilename))
774 retval |= VFF_FILEINUSE;
775 }
776 }
777 }
778 }
779
780 curDirSizeReq = strlen(curDir) + 1;
781 destDirSizeReq = strlen(destDir) + 1;
782
783
784
785 /* Make sure that the pointers to the size of the buffers are
786 valid; if not, do NOTHING with that buffer. If that pointer
787 is valid, then make sure that the buffer pointer is valid, too! */
788
789 if(lpuDestDirLen && lpszDestDir) {
790 if(*lpuDestDirLen < destDirSizeReq) {
791 retval |= VFF_BUFFTOOSMALL;
792 strncpy(lpszDestDir, destDir, *lpuDestDirLen - 1);
793 lpszDestDir[*lpuDestDirLen - 1] = '\0';
794 }
795 else
796 strcpy(lpszDestDir, destDir);
797
798 *lpuDestDirLen = destDirSizeReq;
799 }
800
801 if(lpuCurDirLen && lpszCurDir) {
802 if(*lpuCurDirLen < curDirSizeReq) {
803 retval |= VFF_BUFFTOOSMALL;
804 strncpy(lpszCurDir, curDir, *lpuCurDirLen - 1);
805 lpszCurDir[*lpuCurDirLen - 1] = '\0';
806 }
807 else
808 strcpy(lpszCurDir, curDir);
809
810 *lpuCurDirLen = curDirSizeReq;
811 }
812
813 dprintf_ver(stddeb, "VerFindFile() ret = %lu ",
814 retval);
815
816 if(retval) {
817 dprintf_ver(stddeb, "( ");
818
819 if(retval & VFF_CURNEDEST)
820 dprintf_ver(stddeb, "VFF_CURNEDEST ");
821 if(retval & VFF_FILEINUSE)
822 dprintf_ver(stddeb, "VFF_FILEINUSE ");
823 if(retval & VFF_BUFFTOOSMALL)
824 dprintf_ver(stddeb, "VFF_BUFFTOOSMALL ");
825
826 dprintf_ver(stddeb, ")");
827 }
828
829 ver_dstring("\n\t(Exit) lpszCurDir = ", lpszCurDir, "\n");
830 if(lpuCurDirLen)
831 dprintf_ver(stddeb, "\t(Exit) lpuCurDirLen = %p (%u)\n",
832 lpuCurDirLen, *lpuCurDirLen);
833 else
834 dprintf_ver(stddeb, "\t(Exit) lpuCurDirLen = (null)\n");
835
836 ver_dstring("\t(Exit) lpszDestDir = ", lpszDestDir, "\n");
837 if(lpuDestDirLen)
838 dprintf_ver(stddeb, "\t(Exit) lpuDestDirLen = %p (%u)\n",
839 lpuDestDirLen, *lpuDestDirLen);
840
841 return retval;
842 }
843
844 /* VerFindFileA [VERSION.5] */
845 DWORD WINAPI VerFindFile32A(
846 UINT32 flags,LPCSTR filename,LPCSTR windir,LPCSTR appdir,
847 LPSTR curdir,UINT32 *pcurdirlen,LPSTR destdir,UINT32 *pdestdirlen )
848 {
849 UINT16 curdirlen, destdirlen;
850 DWORD ret = VerFindFile16(flags,filename,windir,appdir,
851 curdir,&curdirlen,destdir,&destdirlen);
852 *pcurdirlen = curdirlen;
853 *pdestdirlen = destdirlen;
854 return ret;
855 }
856
857 /* VerFindFileW [VERSION.6] */
858 DWORD WINAPI VerFindFile32W(
859 UINT32 flags,LPCWSTR filename,LPCWSTR windir,LPCWSTR appdir,
860 LPWSTR curdir,UINT32 *pcurdirlen,LPWSTR destdir,UINT32 *pdestdirlen )
861 {
862 UINT16 curdirlen, destdirlen;
863 LPSTR wfn,wwd,wad,wdd,wcd;
864 DWORD ret;
865
866 wfn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
867 wwd = HEAP_strdupWtoA( GetProcessHeap(), 0, windir );
868 wad = HEAP_strdupWtoA( GetProcessHeap(), 0, appdir );
869 wcd = HeapAlloc( GetProcessHeap(), 0, *pcurdirlen );
870 wdd = HeapAlloc( GetProcessHeap(), 0, *pdestdirlen );
871 ret = VerFindFile16(flags,wfn,wwd,wad,wcd,&curdirlen,wdd,&destdirlen);
872 lstrcpynAtoW(curdir,wcd,*pcurdirlen);
873 lstrcpynAtoW(destdir,wdd,*pdestdirlen);
874 *pcurdirlen = strlen(wcd);
875 *pdestdirlen = strlen(wdd);
876 HeapFree( GetProcessHeap(), 0, wfn );
877 HeapFree( GetProcessHeap(), 0, wwd );
878 HeapFree( GetProcessHeap(), 0, wad );
879 HeapFree( GetProcessHeap(), 0, wcd );
880 HeapFree( GetProcessHeap(), 0, wdd );
881 return ret;
882 }
883
884 /* VerInstallFile [VER.9] */
885 DWORD WINAPI VerInstallFile16(
886 UINT16 flags,LPCSTR srcfilename,LPCSTR destfilename,LPCSTR srcdir,
887 LPCSTR destdir,LPCSTR curdir,LPSTR tmpfile,UINT16 *tmpfilelen )
888 {
889 UINT32 filelen;
890 DWORD ret= VerInstallFile32A(flags,srcfilename,destfilename,srcdir,
891 destdir,curdir,tmpfile,&filelen);
892
893 *tmpfilelen = filelen;
894 return ret;
895 }
896
897 /* VerInstallFileA [VERSION.7] */
898 static LPBYTE
899 _fetch_versioninfo(LPSTR fn,VS_FIXEDFILEINFO **vffi) {
900 DWORD alloclen;
901 LPBYTE buf;
902 DWORD ret;
903
904 alloclen = 1000;
905 buf= xmalloc(alloclen);
906 while (1) {
907 ret = GetFileVersionInfo32A(fn,0,alloclen,buf);
908 if (!ret) {
909 free(buf);
910 return 0;
911 }
912 if (alloclen<*(WORD*)buf) {
913 free(buf);
914 alloclen = *(WORD*)buf;
915 buf = xmalloc(alloclen);
916 } else {
917 *vffi = (VS_FIXEDFILEINFO*)(buf+0x14);
918 if ((*vffi)->dwSignature == 0x004f0049) /* hack to detect unicode */
919 *vffi = (VS_FIXEDFILEINFO*)(buf+0x28);
920 if ((*vffi)->dwSignature != VS_FFI_SIGNATURE)
921 fprintf(stderr,"_fetch_versioninfo:bad VS_FIXEDFILEINFO signature 0x%08lx\n",(*vffi)->dwSignature);
922 return buf;
923 }
924 }
925 }
926
927 static DWORD
928 _error2vif(DWORD error) {
929 switch (error) {
930 case ERROR_ACCESS_DENIED:
931 return VIF_ACCESSVIOLATION;
932 case ERROR_SHARING_VIOLATION:
933 return VIF_SHARINGVIOLATION;
934 default:
935 return 0;
936 }
937 }
938
939 /* VerInstallFile32A
940 */
941
942 DWORD WINAPI VerInstallFile32A(
943 UINT32 flags,LPCSTR srcfilename,LPCSTR destfilename,LPCSTR srcdir,
944 LPCSTR destdir,LPCSTR curdir,LPSTR tmpfile,UINT32 *tmpfilelen )
945 {
946 LPCSTR pdest;
947 char destfn[260],tmpfn[260],srcfn[260];
948 HFILE32 hfsrc,hfdst;
949 DWORD attr,ret,xret,tmplast;
950 LPBYTE buf1,buf2;
951 OFSTRUCT ofs;
952
953 fprintf(stddeb,"VerInstallFile(%x,%s,%s,%s,%s,%s,%p,%d)\n",
954 flags,srcfilename,destfilename,srcdir,destdir,curdir,tmpfile,*tmpfilelen
955 );
956 xret = 0;
957 sprintf(srcfn,"%s\\%s",srcdir,srcfilename);
958 if (!destdir || !*destdir) pdest = srcdir;
959 else pdest = destdir;
960 sprintf(destfn,"%s\\%s",pdest,destfilename);
961 hfsrc=LZOpenFile32A(srcfn,&ofs,OF_READ);
962 if (hfsrc==HFILE_ERROR32)
963 return VIF_CANNOTREADSRC;
964 sprintf(tmpfn,"%s\\%s",pdest,destfilename);
965 tmplast=strlen(pdest)+1;
966 attr = GetFileAttributes32A(tmpfn);
967 if (attr!=-1) {
968 if (attr & FILE_ATTRIBUTE_READONLY) {
969 LZClose32(hfsrc);
970 return VIF_WRITEPROT;
971 }
972 /* FIXME: check if file currently in use and return VIF_FILEINUSE */
973 }
974 attr = -1;
975 if (flags & VIFF_FORCEINSTALL) {
976 if (tmpfile[0]) {
977 sprintf(tmpfn,"%s\\%s",pdest,tmpfile);
978 tmplast = strlen(pdest)+1;
979 attr = GetFileAttributes32A(tmpfn);
980 /* if it exists, it has been copied by the call before.
981 * we jump over the copy part...
982 */
983 }
984 }
985 if (attr == -1) {
986 char *s;
987
988 GetTempFileName32A(pdest,"ver",0,tmpfn); /* should not fail ... */
989 s=strrchr(tmpfn,'\\');
990 if (s)
991 tmplast = s-tmpfn;
992 else
993 tmplast = 0;
994 hfdst = OpenFile32(tmpfn,&ofs,OF_CREATE);
995 if (hfdst == HFILE_ERROR32) {
996 LZClose32(hfsrc);
997 return VIF_CANNOTCREATE; /* | translated dos error */
998 }
999 ret = LZCopy32(hfsrc,hfdst);
1000 _lclose32(hfdst);
1001 if (((long) ret) < 0) {
1002 /* translate LZ errors into VIF_xxx */
1003 switch (ret) {
1004 case LZERROR_BADINHANDLE:
1005 case LZERROR_READ:
1006 case LZERROR_BADVALUE:
1007 case LZERROR_UNKNOWNALG:
1008 ret = VIF_CANNOTREADSRC;
1009 break;
1010 case LZERROR_BADOUTHANDLE:
1011 case LZERROR_WRITE:
1012 ret = VIF_OUTOFMEMORY; /* FIXME: correct? */
1013 break;
1014 case LZERROR_GLOBALLOC:
1015 case LZERROR_GLOBLOCK:
1016 ret = VIF_OUTOFSPACE;
1017 break;
1018 default: /* unknown error, should not happen */
1019 ret = 0;
1020 break;
1021 }
1022 if (ret) {
1023 LZClose32(hfsrc);
1024 return ret;
1025 }
1026 }
1027 }
1028 xret = 0;
1029 if (!(flags & VIFF_FORCEINSTALL)) {
1030 VS_FIXEDFILEINFO *destvffi,*tmpvffi;
1031 buf1 = _fetch_versioninfo(destfn,&destvffi);
1032 if (buf1) {
1033 buf2 = _fetch_versioninfo(tmpfn,&tmpvffi);
1034 if (buf2) {
1035 char *tbuf1,*tbuf2;
1036 UINT32 len1,len2;
1037
1038 len1=len2=40;
1039
1040 /* compare file versions */
1041 if ((destvffi->dwFileVersionMS > tmpvffi->dwFileVersionMS)||
1042 ((destvffi->dwFileVersionMS==tmpvffi->dwFileVersionMS)&&
1043 (destvffi->dwFileVersionLS > tmpvffi->dwFileVersionLS)
1044 )
1045 )
1046 xret |= VIF_MISMATCH|VIF_SRCOLD;
1047 /* compare filetypes and filesubtypes */
1048 if ((destvffi->dwFileType!=tmpvffi->dwFileType) ||
1049 (destvffi->dwFileSubtype!=tmpvffi->dwFileSubtype)
1050 )
1051 xret |= VIF_MISMATCH|VIF_DIFFTYPE;
1052 if (VerQueryValue32A(buf1,"\\VarFileInfo\\Translation",(LPVOID*)&tbuf1,&len1) &&
1053 VerQueryValue32A(buf2,"\\VarFileInfo\\Translation",(LPVOID*)&tbuf2,&len2)
1054 ) {
1055 /* irgendwas mit tbuf1 und tbuf2 machen
1056 * generiert DIFFLANG|MISMATCH
1057 */
1058 }
1059 free(buf2);
1060 } else
1061 xret=VIF_MISMATCH|VIF_SRCOLD;
1062 free(buf1);
1063 }
1064 }
1065 if (xret) {
1066 if (*tmpfilelen<strlen(tmpfn+tmplast)) {
1067 xret|=VIF_BUFTOSMALL;
1068 DeleteFile32A(tmpfn);
1069 } else {
1070 strcpy(tmpfile,tmpfn+tmplast);
1071 *tmpfilelen = strlen(tmpfn+tmplast)+1;
1072 xret|=VIF_TEMPFILE;
1073 }
1074 } else {
1075 if (-1!=GetFileAttributes32A(destfn))
1076 if (!DeleteFile32A(destfn)) {
1077 xret|=_error2vif(GetLastError())|VIF_CANNOTDELETE;
1078 DeleteFile32A(tmpfn);
1079 LZClose32(hfsrc);
1080 return xret;
1081 }
1082 if ((!(flags & VIFF_DONTDELETEOLD)) &&
1083 curdir &&
1084 *curdir &&
1085 lstrcmpi32A(curdir,pdest)
1086 ) {
1087 char curfn[260];
1088
1089 sprintf(curfn,"%s\\%s",curdir,destfilename);
1090 if (-1!=GetFileAttributes32A(curfn)) {
1091 /* FIXME: check if in use ... if it is, VIF_CANNOTDELETECUR */
1092 if (!DeleteFile32A(curfn))
1093 xret|=_error2vif(GetLastError())|VIF_CANNOTDELETECUR;
1094 }
1095 }
1096 if (!MoveFile32A(tmpfn,destfn)) {
1097 xret|=_error2vif(GetLastError())|VIF_CANNOTRENAME;
1098 DeleteFile32A(tmpfn);
1099 }
1100 }
1101 LZClose32(hfsrc);
1102 return xret;
1103 }
1104
1105 /* VerInstallFileW [VERSION.8] */
1106 DWORD WINAPI VerInstallFile32W(
1107 UINT32 flags,LPCWSTR srcfilename,LPCWSTR destfilename,LPCWSTR srcdir,
1108 LPCWSTR destdir,LPCWSTR curdir,LPWSTR tmpfile,UINT32 *tmpfilelen )
1109 {
1110 LPSTR wsrcf,wsrcd,wdestf,wdestd,wtmpf,wcurd;
1111 DWORD ret;
1112
1113 wsrcf = HEAP_strdupWtoA( GetProcessHeap(), 0, srcfilename );
1114 wsrcd = HEAP_strdupWtoA( GetProcessHeap(), 0, srcdir );
1115 wdestf = HEAP_strdupWtoA( GetProcessHeap(), 0, destfilename );
1116 wdestd = HEAP_strdupWtoA( GetProcessHeap(), 0, destdir );
1117 wtmpf = HEAP_strdupWtoA( GetProcessHeap(), 0, tmpfile );
1118 wcurd = HEAP_strdupWtoA( GetProcessHeap(), 0, curdir );
1119 ret = VerInstallFile32A(flags,wsrcf,wdestf,wsrcd,wdestd,wcurd,wtmpf,tmpfilelen);
1120 if (!ret)
1121 lstrcpynAtoW(tmpfile,wtmpf,*tmpfilelen);
1122 HeapFree( GetProcessHeap(), 0, wsrcf );
1123 HeapFree( GetProcessHeap(), 0, wsrcd );
1124 HeapFree( GetProcessHeap(), 0, wdestf );
1125 HeapFree( GetProcessHeap(), 0, wdestd );
1126 HeapFree( GetProcessHeap(), 0, wtmpf );
1127 if (wcurd)
1128 HeapFree( GetProcessHeap(), 0, wcurd );
1129 return ret;
1130 }
1131
1132
1133 struct dbA {
1134 WORD nextoff;
1135 WORD datalen;
1136 /* in memory structure... */
1137 char name[1]; /* padded to dword alignment */
1138 /* ....
1139 char data[datalen]; padded to dword alignment
1140 BYTE subdirdata[]; until nextoff
1141 */
1142 };
1143
1144 #define DATA_OFFSET_A(db) ((4+(strlen((db)->name)+4))&~3)
1145
1146 struct dbW {
1147 WORD nextoff;
1148 WORD datalen;
1149 WORD btext; /* type of data */
1150 /* in memory structure... */
1151 WCHAR name[1]; /* padded to dword alignment */
1152 /* ....
1153 WCHAR data[datalen]; padded to dword alignment
1154 BYTE subdirdata[]; until nextoff
1155 */
1156 };
1157
1158 /* WORD nextoffset;
1159 * WORD datalength;
1160 * WORD btype;
1161 * WCHAR szKey[]; (zero terminated)
1162 * PADDING (round up to nearest 32bit boundary)
1163 */
1164 #define DATA_OFFSET_W(db) ((2+2+2+((lstrlen32W((db)->name)+1)*2+3))&~3)
1165
1166 /* this one used for Win16 resources, which are always in ASCII format */
1167 static BYTE*
1168 _find_dataA(BYTE *block,LPCSTR str, int buff_remain) {
1169 char *nextslash;
1170 int substrlen, inc_size;
1171 struct dbA *db;
1172
1173 while (*str && *str=='\\')
1174 str++;
1175 if (NULL!=(nextslash=strchr(str,'\\')))
1176 substrlen=nextslash-str;
1177 else
1178 substrlen=strlen(str);
1179 if (nextslash!=NULL) {
1180 while (*nextslash && *nextslash=='\\')
1181 nextslash++;
1182 if (!*nextslash)
1183 nextslash=NULL;
1184 }
1185
1186
1187 while (1) {
1188 db=(struct dbA*)block;
1189 dprintf_ver(stddeb,"db=%p,db->nextoff=%d,db->datalen=%d,db->name=%s\n",
1190 db,db->nextoff,db->datalen,db->name
1191 );
1192 if ((!db->nextoff) || (buff_remain<=0)) /* no more entries ? */
1193 return NULL;
1194
1195 dprintf_ver(stddeb,"comparing with %s\n",db->name);
1196 if (!lstrncmpi32A(db->name,str,substrlen)) {
1197 if (nextslash) {
1198 inc_size=DATA_OFFSET_A(db)+((db->datalen+3)&~3);
1199 return _find_dataA(block+inc_size,nextslash,
1200 db->nextoff-inc_size);
1201 } else
1202 return block;
1203 }
1204 inc_size = ((db->nextoff+3)&~3);
1205 block += inc_size;
1206 buff_remain -= inc_size;
1207 }
1208 }
1209
1210 /* this one used for Win32 resources, which are always in UNICODE format */
1211 extern LPWSTR CRTDLL_wcschr(LPCWSTR str,WCHAR xchar);
1212 static BYTE*
1213 _find_dataW(BYTE *block,LPCWSTR str, int buff_remain) {
1214 LPWSTR nextslash;
1215 int substrlen, inc_size;
1216 struct dbW *db;
1217
1218
1219 while (*str && *str=='\\')
1220 str++;
1221 if (NULL!=(nextslash=CRTDLL_wcschr(str,'\\')))
1222 substrlen=nextslash-str;
1223 else
1224 substrlen=lstrlen32W(str);
1225 if (nextslash!=NULL) {
1226 while (*nextslash && *nextslash=='\\')
1227 nextslash++;
1228 if (!*nextslash)
1229 nextslash=NULL;
1230 }
1231
1232
1233 while (1) {
1234 char *xs,*vs;
1235 db=(struct dbW*)block;
1236 xs= HEAP_strdupWtoA(GetProcessHeap(),0,db->name);
1237 if (db->datalen) {
1238 if (db->btext)
1239 vs = HEAP_strdupWtoA(GetProcessHeap(),0,(WCHAR*)((block+DATA_OFFSET_W(db))));
1240 else
1241 vs = HEAP_strdupA(GetProcessHeap(),0,"not a string");
1242 } else
1243 vs = HEAP_strdupA(GetProcessHeap(),0,"no data");
1244
1245 dprintf_ver(stddeb,"db->nextoff=%d,db->name=%s,db->data=\"%s\"\n",
1246 db->nextoff,xs,vs
1247 );
1248 HeapFree(GetProcessHeap(),0,vs);
1249 HeapFree(GetProcessHeap(),0,xs);
1250 if ((!db->nextoff) || (buff_remain<=0)) /* no more entries ? */
1251 return NULL;
1252
1253 if (!lstrncmpi32W(db->name,str,substrlen)) {
1254 if (nextslash) {
1255 /* DATA_OFFSET_W(db) (padded to 32bit already)
1256 * DATA[datalength]
1257 * PADDING (round up to nearest 32bit boundary)
1258 * --> next level structs
1259 */
1260 inc_size=DATA_OFFSET_W(db)+((db->datalen+3)&~3);
1261 return _find_dataW( block+inc_size ,nextslash,
1262 db->nextoff-inc_size);
1263 } else
1264 return block;
1265 }
1266 /* skip over this block, round up to nearest 32bit boundary */
1267 inc_size = ((db->nextoff+3)&~3);
1268 block += inc_size;
1269 buff_remain -= inc_size;
1270 }
1271 }
1272
1273 /* VerQueryValue [VER.11] */
1274 /* take care, 'buffer' is NOT a SEGPTR, it just points to one */
1275 DWORD WINAPI VerQueryValue16(SEGPTR segblock,LPCSTR subblock,SEGPTR *buffer,
1276 UINT16 *buflen)
1277 {
1278 LPSTR s;
1279 BYTE *block=PTR_SEG_TO_LIN(segblock),*b;
1280
1281 dprintf_ver(stddeb,"VerQueryValue16(%p,%s,%p,%d)\n",
1282 block,subblock,buffer,*buflen
1283 );
1284
1285 s=(char*)xmalloc(strlen("VS_VERSION_INFO\\")+strlen(subblock)+1);
1286 strcpy(s,"VS_VERSION_INFO\\");strcat(s,subblock);
1287 /* check for UNICODE version */
1288 if ( (*(DWORD*)(block+0x14) != VS_FFI_SIGNATURE) &&
1289 (*(DWORD*)(block+0x28) == VS_FFI_SIGNATURE)
1290 ) {
1291 struct dbW *db;
1292 LPWSTR wstr;
1293 LPSTR xs;
1294
1295 wstr = HEAP_strdupAtoW(GetProcessHeap(),0,s);
1296 b=_find_dataW(block,wstr,*(WORD*)block);
1297 HeapFree(GetProcessHeap(),0,wstr);
1298 if (!b) {
1299 fprintf(stderr,"key %s not found in versionresource.\n",s);
1300 *buflen=0;
1301 return 0;
1302 }
1303 db=(struct dbW*)b;
1304 b = b+DATA_OFFSET_W(db);
1305 *buflen = db->datalen;
1306 if (db->btext) {
1307 xs = HEAP_strdupWtoA(GetProcessHeap(),0,(WCHAR*)b);
1308 dprintf_ver(stderr,"->%s\n",xs);
1309 HeapFree(GetProcessHeap(),0,xs);
1310 } else
1311 dprintf_ver(stderr,"->%p\n",b);
1312 } else {
1313 struct dbA *db;
1314 b=_find_dataA(block,s,*(WORD*)block);
1315 if (!b) {
1316 fprintf(stderr,"key %s not found in versionresource.\n",s);
1317 *buflen=0;
1318 return 0;
1319 }
1320 db=(struct dbA*)b;
1321 b = b+DATA_OFFSET_A(db);
1322 *buflen = db->datalen;
1323 /* the string is only printable, if it is below \\StringFileInfo*/
1324 if (!lstrncmpi32A("VS_VERSION_INFO\\StringFileInfo\\",s,strlen("VS_VERSION_INFO\\StringFileInfo\\")))
1325 dprintf_ver(stddeb," -> %s=%s\n",subblock,b);
1326 else
1327 dprintf_ver(stddeb," -> %s=%p\n",subblock,b);
1328 }
1329 *buffer = (b-block)+segblock;
1330 free(s);
1331 return 1;
1332 }
1333
1334 DWORD WINAPI VerQueryValue32A(LPVOID vblock,LPCSTR subblock,
1335 LPVOID *vbuffer,UINT32 *buflen)
1336 {
1337 BYTE *b,*block=(LPBYTE)vblock,**buffer=(LPBYTE*)vbuffer;
1338 LPSTR s;
1339
1340 dprintf_ver(stddeb,"VerQueryValue32A(%p,%s,%p,%d)\n",
1341 block,subblock,buffer,*buflen
1342 );
1343
1344 s=(char*)xmalloc(strlen("VS_VERSION_INFO\\")+strlen(subblock)+1);
1345 strcpy(s,"VS_VERSION_INFO\\");strcat(s,subblock);
1346
1347 /* check for UNICODE version */
1348 if ( (*(DWORD*)(block+0x14) != VS_FFI_SIGNATURE) &&
1349 (*(DWORD*)(block+0x28) == VS_FFI_SIGNATURE)
1350 ) {
1351 LPWSTR wstr;
1352 LPSTR xs;
1353 struct dbW *db;
1354
1355 wstr = HEAP_strdupAtoW(GetProcessHeap(),0,s);
1356 b=_find_dataW(block,wstr,*(WORD*)block);
1357 HeapFree(GetProcessHeap(),0,wstr);
1358 if (!b) {
1359 fprintf(stderr,"key %s not found in versionresource.\n",s);
1360 *buflen=0;
1361 return 0;
1362 }
1363 db = (struct dbW*)b;
1364 *buflen = db->datalen;
1365 b = b+DATA_OFFSET_W(db);
1366 if (db->btext) {
1367 xs = HEAP_strdupWtoA(GetProcessHeap(),0,(WCHAR*)b);
1368 dprintf_ver(stderr,"->%s\n",xs);
1369 HeapFree(GetProcessHeap(),0,xs);
1370 } else
1371 dprintf_ver(stderr,"->%p\n",b);
1372 } else {
1373 struct dbA *db;
1374 b=_find_dataA(block,s,*(WORD*)block);
1375 if (!b) {
1376 fprintf(stderr,"key %s not found in versionresource.\n",subblock);
1377 *buflen=0;
1378 return 0;
1379 }
1380 db=(struct dbA*)b;
1381 *buflen = db->datalen;
1382 b = b+DATA_OFFSET_A(db);
1383
1384 /* the string is only printable, if it is below \\StringFileInfo*/
1385 if (!lstrncmpi32A("VS_VERSION_INFO\\StringFileInfo\\",s,strlen("VS_VERSION_INFO\\StringFileInfo\\")))
1386 dprintf_ver(stddeb," -> %s=%s\n",subblock,b);
1387 else
1388 dprintf_ver(stddeb," -> %s=%p\n",subblock,b);
1389 }
1390 *buffer = b;
1391 free(s);
1392 return 1;
1393 }
1394
1395 DWORD WINAPI VerQueryValue32W(LPVOID vblock,LPCWSTR subblock,LPVOID *vbuffer,
1396 UINT32 *buflen)
1397 {
1398 LPSTR sb;
1399 DWORD ret;
1400
1401 sb = HEAP_strdupWtoA( GetProcessHeap(), 0, subblock );
1402 ret = VerQueryValue32A(vblock,sb,vbuffer,buflen);
1403 HeapFree( GetProcessHeap(), 0, sb );
1404 return 1;
1405 }
1406 /* 20 GETFILEVERSIONINFORAW */
useful hacks and other patches not (yet) suitable for mainline