source: trunk/src/version/info.c@ 10367

Last change on this file since 10367 was 10300, checked in by sandervl, 22 years ago

flexible debug logging
File size: 22.3 KB
Line 
1/*
2 * Implementation of VERSION.DLL - Version Info access
3 *
4 * Copyright 1996,1997 Marcus Meissner
5 * Copyright 1997 David Cuthbert
6 * Copyright 1999 Ulrich Weigand
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * TODO
23 * o Verify VerQueryValue()
24 */
25
26#include <stdarg.h>
27#include <stdlib.h>
28#include <string.h>
29
30#include "windef.h"
31#include "winbase.h"
32#include "winreg.h"
33#include "winver.h"
34#include "wine/winuser16.h"
35#include "wine/unicode.h"
36#include "winerror.h"
37#include "wine/debug.h"
38
39#define DBG_LOCALLOG DBG_info
40#include "dbglocal.h"
41
42WINE_DEFAULT_DEBUG_CHANNEL(ver);
43
44
45/******************************************************************************
46 *
47 * This function will print via dprintf[_]ver to stddeb debug info regarding
48 * the file info structure vffi.
49 * 15-Feb-1998 Dimitrie Paun (dimi@cs.toronto.edu)
50 * Added this function to clean up the code.
51 *
52 *****************************************************************************/
53#ifdef DEBUG
54static void print_vffi_debug(VS_FIXEDFILEINFO *vffi)
55{
56 TRACE(" structversion=%u.%u, fileversion=%u.%u.%u.%u, productversion=%u.%u.%u.%u, flagmask=0x%lx, flags=%s%s%s%s%s%s\n",
57 HIWORD(vffi->dwStrucVersion),LOWORD(vffi->dwStrucVersion),
58 HIWORD(vffi->dwFileVersionMS),LOWORD(vffi->dwFileVersionMS),
59 HIWORD(vffi->dwFileVersionLS),LOWORD(vffi->dwFileVersionLS),
60 HIWORD(vffi->dwProductVersionMS),LOWORD(vffi->dwProductVersionMS),
61 HIWORD(vffi->dwProductVersionLS),LOWORD(vffi->dwProductVersionLS),
62 vffi->dwFileFlagsMask,
63 (vffi->dwFileFlags & VS_FF_DEBUG) ? "DEBUG," : "",
64 (vffi->dwFileFlags & VS_FF_PRERELEASE) ? "PRERELEASE," : "",
65 (vffi->dwFileFlags & VS_FF_PATCHED) ? "PATCHED," : "",
66 (vffi->dwFileFlags & VS_FF_PRIVATEBUILD) ? "PRIVATEBUILD," : "",
67 (vffi->dwFileFlags & VS_FF_INFOINFERRED) ? "INFOINFERRED," : "",
68 (vffi->dwFileFlags & VS_FF_SPECIALBUILD) ? "SPECIALBUILD," : ""
69 );
70
71 TRACE("(");
72 TRACE(" OS=0x%x.0x%x ",
73 HIWORD(vffi->dwFileOS),
74 LOWORD(vffi->dwFileOS)
75 );
76 switch (vffi->dwFileOS&0xFFFF0000) {
77 case VOS_DOS:TRACE("DOS,");break;
78 case VOS_OS216:TRACE("OS/2-16,");break;
79 case VOS_OS232:TRACE("OS/2-32,");break;
80 case VOS_NT:TRACE("NT,");break;
81 case VOS_UNKNOWN:
82 default:
83 TRACE("UNKNOWN(0x%lx),",vffi->dwFileOS&0xFFFF0000);break;
84 }
85 switch (LOWORD(vffi->dwFileOS)) {
86 case VOS__BASE:TRACE("BASE");break;
87 case VOS__WINDOWS16:TRACE("WIN16");break;
88 case VOS__WINDOWS32:TRACE("WIN32");break;
89 case VOS__PM16:TRACE("PM16");break;
90 case VOS__PM32:TRACE("PM32");break;
91 default:TRACE("UNKNOWN(0x%x)",LOWORD(vffi->dwFileOS));break;
92 }
93 TRACE(")\n");
94
95 switch (vffi->dwFileType) {
96 default:
97 case VFT_UNKNOWN:
98 TRACE("filetype=Unknown(0x%lx)",vffi->dwFileType);
99 break;
100 case VFT_APP:TRACE("filetype=APP,");break;
101 case VFT_DLL:TRACE("filetype=DLL,");break;
102 case VFT_DRV:
103 TRACE("filetype=DRV,");
104 switch(vffi->dwFileSubtype) {
105 default:
106 case VFT2_UNKNOWN:
107 TRACE("UNKNOWN(0x%lx)",vffi->dwFileSubtype);
108 break;
109 case VFT2_DRV_PRINTER:
110 TRACE("PRINTER");
111 break;
112 case VFT2_DRV_KEYBOARD:
113 TRACE("KEYBOARD");
114 break;
115 case VFT2_DRV_LANGUAGE:
116 TRACE("LANGUAGE");
117 break;
118 case VFT2_DRV_DISPLAY:
119 TRACE("DISPLAY");
120 break;
121 case VFT2_DRV_MOUSE:
122 TRACE("MOUSE");
123 break;
124 case VFT2_DRV_NETWORK:
125 TRACE("NETWORK");
126 break;
127 case VFT2_DRV_SYSTEM:
128 TRACE("SYSTEM");
129 break;
130 case VFT2_DRV_INSTALLABLE:
131 TRACE("INSTALLABLE");
132 break;
133 case VFT2_DRV_SOUND:
134 TRACE("SOUND");
135 break;
136 case VFT2_DRV_COMM:
137 TRACE("COMM");
138 break;
139 case VFT2_DRV_INPUTMETHOD:
140 TRACE("INPUTMETHOD");
141 break;
142 }
143 break;
144 case VFT_FONT:
145 TRACE("filetype=FONT.");
146 switch (vffi->dwFileSubtype) {
147 default:
148 TRACE("UNKNOWN(0x%lx)",vffi->dwFileSubtype);
149 break;
150 case VFT2_FONT_RASTER:TRACE("RASTER");break;
151 case VFT2_FONT_VECTOR:TRACE("VECTOR");break;
152 case VFT2_FONT_TRUETYPE:TRACE("TRUETYPE");break;
153 }
154 break;
155 case VFT_VXD:TRACE("filetype=VXD");break;
156 case VFT_STATIC_LIB:TRACE("filetype=STATIC_LIB");break;
157 }
158 TRACE("\n");
159 TRACE(" filedata=0x%lx.0x%lx\n",
160 vffi->dwFileDateMS,vffi->dwFileDateLS);
161}
162#else
163#define print_vffi_debug(a)
164#endif
165
166/***********************************************************************
167 * Version Info Structure
168 */
169
170typedef struct
171{
172 WORD wLength;
173 WORD wValueLength;
174 CHAR szKey[1];
175#if 0 /* variable length structure */
176 /* DWORD aligned */
177 BYTE Value[];
178 /* DWORD aligned */
179 VS_VERSION_INFO_STRUCT16 Children[];
180#endif
181} VS_VERSION_INFO_STRUCT16;
182
183typedef struct
184{
185 WORD wLength;
186 WORD wValueLength;
187 WORD bText;
188 WCHAR szKey[1];
189#if 0 /* variable length structure */
190 /* DWORD aligned */
191 BYTE Value[];
192 /* DWORD aligned */
193 VS_VERSION_INFO_STRUCT32 Children[];
194#endif
195} VS_VERSION_INFO_STRUCT32;
196
197#define VersionInfoIs16( ver ) \
198 ( ((VS_VERSION_INFO_STRUCT16 *)ver)->szKey[0] >= ' ' )
199
200#define DWORD_ALIGN( base, ptr ) \
201 ( (LPBYTE)(base) + ((((LPBYTE)(ptr) - (LPBYTE)(base)) + 3) & ~3) )
202
203#define VersionInfo16_Value( ver ) \
204 DWORD_ALIGN( (ver), (ver)->szKey + strlen((ver)->szKey) + 1 )
205#define VersionInfo32_Value( ver ) \
206 DWORD_ALIGN( (ver), (ver)->szKey + strlenW((ver)->szKey) + 1 )
207
208#define VersionInfo16_Children( ver ) \
209 (VS_VERSION_INFO_STRUCT16 *)( VersionInfo16_Value( ver ) + \
210 ( ( (ver)->wValueLength + 3 ) & ~3 ) )
211#define VersionInfo32_Children( ver ) \
212 (VS_VERSION_INFO_STRUCT32 *)( VersionInfo32_Value( ver ) + \
213 ( ( (ver)->wValueLength * \
214 ((ver)->bText? 2 : 1) + 3 ) & ~3 ) )
215
216#define VersionInfo16_Next( ver ) \
217 (VS_VERSION_INFO_STRUCT16 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) )
218#define VersionInfo32_Next( ver ) \
219 (VS_VERSION_INFO_STRUCT32 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) )
220
221/***********************************************************************
222 * ConvertVersionInfo32To16 [internal]
223 */
224void ConvertVersionInfo32To16( VS_VERSION_INFO_STRUCT32 *info32,
225 VS_VERSION_INFO_STRUCT16 *info16 )
226{
227 /* Copy data onto local stack to prevent overwrites */
228 WORD wLength = info32->wLength;
229 WORD wValueLength = info32->wValueLength;
230 WORD bText = info32->bText;
231 LPBYTE lpValue = VersionInfo32_Value( info32 );
232 VS_VERSION_INFO_STRUCT32 *child32 = VersionInfo32_Children( info32 );
233 VS_VERSION_INFO_STRUCT16 *child16;
234
235 dprintf(("Converting %p to %p\n", info32, info16 ));
236 dprintf(("wLength %d, wValueLength %d, bText %d, value %p, child %p\n",
237 wLength, wValueLength, bText, lpValue, child32 ));
238
239 /* Convert key */
240 WideCharToMultiByte( CP_ACP, 0, info32->szKey, -1, info16->szKey, 0x7fffffff, NULL, NULL );
241
242 dprintf(("Copied key from %p to %p: %s\n", info32->szKey, info16->szKey,
243 debugstr_a(info16->szKey) ));
244
245 /* Convert value */
246 if ( wValueLength == 0 )
247 {
248 info16->wValueLength = 0;
249 dprintf(("No value present\n" ));
250 }
251 else if ( bText )
252 {
253 info16->wValueLength = WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)lpValue, -1, NULL, 0, NULL, NULL );
254 WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)lpValue, -1,
255 VersionInfo16_Value( info16 ), info16->wValueLength, NULL, NULL );
256
257 dprintf(("Copied value from %p to %p: %s\n", lpValue,
258 VersionInfo16_Value( info16 )),
259 debugstr_a(VersionInfo16_Value( info16 )) );
260 }
261 else
262 {
263 info16->wValueLength = wValueLength;
264 memmove( VersionInfo16_Value( info16 ), lpValue, wValueLength );
265
266 dprintf(("Copied value from %p to %p: %d bytes\n", lpValue,
267 VersionInfo16_Value( info16 ), wValueLength ));
268 }
269
270 /* Convert children */
271 child16 = VersionInfo16_Children( info16 );
272 while ( (DWORD)child32 < (DWORD)info32 + wLength && child32->wLength != 0 )
273 {
274 VS_VERSION_INFO_STRUCT32 *nextChild = VersionInfo32_Next( child32 );
275
276 ConvertVersionInfo32To16( child32, child16 );
277
278 child16 = VersionInfo16_Next( child16 );
279 child32 = nextChild;
280 }
281
282 /* Fixup length */
283 info16->wLength = (DWORD)child16 - (DWORD)info16;
284
285 dprintf(("Finished, length is %d (%p - %p)\n",
286 info16->wLength, info16, child16 ));
287}
288
289/***********************************************************************
290 * VERSION_GetFileVersionInfo_PE [internal]
291 *
292 * NOTE: returns size of the PE VERSION resource or 0xFFFFFFFF
293 * in the case if file exists, but VERSION_INFO not found.
294 * FIXME: handle is not used.
295 */
296static DWORD VERSION_GetFileVersionInfo_PE( LPCSTR filename, LPDWORD handle,
297 DWORD datasize, LPVOID data )
298{
299 VS_FIXEDFILEINFO *vffi;
300 DWORD len;
301 BYTE *buf;
302 HMODULE hModule;
303 HRSRC hRsrc;
304 HGLOBAL hMem;
305
306 dprintf(("(%s,%p)\n", debugstr_a(filename), handle ));
307
308 hModule = GetModuleHandleA(filename);
309 if(!hModule)
310 hModule = LoadLibraryExA(filename, 0, LOAD_LIBRARY_AS_DATAFILE);
311 else
312 hModule = LoadLibraryExA(filename, 0, 0);
313 if(!hModule)
314 {
315 WARN("Could not load %s\n", debugstr_a(filename));
316 return 0;
317 }
318 hRsrc = FindResourceW(hModule,
319 MAKEINTRESOURCEW(VS_VERSION_INFO),
320 MAKEINTRESOURCEW(VS_FILE_INFO));
321 if(!hRsrc)
322 {
323 WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename));
324 FreeLibrary(hModule);
325 return 0xFFFFFFFF;
326 }
327 len = SizeofResource(hModule, hRsrc);
328 hMem = LoadResource(hModule, hRsrc);
329 if(!hMem)
330 {
331 WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename));
332 FreeLibrary(hModule);
333 return 0xFFFFFFFF;
334 }
335 buf = LockResource(hMem);
336
337 vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)buf );
338
339 if ( vffi->dwSignature != VS_FFI_SIGNATURE )
340 {
341 WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
342 vffi->dwSignature, VS_FFI_SIGNATURE );
343 len = 0xFFFFFFFF;
344 goto END;
345 }
346#ifdef DEBUG
347 if ( TRACE_ON(ver) )
348 print_vffi_debug( vffi );
349#endif
350 if(data)
351 {
352 if(datasize < len)
353 len = datasize; /* truncate data */
354 if(len)
355 memcpy(data, buf, len);
356 else
357 len = 0xFFFFFFFF;
358 }
359END:
360 FreeResource(hMem);
361 FreeLibrary(hModule);
362
363 return len;
364}
365
366#ifndef __WIN32OS2__
367/***********************************************************************
368 * VERSION_GetFileVersionInfo_16 [internal]
369 *
370 * NOTE: returns size of the 16-bit VERSION resource or 0xFFFFFFFF
371 * in the case if file exists, but VERSION_INFO not found.
372 * FIXME: handle is not used.
373 */
374static DWORD VERSION_GetFileVersionInfo_16( LPCSTR filename, LPDWORD handle,
375 DWORD datasize, LPVOID data )
376{
377 VS_FIXEDFILEINFO *vffi;
378 DWORD len;
379 BYTE *buf;
380 HMODULE16 hModule;
381 HRSRC16 hRsrc;
382 HGLOBAL16 hMem;
383
384 TRACE("(%s,%p)\n", debugstr_a(filename), handle );
385
386 hModule = LoadLibrary16(filename);
387 if(hModule < 32)
388 {
389 WARN("Could not load %s\n", debugstr_a(filename));
390 return 0;
391 }
392 hRsrc = FindResource16(hModule,
393 MAKEINTRESOURCEA(VS_VERSION_INFO),
394 MAKEINTRESOURCEA(VS_FILE_INFO));
395 if(!hRsrc)
396 {
397 WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename));
398 FreeLibrary16(hModule);
399 return 0xFFFFFFFF;
400 }
401 len = SizeofResource16(hModule, hRsrc);
402 hMem = LoadResource16(hModule, hRsrc);
403 if(!hMem)
404 {
405 WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename));
406 FreeLibrary16(hModule);
407 return 0xFFFFFFFF;
408 }
409 buf = LockResource16(hMem);
410
411 if(!VersionInfoIs16(buf))
412 goto END;
413
414 vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf );
415
416 if ( vffi->dwSignature != VS_FFI_SIGNATURE )
417 {
418 WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
419 vffi->dwSignature, VS_FFI_SIGNATURE );
420 len = 0xFFFFFFFF;
421 goto END;
422 }
423
424 if ( TRACE_ON(ver) )
425 print_vffi_debug( vffi );
426
427 if(data)
428 {
429 if(datasize < len)
430 len = datasize; /* truncate data */
431 if(len)
432 memcpy(data, buf, len);
433 else
434 len = 0xFFFFFFFF;
435 }
436END:
437 FreeResource16(hMem);
438 FreeLibrary16(hModule);
439
440 return len;
441}
442#endif
443
444/***********************************************************************
445 * GetFileVersionInfoSizeA [VERSION.@]
446 */
447DWORD WINAPI GetFileVersionInfoSizeA( LPCSTR filename, LPDWORD handle )
448{
449 VS_FIXEDFILEINFO *vffi;
450 DWORD len, ret, offset;
451 BYTE buf[144];
452
453 dprintf(("(%s,%p)\n", debugstr_a(filename), handle ));
454
455 len = VERSION_GetFileVersionInfo_PE(filename, handle, 0, NULL);
456 /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
457 if(len == 0xFFFFFFFF)
458 {
459 SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
460 return 0;
461 }
462 if(len) return len;
463#ifndef __WIN32OS2__
464 len = VERSION_GetFileVersionInfo_16(filename, handle, 0, NULL);
465 /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
466 if(len == 0xFFFFFFFF)
467 {
468 SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
469 return 0;
470 }
471 if(len) return len;
472#endif
473 len = GetFileResourceSize16( filename,
474 MAKEINTRESOURCEA(VS_FILE_INFO),
475 MAKEINTRESOURCEA(VS_VERSION_INFO),
476 &offset );
477 if (!len) return 0;
478
479 ret = GetFileResource16( filename,
480 MAKEINTRESOURCEA(VS_FILE_INFO),
481 MAKEINTRESOURCEA(VS_VERSION_INFO),
482 offset, sizeof( buf ), buf );
483 if (!ret) return 0;
484
485 if ( handle ) *handle = offset;
486
487 if ( VersionInfoIs16( buf ) )
488 vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf );
489 else
490 vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)buf );
491
492 if ( vffi->dwSignature != VS_FFI_SIGNATURE )
493 {
494 dprintf(("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n",
495 vffi->dwSignature, VS_FFI_SIGNATURE ));
496 return 0;
497 }
498
499 if ( ((VS_VERSION_INFO_STRUCT16 *)buf)->wLength < len )
500 len = ((VS_VERSION_INFO_STRUCT16 *)buf)->wLength;
501
502#ifdef DEBUG
503 if ( TRACE_ON(ver) )
504 print_vffi_debug( vffi );
505#endif
506
507 return len;
508}
509
510/***********************************************************************
511 * GetFileVersionInfoSizeW [VERSION.@]
512 */
513DWORD WINAPI GetFileVersionInfoSizeW( LPCWSTR filename, LPDWORD handle )
514{
515 DWORD ret, len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
516 LPSTR fn = HeapAlloc( GetProcessHeap(), 0, len );
517 WideCharToMultiByte( CP_ACP, 0, filename, -1, fn, len, NULL, NULL );
518 ret = GetFileVersionInfoSizeA( fn, handle );
519 HeapFree( GetProcessHeap(), 0, fn );
520 return ret;
521}
522
523/***********************************************************************
524 * GetFileVersionInfoA [VERSION.@]
525 */
526BOOL WINAPI GetFileVersionInfoA( LPCSTR filename, DWORD handle,
527 DWORD datasize, LPVOID data )
528{
529 DWORD len;
530
531 dprintf(("(%s,%ld,size=%ld,data=%p)\n",
532 debugstr_a(filename), handle, datasize, data ));
533
534 len = VERSION_GetFileVersionInfo_PE(filename, &handle, datasize, data);
535 /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
536 if(len == 0xFFFFFFFF) return FALSE;
537 if(len)
538 goto DO_CONVERT;
539#ifndef __WIN32OS2__
540 len = VERSION_GetFileVersionInfo_16(filename, &handle, datasize, data);
541 /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
542 if(len == 0xFFFFFFFF) return FALSE;
543 if(len)
544 goto DO_CONVERT;
545#endif
546
547 if ( !GetFileResource16( filename, MAKEINTRESOURCEA(VS_FILE_INFO),
548 MAKEINTRESOURCEA(VS_VERSION_INFO),
549 handle, datasize, data ) )
550 return FALSE;
551DO_CONVERT:
552 if ( datasize >= sizeof(VS_VERSION_INFO_STRUCT16)
553 && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength
554 && !VersionInfoIs16( data ) )
555 {
556 /* convert resource from PE format to NE format */
557 ConvertVersionInfo32To16( (VS_VERSION_INFO_STRUCT32 *)data,
558 (VS_VERSION_INFO_STRUCT16 *)data );
559 }
560
561 return TRUE;
562}
563
564/***********************************************************************
565 * GetFileVersionInfoW [VERSION.@]
566 */
567BOOL WINAPI GetFileVersionInfoW( LPCWSTR filename, DWORD handle,
568 DWORD datasize, LPVOID data )
569{
570 DWORD len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
571 LPSTR fn = HeapAlloc( GetProcessHeap(), 0, len );
572 DWORD retv = TRUE;
573
574 WideCharToMultiByte( CP_ACP, 0, filename, -1, fn, len, NULL, NULL );
575
576 dprintf(("(%s,%ld,size=%ld,data=%p)\n",
577 debugstr_w(filename), handle, datasize, data ));
578
579 if(VERSION_GetFileVersionInfo_PE(fn, &handle, datasize, data))
580 goto END;
581#ifndef __WIN32OS2__
582 if(VERSION_GetFileVersionInfo_16(fn, &handle, datasize, data))
583 goto END;
584#endif
585 if ( !GetFileResource16( fn, MAKEINTRESOURCEA(VS_FILE_INFO),
586 MAKEINTRESOURCEA(VS_VERSION_INFO),
587 handle, datasize, data ) )
588 retv = FALSE;
589
590 else if ( datasize >= sizeof(VS_VERSION_INFO_STRUCT16)
591 && datasize >= ((VS_VERSION_INFO_STRUCT16 *)data)->wLength
592 && VersionInfoIs16( data ) )
593 {
594 dprintf(("Cannot access NE resource in %s\n", debugstr_a(fn) ));
595 retv = FALSE;
596 }
597END:
598 HeapFree( GetProcessHeap(), 0, fn );
599 return retv;
600}
601
602
603/***********************************************************************
604 * VersionInfo16_FindChild [internal]
605 */
606static VS_VERSION_INFO_STRUCT16 *VersionInfo16_FindChild( VS_VERSION_INFO_STRUCT16 *info,
607 LPCSTR szKey, UINT cbKey )
608{
609 VS_VERSION_INFO_STRUCT16 *child = VersionInfo16_Children( info );
610
611 while ( (DWORD)child < (DWORD)info + info->wLength )
612 {
613 if ( !strncasecmp( child->szKey, szKey, cbKey ) )
614 return child;
615
616 if (!(child->wLength)) return NULL;
617 child = VersionInfo16_Next( child );
618 }
619
620 return NULL;
621}
622
623/***********************************************************************
624 * VersionInfo32_FindChild [internal]
625 */
626static VS_VERSION_INFO_STRUCT32 *VersionInfo32_FindChild( VS_VERSION_INFO_STRUCT32 *info,
627 LPCWSTR szKey, UINT cbKey )
628{
629 VS_VERSION_INFO_STRUCT32 *child = VersionInfo32_Children( info );
630
631 while ( (DWORD)child < (DWORD)info + info->wLength )
632 {
633 if ( !strncmpiW( child->szKey, szKey, cbKey ) )
634 return child;
635
636 child = VersionInfo32_Next( child );
637 }
638
639 return NULL;
640}
641
642/***********************************************************************
643 * VerQueryValueA [VERSION.@]
644 */
645DWORD WINAPI VerQueryValueA( LPVOID pBlock, LPCSTR lpSubBlock,
646 LPVOID *lplpBuffer, UINT *puLen )
647{
648 VS_VERSION_INFO_STRUCT16 *info = (VS_VERSION_INFO_STRUCT16 *)pBlock;
649 if ( !VersionInfoIs16( info ) )
650 {
651 INT len;
652 LPWSTR wide_str;
653 DWORD give;
654
655 /* <lawson_whitney@juno.com> Feb 2001 */
656 /* AOL 5.0 does this, expecting to get this: */
657 len = MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, NULL, 0);
658 wide_str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
659 MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, wide_str, len);
660
661 give = VerQueryValueW(pBlock, wide_str, lplpBuffer, puLen);
662 HeapFree(GetProcessHeap(), 0, wide_str);
663 return give;
664 }
665
666 dprintf(("(%p,%s,%p,%p)\n",
667 pBlock, debugstr_a(lpSubBlock), lplpBuffer, puLen ));
668
669 while ( *lpSubBlock )
670 {
671 /* Find next path component */
672 LPCSTR lpNextSlash;
673 for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
674 if ( *lpNextSlash == '\\' )
675 break;
676
677 /* Skip empty components */
678 if ( lpNextSlash == lpSubBlock )
679 {
680 lpSubBlock++;
681 continue;
682 }
683
684 /* We have a non-empty component: search info for key */
685 info = VersionInfo16_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
686 if ( !info ) return FALSE;
687
688 /* Skip path component */
689 lpSubBlock = lpNextSlash;
690 }
691
692 /* Return value */
693 *lplpBuffer = VersionInfo16_Value( info );
694 *puLen = info->wValueLength;
695
696 return TRUE;
697}
698
699/***********************************************************************
700 * VerQueryValueW [VERSION.@]
701 */
702DWORD WINAPI VerQueryValueW( LPVOID pBlock, LPCWSTR lpSubBlock,
703 LPVOID *lplpBuffer, UINT *puLen )
704{
705 VS_VERSION_INFO_STRUCT32 *info = (VS_VERSION_INFO_STRUCT32 *)pBlock;
706 if ( VersionInfoIs16( info ) )
707 {
708 dprintf(("called on NE resource!\n" ));
709 return FALSE;
710 }
711
712 dprintf(("(%p,%s,%p,%p)\n",
713 pBlock, debugstr_w(lpSubBlock), lplpBuffer, puLen ));
714
715 while ( *lpSubBlock )
716 {
717 /* Find next path component */
718 LPCWSTR lpNextSlash;
719 for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
720 if ( *lpNextSlash == '\\' )
721 break;
722
723 /* Skip empty components */
724 if ( lpNextSlash == lpSubBlock )
725 {
726 lpSubBlock++;
727 continue;
728 }
729
730 /* We have a non-empty component: search info for key */
731 info = VersionInfo32_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
732 if ( !info ) return FALSE;
733
734 /* Skip path component */
735 lpSubBlock = lpNextSlash;
736 }
737
738 /* Return value */
739 *lplpBuffer = VersionInfo32_Value( info );
740 *puLen = info->wValueLength;
741
742 return TRUE;
743}
Note: See TracBrowser for help on using the repository browser.