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

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

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