projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
- Revert 44301
[reactos.git] / dll / win32 / version / info.c
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 * Copyright 2005 Paul Vriens
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 *
23 */
24
25 #include <stdarg.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winver.h"
32 #include "winternl.h"
33 #include "winuser.h"
34 #include "wine/winuser16.h"
35 #include "wine/unicode.h"
36 #include "winerror.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(ver);
40
41 /******************************************************************************
42 *
43 * This function will print via standard TRACE, debug info regarding
44 * the file info structure vffi.
45 * 15-Feb-1998 Dimitrie Paun (dimi@cs.toronto.edu)
46 * Added this function to clean up the code.
47 *
48 *****************************************************************************/
49 static void print_vffi_debug(const VS_FIXEDFILEINFO *vffi)
50 {
51 BOOL versioned_printer = FALSE;
52
53 if((vffi->dwFileType == VFT_DLL) || (vffi->dwFileType == VFT_DRV))
54 {
55 if(vffi->dwFileSubtype == VFT2_DRV_VERSIONED_PRINTER)
56 /* this is documented for newer w2k Drivers and up */
57 versioned_printer = TRUE;
58 else if( (vffi->dwFileSubtype == VFT2_DRV_PRINTER) &&
59 (vffi->dwFileVersionMS != vffi->dwProductVersionMS) &&
60 (vffi->dwFileVersionMS > 0) &&
61 (vffi->dwFileVersionMS <= 3) )
62 /* found this on NT 3.51, NT4.0 and old w2k Drivers */
63 versioned_printer = TRUE;
64 }
65
66 TRACE("structversion=%u.%u, ",
67 HIWORD(vffi->dwStrucVersion),LOWORD(vffi->dwStrucVersion));
68 if(versioned_printer)
69 {
70 WORD mode = LOWORD(vffi->dwFileVersionMS);
71 WORD ver_rev = HIWORD(vffi->dwFileVersionLS);
72 TRACE("fileversion=%u.%u.%u.%u (%s.major.minor.release), ",
73 (vffi->dwFileVersionMS),
74 HIBYTE(ver_rev), LOBYTE(ver_rev), LOWORD(vffi->dwFileVersionLS),
75 (mode == 3) ? "Usermode" : ((mode <= 2) ? "Kernelmode" : "?") );
76 }
77 else
78 {
79 TRACE("fileversion=%u.%u.%u.%u, ",
80 HIWORD(vffi->dwFileVersionMS),LOWORD(vffi->dwFileVersionMS),
81 HIWORD(vffi->dwFileVersionLS),LOWORD(vffi->dwFileVersionLS));
82 }
83 TRACE("productversion=%u.%u.%u.%u\n",
84 HIWORD(vffi->dwProductVersionMS),LOWORD(vffi->dwProductVersionMS),
85 HIWORD(vffi->dwProductVersionLS),LOWORD(vffi->dwProductVersionLS));
86
87 TRACE("flagmask=0x%x, flags=0x%x %s%s%s%s%s%s\n",
88 vffi->dwFileFlagsMask, vffi->dwFileFlags,
89 (vffi->dwFileFlags & VS_FF_DEBUG) ? "DEBUG," : "",
90 (vffi->dwFileFlags & VS_FF_PRERELEASE) ? "PRERELEASE," : "",
91 (vffi->dwFileFlags & VS_FF_PATCHED) ? "PATCHED," : "",
92 (vffi->dwFileFlags & VS_FF_PRIVATEBUILD) ? "PRIVATEBUILD," : "",
93 (vffi->dwFileFlags & VS_FF_INFOINFERRED) ? "INFOINFERRED," : "",
94 (vffi->dwFileFlags & VS_FF_SPECIALBUILD) ? "SPECIALBUILD," : "");
95
96 TRACE("(");
97
98 TRACE("OS=0x%x.0x%x ", HIWORD(vffi->dwFileOS), LOWORD(vffi->dwFileOS));
99
100 switch (vffi->dwFileOS&0xFFFF0000)
101 {
102 case VOS_DOS:TRACE("DOS,");break;
103 case VOS_OS216:TRACE("OS/2-16,");break;
104 case VOS_OS232:TRACE("OS/2-32,");break;
105 case VOS_NT:TRACE("NT,");break;
106 case VOS_UNKNOWN:
107 default:
108 TRACE("UNKNOWN(0x%x),",vffi->dwFileOS&0xFFFF0000);break;
109 }
110
111 switch (LOWORD(vffi->dwFileOS))
112 {
113 case VOS__BASE:TRACE("BASE");break;
114 case VOS__WINDOWS16:TRACE("WIN16");break;
115 case VOS__WINDOWS32:TRACE("WIN32");break;
116 case VOS__PM16:TRACE("PM16");break;
117 case VOS__PM32:TRACE("PM32");break;
118 default:
119 TRACE("UNKNOWN(0x%x)",LOWORD(vffi->dwFileOS));break;
120 }
121
122 TRACE(")\n");
123
124 switch (vffi->dwFileType)
125 {
126 case VFT_APP:TRACE("filetype=APP");break;
127 case VFT_DLL:
128 TRACE("filetype=DLL");
129 if(vffi->dwFileSubtype != 0)
130 {
131 if(versioned_printer) /* NT3.x/NT4.0 or old w2k Driver */
132 TRACE(",PRINTER");
133 TRACE(" (subtype=0x%x)", vffi->dwFileSubtype);
134 }
135 break;
136 case VFT_DRV:
137 TRACE("filetype=DRV,");
138 switch(vffi->dwFileSubtype)
139 {
140 case VFT2_DRV_PRINTER:TRACE("PRINTER");break;
141 case VFT2_DRV_KEYBOARD:TRACE("KEYBOARD");break;
142 case VFT2_DRV_LANGUAGE:TRACE("LANGUAGE");break;
143 case VFT2_DRV_DISPLAY:TRACE("DISPLAY");break;
144 case VFT2_DRV_MOUSE:TRACE("MOUSE");break;
145 case VFT2_DRV_NETWORK:TRACE("NETWORK");break;
146 case VFT2_DRV_SYSTEM:TRACE("SYSTEM");break;
147 case VFT2_DRV_INSTALLABLE:TRACE("INSTALLABLE");break;
148 case VFT2_DRV_SOUND:TRACE("SOUND");break;
149 case VFT2_DRV_COMM:TRACE("COMM");break;
150 case VFT2_DRV_INPUTMETHOD:TRACE("INPUTMETHOD");break;
151 case VFT2_DRV_VERSIONED_PRINTER:TRACE("VERSIONED_PRINTER");break;
152 case VFT2_UNKNOWN:
153 default:
154 TRACE("UNKNOWN(0x%x)",vffi->dwFileSubtype);break;
155 }
156 break;
157 case VFT_FONT:
158 TRACE("filetype=FONT,");
159 switch (vffi->dwFileSubtype)
160 {
161 case VFT2_FONT_RASTER:TRACE("RASTER");break;
162 case VFT2_FONT_VECTOR:TRACE("VECTOR");break;
163 case VFT2_FONT_TRUETYPE:TRACE("TRUETYPE");break;
164 default:TRACE("UNKNOWN(0x%x)",vffi->dwFileSubtype);break;
165 }
166 break;
167 case VFT_VXD:TRACE("filetype=VXD");break;
168 case VFT_STATIC_LIB:TRACE("filetype=STATIC_LIB");break;
169 case VFT_UNKNOWN:
170 default:
171 TRACE("filetype=Unknown(0x%x)",vffi->dwFileType);break;
172 }
173
174 TRACE("\n");
175 TRACE("filedate=0x%x.0x%x\n",vffi->dwFileDateMS,vffi->dwFileDateLS);
176 }
177
178 /***********************************************************************
179 * Version Info Structure
180 */
181
182 typedef struct
183 {
184 WORD wLength;
185 WORD wValueLength;
186 CHAR szKey[1];
187 #if 0 /* variable length structure */
188 /* DWORD aligned */
189 BYTE Value[];
190 /* DWORD aligned */
191 VS_VERSION_INFO_STRUCT16 Children[];
192 #endif
193 } VS_VERSION_INFO_STRUCT16;
194
195 typedef struct
196 {
197 WORD wLength;
198 WORD wValueLength;
199 WORD wType;
200 WCHAR szKey[1];
201 #if 0 /* variable length structure */
202 /* DWORD aligned */
203 BYTE Value[];
204 /* DWORD aligned */
205 VS_VERSION_INFO_STRUCT32 Children[];
206 #endif
207 } VS_VERSION_INFO_STRUCT32;
208
209 #define VersionInfoIs16( ver ) \
210 ( ((const VS_VERSION_INFO_STRUCT16 *)ver)->szKey[0] >= ' ' )
211
212 #define DWORD_ALIGN( base, ptr ) \
213 ( (LPBYTE)(base) + ((((LPBYTE)(ptr) - (LPBYTE)(base)) + 3) & ~3) )
214
215 #define VersionInfo16_Value( ver ) \
216 DWORD_ALIGN( (ver), (ver)->szKey + strlen((ver)->szKey) + 1 )
217 #define VersionInfo32_Value( ver ) \
218 DWORD_ALIGN( (ver), (ver)->szKey + strlenW((ver)->szKey) + 1 )
219
220 #define VersionInfo16_Children( ver ) \
221 (const VS_VERSION_INFO_STRUCT16 *)( VersionInfo16_Value( ver ) + \
222 ( ( (ver)->wValueLength + 3 ) & ~3 ) )
223 #define VersionInfo32_Children( ver ) \
224 (const VS_VERSION_INFO_STRUCT32 *)( VersionInfo32_Value( ver ) + \
225 ( ( (ver)->wValueLength * \
226 ((ver)->wType? 2 : 1) + 3 ) & ~3 ) )
227
228 #define VersionInfo16_Next( ver ) \
229 (VS_VERSION_INFO_STRUCT16 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) )
230 #define VersionInfo32_Next( ver ) \
231 (VS_VERSION_INFO_STRUCT32 *)( (LPBYTE)ver + (((ver)->wLength + 3) & ~3) )
232
233 /***********************************************************************
234 * VERSION_GetFileVersionInfo_PE [internal]
235 *
236 * NOTE: returns size of the PE VERSION resource or 0xFFFFFFFF
237 * in the case the file is a PE module, but VERSION_INFO not found.
238 */
239 static DWORD VERSION_GetFileVersionInfo_PE( LPCWSTR filename, DWORD datasize, LPVOID data )
240 {
241 const VS_FIXEDFILEINFO *vffi;
242 DWORD len;
243 BYTE *buf;
244 HMODULE hModule;
245 HRSRC hRsrc;
246 HGLOBAL hMem;
247
248 TRACE("%s\n", debugstr_w(filename));
249
250 if (!GetModuleHandleExW(0, filename, &hModule))
251 hModule = LoadLibraryExW(filename, 0, LOAD_LIBRARY_AS_DATAFILE);
252
253 if(!hModule)
254 {
255 WARN("Could not load %s\n", debugstr_w(filename));
256
257 return 0;
258 }
259 hRsrc = FindResourceW(hModule,
260 MAKEINTRESOURCEW(VS_VERSION_INFO),
261 MAKEINTRESOURCEW(VS_FILE_INFO));
262 if(!hRsrc)
263 {
264 WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_w(filename));
265 FreeLibrary(hModule);
266 return 0xFFFFFFFF;
267 }
268 len = SizeofResource(hModule, hRsrc);
269 hMem = LoadResource(hModule, hRsrc);
270 if(!hMem)
271 {
272 WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_w(filename));
273 FreeLibrary(hModule);
274 return 0xFFFFFFFF;
275 }
276 buf = LockResource(hMem);
277
278 vffi = (VS_FIXEDFILEINFO *)VersionInfo32_Value( (VS_VERSION_INFO_STRUCT32 *)buf );
279
280 if ( vffi->dwSignature != VS_FFI_SIGNATURE )
281 {
282 WARN("vffi->dwSignature is 0x%08x, but not 0x%08lx!\n",
283 vffi->dwSignature, VS_FFI_SIGNATURE );
284 len = 0xFFFFFFFF;
285 goto END;
286 }
287
288 if ( TRACE_ON(ver) )
289 print_vffi_debug( vffi );
290
291 if(data)
292 {
293 if(datasize < len)
294 len = datasize; /* truncate data */
295 if(len)
296 memcpy(data, buf, len);
297 else
298 len = 0xFFFFFFFF;
299 }
300 END:
301 FreeResource(hMem);
302 FreeLibrary(hModule);
303
304 return len;
305 }
306
307 #ifndef __REACTOS__
308 /***********************************************************************
309 * VERSION_GetFileVersionInfo_16 [internal]
310 *
311 * NOTE: returns size of the 16-bit VERSION resource or 0xFFFFFFFF
312 * in the case the file exists, but VERSION_INFO not found.
313 */
314 static DWORD VERSION_GetFileVersionInfo_16( LPCSTR filename, DWORD datasize, LPVOID data )
315 {
316 const VS_FIXEDFILEINFO *vffi;
317 DWORD len, offset;
318 BYTE *buf;
319 HMODULE16 hModule;
320 HRSRC16 hRsrc;
321 HGLOBAL16 hMem;
322 char dllname[20], owner[20], *p;
323 const char *basename;
324 BOOL is_builtin = FALSE;
325
326 TRACE("%s\n", debugstr_a(filename));
327
328 /* strip path information */
329
330 basename = filename;
331 if (basename[0] && basename[1] == ':') basename += 2; /* strip drive specification */
332 if ((p = strrchr( basename, '\\' ))) basename = p + 1;
333 if ((p = strrchr( basename, '/' ))) basename = p + 1;
334
335 if (strlen(basename) < sizeof(dllname)-4)
336 {
337 int file_exists;
338
339 strcpy( dllname, basename );
340 p = strrchr( dllname, '.' );
341 if (!p) strcat( dllname, ".dll" );
342 for (p = dllname; *p; p++) if (*p >= 'A' && *p <= 'Z') *p += 32;
343
344 if (wine_dll_get_owner( dllname, owner, sizeof(owner), &file_exists ) == 0)
345 is_builtin = TRUE;
346 }
347
348 /* first try without loading a 16-bit module */
349 if (is_builtin)
350 len = 0;
351 else
352 len = GetFileResourceSize16( filename,
353 MAKEINTRESOURCEA(VS_FILE_INFO),
354 MAKEINTRESOURCEA(VS_VERSION_INFO),
355 &offset );
356 if (len)
357 {
358 if (!data) return len;
359
360 len = GetFileResource16( filename,
361 MAKEINTRESOURCEA(VS_FILE_INFO),
362 MAKEINTRESOURCEA(VS_VERSION_INFO),
363 offset, datasize, data );
364 if (len)
365 {
366 vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)data );
367
368 if ( vffi->dwSignature == VS_FFI_SIGNATURE )
369 {
370 if ( ((VS_VERSION_INFO_STRUCT16 *)data)->wLength < len )
371 len = ((VS_VERSION_INFO_STRUCT16 *)data)->wLength;
372
373 if ( TRACE_ON(ver) )
374 print_vffi_debug( vffi );
375
376 return len;
377 }
378 }
379 }
380
381 /* this might be a builtin 16-bit module */
382 hModule = LoadLibrary16(filename);
383 if(hModule < 32)
384 {
385 WARN("Could not load %s\n", debugstr_a(filename));
386 if (hModule == ERROR_BAD_FORMAT)
387 return 0xFFFFFFFF;
388 else
389 return 0x0;
390 }
391 hRsrc = FindResource16(hModule,
392 MAKEINTRESOURCEA(VS_VERSION_INFO),
393 MAKEINTRESOURCEA(VS_FILE_INFO));
394 if(!hRsrc)
395 {
396 WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename));
397 FreeLibrary16(hModule);
398 return 0xFFFFFFFF;
399 }
400 len = SizeofResource16(hModule, hRsrc);
401 hMem = LoadResource16(hModule, hRsrc);
402 if(!hMem)
403 {
404 WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename));
405 FreeLibrary16(hModule);
406 return 0xFFFFFFFF;
407 }
408 buf = LockResource16(hMem);
409
410 if(!VersionInfoIs16(buf))
411 {
412 len = 0xFFFFFFFF;
413 goto END;
414 }
415
416 vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf );
417
418 if ( vffi->dwSignature != VS_FFI_SIGNATURE )
419 {
420 WARN("vffi->dwSignature is 0x%08x, but not 0x%08lx!\n",
421 vffi->dwSignature, VS_FFI_SIGNATURE );
422 len = 0xFFFFFFFF;
423 goto END;
424 }
425
426 if ( TRACE_ON(ver) )
427 print_vffi_debug( vffi );
428
429 if(data)
430 {
431 if(datasize < len)
432 len = datasize; /* truncate data */
433 if(len)
434 memcpy(data, buf, len);
435 else
436 len = 0xFFFFFFFF;
437 }
438 END:
439 FreeResource16(hMem);
440 FreeLibrary16(hModule);
441
442 return len;
443 }
444 #endif /* ! __REACTOS__ */
445
446 /***********************************************************************
447 * GetFileVersionInfoSizeW [VERSION.@]
448 */
449 DWORD WINAPI GetFileVersionInfoSizeW( LPCWSTR filename, LPDWORD handle )
450 {
451 DWORD len;
452
453 TRACE("(%s,%p)\n", debugstr_w(filename), handle );
454
455 if (handle) *handle = 0;
456
457 if (!filename)
458 {
459 SetLastError(ERROR_INVALID_PARAMETER);
460 return 0;
461 }
462 if (!*filename)
463 {
464 SetLastError(ERROR_BAD_PATHNAME);
465 return 0;
466 }
467
468 len = VERSION_GetFileVersionInfo_PE(filename, 0, NULL);
469 /* 0xFFFFFFFF means: file is a PE module, but VERSION_INFO not found */
470 if(len == 0xFFFFFFFF)
471 {
472 SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
473 return 0;
474 }
475
476 if (!len)
477 {
478 #ifdef __REACTOS__
479 SetLastError(ERROR_FILE_NOT_FOUND);
480 return 0;
481 #else /* __REACTOS__ */
482 LPSTR filenameA;
483
484 len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
485 filenameA = HeapAlloc( GetProcessHeap(), 0, len );
486 WideCharToMultiByte( CP_ACP, 0, filename, -1, filenameA, len, NULL, NULL );
487
488 len = VERSION_GetFileVersionInfo_16(filenameA, 0, NULL);
489 HeapFree( GetProcessHeap(), 0, filenameA );
490 /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
491 if (!len)
492 {
493 SetLastError(ERROR_FILE_NOT_FOUND);
494 return 0;
495 }
496 if (len == 0xFFFFFFFF)
497 {
498 SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
499 return 0;
500 }
501
502 /* We have a 16bit resource.
503 *
504 * XP/W2K/W2K3 uses a buffer which is more than the actual needed space:
505 *
506 * (info->wLength - sizeof(VS_FIXEDFILEINFO)) * 4
507 *
508 * This extra buffer is used for ANSI to Unicode conversions in W-Calls.
509 * info->wLength should be the same as len. Currently it isn't but that
510 * doesn't seem to be a problem (len is bigger than info->wLength).
511 */
512 len = (len - sizeof(VS_FIXEDFILEINFO)) * 4;
513 #endif /* ! __REACTOS__ */
514 }
515 else
516 {
517 /* We have a 32bit resource.
518 *
519 * XP/W2K/W2K3 uses a buffer which is 2 times the actual needed space + 4 bytes "FE2X"
520 * This extra buffer is used for Unicode to ANSI conversions in A-Calls
521 */
522 len = (len * 2) + 4;
523 }
524
525 SetLastError(0);
526 return len;
527 }
528
529 /***********************************************************************
530 * GetFileVersionInfoSizeA [VERSION.@]
531 */
532 DWORD WINAPI GetFileVersionInfoSizeA( LPCSTR filename, LPDWORD handle )
533 {
534 UNICODE_STRING filenameW;
535 DWORD retval;
536
537 TRACE("(%s,%p)\n", debugstr_a(filename), handle );
538
539 if(filename)
540 RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
541 else
542 filenameW.Buffer = NULL;
543
544 retval = GetFileVersionInfoSizeW(filenameW.Buffer, handle);
545
546 RtlFreeUnicodeString(&filenameW);
547
548 return retval;
549 }
550
551 /***********************************************************************
552 * GetFileVersionInfoW [VERSION.@]
553 */
554 BOOL WINAPI GetFileVersionInfoW( LPCWSTR filename, DWORD handle,
555 DWORD datasize, LPVOID data )
556 {
557 DWORD len;
558 VS_VERSION_INFO_STRUCT32* vvis = data;
559
560 TRACE("(%s,%d,size=%d,data=%p)\n",
561 debugstr_w(filename), handle, datasize, data );
562
563 if (!data)
564 {
565 SetLastError(ERROR_INVALID_DATA);
566 return FALSE;
567 }
568 len = VERSION_GetFileVersionInfo_PE(filename, datasize, data);
569 /* 0xFFFFFFFF means: file is a PE module, but VERSION_INFO not found */
570 if (len == 0xFFFFFFFF)
571 {
572 SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
573 return FALSE;
574 }
575
576 if (!len)
577 {
578 #ifdef __REACTOS__
579 SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
580 return FALSE;
581 #else /* __REACTOS__ */
582 LPSTR filenameA;
583
584 len = WideCharToMultiByte( CP_ACP, 0, filename, -1, NULL, 0, NULL, NULL );
585 filenameA = HeapAlloc( GetProcessHeap(), 0, len );
586 WideCharToMultiByte( CP_ACP, 0, filename, -1, filenameA, len, NULL, NULL );
587
588 len = VERSION_GetFileVersionInfo_16(filenameA, datasize, data);
589 HeapFree( GetProcessHeap(), 0, filenameA );
590 /* 0xFFFFFFFF means: file exists, but VERSION_INFO not found */
591 if (!len || len == 0xFFFFFFFF)
592 {
593 SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
594 return FALSE;
595 }
596 /* We have a 16bit resource. */
597 #endif /* ! __REACTOS__ */
598 }
599 else
600 {
601 static const char signature[] = "FE2X";
602 DWORD bufsize = vvis->wLength + strlen(signature);
603 DWORD convbuf;
604
605 /* We have a 32bit resource.
606 *
607 * XP/W2K/W2K3 uses a buffer which is 2 times the actual needed space + 4 bytes "FE2X"
608 * This extra buffer is used for Unicode to ANSI conversions in A-Calls
609 */
610
611 /* information is truncated to datasize bytes */
612 if (datasize >= bufsize)
613 {
614 convbuf = datasize - vvis->wLength;
615 memcpy( ((char*)(data))+vvis->wLength, signature, convbuf > 4 ? 4 : convbuf );
616 }
617 }
618
619 SetLastError(0);
620 return TRUE;
621 }
622
623 /***********************************************************************
624 * GetFileVersionInfoA [VERSION.@]
625 */
626 BOOL WINAPI GetFileVersionInfoA( LPCSTR filename, DWORD handle,
627 DWORD datasize, LPVOID data )
628 {
629 UNICODE_STRING filenameW;
630 BOOL retval;
631
632 TRACE("(%s,%d,size=%d,data=%p)\n",
633 debugstr_a(filename), handle, datasize, data );
634
635 if(filename)
636 RtlCreateUnicodeStringFromAsciiz(&filenameW, filename);
637 else
638 filenameW.Buffer = NULL;
639
640 retval = GetFileVersionInfoW(filenameW.Buffer, handle, datasize, data);
641
642 RtlFreeUnicodeString(&filenameW);
643
644 return retval;
645 }
646
647 /***********************************************************************
648 * VersionInfo16_FindChild [internal]
649 */
650 static const VS_VERSION_INFO_STRUCT16 *VersionInfo16_FindChild( const VS_VERSION_INFO_STRUCT16 *info,
651 LPCSTR szKey, UINT cbKey )
652 {
653 const VS_VERSION_INFO_STRUCT16 *child = VersionInfo16_Children( info );
654
655 while ((char *)child < (char *)info + info->wLength )
656 {
657 if (!strncasecmp( child->szKey, szKey, cbKey ) && !child->szKey[cbKey])
658 return child;
659
660 if (!(child->wLength)) return NULL;
661 child = VersionInfo16_Next( child );
662 }
663
664 return NULL;
665 }
666
667 /***********************************************************************
668 * VersionInfo32_FindChild [internal]
669 */
670 static const VS_VERSION_INFO_STRUCT32 *VersionInfo32_FindChild( const VS_VERSION_INFO_STRUCT32 *info,
671 LPCWSTR szKey, UINT cbKey )
672 {
673 const VS_VERSION_INFO_STRUCT32 *child = VersionInfo32_Children( info );
674
675 while ((char *)child < (char *)info + info->wLength )
676 {
677 if (!strncmpiW( child->szKey, szKey, cbKey ) && !child->szKey[cbKey])
678 return child;
679
680 if (!(child->wLength)) return NULL;
681 child = VersionInfo32_Next( child );
682 }
683
684 return NULL;
685 }
686
687 /***********************************************************************
688 * VersionInfo16_QueryValue [internal]
689 *
690 * Gets a value from a 16-bit NE resource
691 */
692 static BOOL VersionInfo16_QueryValue( const VS_VERSION_INFO_STRUCT16 *info, LPCSTR lpSubBlock,
693 LPVOID *lplpBuffer, UINT *puLen )
694 {
695 while ( *lpSubBlock )
696 {
697 /* Find next path component */
698 LPCSTR lpNextSlash;
699 for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
700 if ( *lpNextSlash == '\\' )
701 break;
702
703 /* Skip empty components */
704 if ( lpNextSlash == lpSubBlock )
705 {
706 lpSubBlock++;
707 continue;
708 }
709
710 /* We have a non-empty component: search info for key */
711 info = VersionInfo16_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
712 if ( !info )
713 {
714 if (puLen) *puLen = 0 ;
715 SetLastError( ERROR_RESOURCE_TYPE_NOT_FOUND );
716 return FALSE;
717 }
718
719 /* Skip path component */
720 lpSubBlock = lpNextSlash;
721 }
722
723 /* Return value */
724 *lplpBuffer = VersionInfo16_Value( info );
725 if (puLen)
726 *puLen = info->wValueLength;
727
728 return TRUE;
729 }
730
731 /***********************************************************************
732 * VersionInfo32_QueryValue [internal]
733 *
734 * Gets a value from a 32-bit PE resource
735 */
736 static BOOL VersionInfo32_QueryValue( const VS_VERSION_INFO_STRUCT32 *info, LPCWSTR lpSubBlock,
737 LPVOID *lplpBuffer, UINT *puLen )
738 {
739 TRACE("lpSubBlock : (%s)\n", debugstr_w(lpSubBlock));
740
741 while ( *lpSubBlock )
742 {
743 /* Find next path component */
744 LPCWSTR lpNextSlash;
745 for ( lpNextSlash = lpSubBlock; *lpNextSlash; lpNextSlash++ )
746 if ( *lpNextSlash == '\\' )
747 break;
748
749 /* Skip empty components */
750 if ( lpNextSlash == lpSubBlock )
751 {
752 lpSubBlock++;
753 continue;
754 }
755
756 /* We have a non-empty component: search info for key */
757 info = VersionInfo32_FindChild( info, lpSubBlock, lpNextSlash-lpSubBlock );
758 if ( !info )
759 {
760 if (puLen) *puLen = 0 ;
761 SetLastError( ERROR_RESOURCE_TYPE_NOT_FOUND );
762 return FALSE;
763 }
764
765 /* Skip path component */
766 lpSubBlock = lpNextSlash;
767 }
768
769 /* Return value */
770 *lplpBuffer = VersionInfo32_Value( info );
771 if (puLen)
772 *puLen = info->wValueLength;
773
774 return TRUE;
775 }
776
777 /***********************************************************************
778 * VerQueryValueA [VERSION.@]
779 */
780 BOOL WINAPI VerQueryValueA( LPCVOID pBlock, LPCSTR lpSubBlock,
781 LPVOID *lplpBuffer, PUINT puLen )
782 {
783 static const char rootA[] = "\\";
784 static const char varfileinfoA[] = "\\VarFileInfo\\Translation";
785 const VS_VERSION_INFO_STRUCT16 *info = pBlock;
786
787 TRACE("(%p,%s,%p,%p)\n",
788 pBlock, debugstr_a(lpSubBlock), lplpBuffer, puLen );
789
790 if (!pBlock)
791 return FALSE;
792
793 if (lpSubBlock == NULL || lpSubBlock[0] == '\0')
794 lpSubBlock = rootA;
795
796 if ( !VersionInfoIs16( info ) )
797 {
798 BOOL ret;
799 INT len;
800 LPWSTR lpSubBlockW;
801
802 len = MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, NULL, 0);
803 lpSubBlockW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
804
805 if (!lpSubBlockW)
806 return FALSE;
807
808 MultiByteToWideChar(CP_ACP, 0, lpSubBlock, -1, lpSubBlockW, len);
809
810 ret = VersionInfo32_QueryValue(pBlock, lpSubBlockW, lplpBuffer, puLen);
811
812 HeapFree(GetProcessHeap(), 0, lpSubBlockW);
813
814 if (ret && strcasecmp( lpSubBlock, rootA ) && strcasecmp( lpSubBlock, varfileinfoA ))
815 {
816 /* Set lpBuffer so it points to the 'empty' area where we store
817 * the converted strings
818 */
819 LPSTR lpBufferA = (LPSTR)pBlock + info->wLength + 4;
820 DWORD pos = (LPCSTR)*lplpBuffer - (LPCSTR)pBlock;
821
822 len = WideCharToMultiByte(CP_ACP, 0, *lplpBuffer, -1,
823 lpBufferA + pos, info->wLength - pos, NULL, NULL);
824 *lplpBuffer = lpBufferA + pos;
825 *puLen = len;
826 }
827 return ret;
828 }
829
830 return VersionInfo16_QueryValue(info, lpSubBlock, lplpBuffer, puLen);
831 }
832
833 /***********************************************************************
834 * VerQueryValueW [VERSION.@]
835 */
836 BOOL WINAPI VerQueryValueW( LPCVOID pBlock, LPCWSTR lpSubBlock,
837 LPVOID *lplpBuffer, PUINT puLen )
838 {
839 static const WCHAR nullW[] = { 0 };
840 static const WCHAR rootW[] = { '\\', 0 };
841 static const WCHAR varfileinfoW[] = { '\\','V','a','r','F','i','l','e','I','n','f','o',
842 '\\','T','r','a','n','s','l','a','t','i','o','n', 0 };
843
844 const VS_VERSION_INFO_STRUCT32 *info = pBlock;
845
846 TRACE("(%p,%s,%p,%p)\n",
847 pBlock, debugstr_w(lpSubBlock), lplpBuffer, puLen );
848
849 if (!pBlock)
850 return FALSE;
851
852 if (lpSubBlock == NULL || lpSubBlock[0] == nullW[0])
853 lpSubBlock = rootW;
854
855 if ( VersionInfoIs16( info ) )
856 {
857 BOOL ret;
858 int len;
859 LPSTR lpSubBlockA;
860
861 len = WideCharToMultiByte(CP_ACP, 0, lpSubBlock, -1, NULL, 0, NULL, NULL);
862 lpSubBlockA = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
863
864 if (!lpSubBlockA)
865 return FALSE;
866
867 WideCharToMultiByte(CP_ACP, 0, lpSubBlock, -1, lpSubBlockA, len, NULL, NULL);
868
869 ret = VersionInfo16_QueryValue(pBlock, lpSubBlockA, lplpBuffer, puLen);
870
871 HeapFree(GetProcessHeap(), 0, lpSubBlockA);
872
873 if (ret && strcmpiW( lpSubBlock, rootW ) && strcmpiW( lpSubBlock, varfileinfoW ))
874 {
875 /* Set lpBuffer so it points to the 'empty' area where we store
876 * the converted strings
877 */
878 LPWSTR lpBufferW = (LPWSTR)((LPSTR)pBlock + info->wLength);
879 DWORD pos = (LPCSTR)*lplpBuffer - (LPCSTR)pBlock;
880 DWORD max = (info->wLength - sizeof(VS_FIXEDFILEINFO)) * 4 - info->wLength;
881
882 len = MultiByteToWideChar(CP_ACP, 0, *lplpBuffer, -1,
883 lpBufferW + pos, max/sizeof(WCHAR) - pos );
884 *lplpBuffer = lpBufferW + pos;
885 *puLen = len;
886 }
887 return ret;
888 }
889
890 return VersionInfo32_QueryValue(info, lpSubBlock, lplpBuffer, puLen);
891 }
A free Windows-compatible Operating System