| blob | 11590c73e0a9d7f504a9cca45ccd2dffc38fde10 |
1 /*
2 * versioninfo.c: Version information support
3 *
4 * Author:
5 * Dick Porter (dick@ximian.com)
6 *
7 * (C) 2007 Novell, Inc.
8 */
10 #include <config.h>
11 #include <glib.h>
12 #include <string.h>
13 #include <pthread.h>
14 #include <sys/types.h>
15 #include <sys/stat.h>
16 #include <unistd.h>
17 #include <fcntl.h>
18 #include <errno.h>
20 #include <mono/io-layer/wapi.h>
21 #include <mono/io-layer/wapi-private.h>
22 #include <mono/io-layer/versioninfo.h>
23 #include <mono/io-layer/io-portability.h>
24 #include <mono/io-layer/error.h>
25 #include <mono/utils/strenc.h>
26 #include <mono/utils/mono-mmap.h>
28 #define LOGDEBUG(...)
29 //define LOGDEBUG(...) g_message(__VA_ARGS__)
31 #define ALIGN32(ptr) ptr = (gpointer)((char *)ptr + 3); ptr = (gpointer)((char *)ptr - ((gsize)ptr & 3));
35 {
37 guint32 i;
43 }
48 }
49 }
52 }
54 /* This works for both 32bit and 64bit files, as the differences are
55 * all after the section header block
56 */
57 static gpointer
59 {
61 guint32 delta;
66 }
72 }
74 static gpointer
77 gpointer file_map,
81 {
82 WapiImageResourceDirectoryEntry swapped_entry;
96 /* Normally holds a directory entry for each type of
97 * resource
98 */
103 }
105 /* Normally holds a directory entry for each resource
106 * item
107 */
109 /* Normally holds a directory entry for each language
110 */
116 }
119 }
122 WapiImageResourceDirectory *res_dir = (WapiImageResourceDirectory *)((guint8 *)root + dir_offset);
123 WapiImageResourceDirectoryEntry *sub_entries = (WapiImageResourceDirectoryEntry *)(res_dir + 1);
126 entries = GUINT16_FROM_LE (res_dir->NumberOfNamedEntries) + GUINT16_FROM_LE (res_dir->NumberOfIdEntries);
130 gpointer ret;
137 }
138 }
142 WapiImageResourceDataEntry *data_entry = (WapiImageResourceDataEntry *)((guint8 *)root + data_offset);
146 }
147 }
149 static gpointer
153 {
167 }
174 }
176 nt_headers = (WapiImageNTHeaders32 *)((guint8 *)file_map + GUINT32_FROM_LE (dos_header->e_lfanew));
182 }
185 /* Do 64-bit stuff */
186 resource_rva = GUINT32_FROM_LE (((WapiImageNTHeaders64 *)nt_headers)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
188 resource_rva = GUINT32_FROM_LE (nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
189 }
196 }
198 resource_dir = (WapiImageResourceDirectory *)get_ptr_from_rva (resource_rva, (WapiImageNTHeaders32 *)nt_headers, file_map);
204 }
206 entries = GUINT16_FROM_LE (resource_dir->NumberOfNamedEntries) + GUINT16_FROM_LE (resource_dir->NumberOfIdEntries);
217 }
218 }
221 }
223 static gpointer
227 {
241 }
248 }
250 nt_headers = (WapiImageNTHeaders64 *)((guint8 *)file_map + GUINT32_FROM_LE (dos_header->e_lfanew));
257 }
260 /* Do 64-bit stuff */
261 resource_rva = GUINT32_FROM_LE (((WapiImageNTHeaders64 *)nt_headers)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
263 resource_rva = GUINT32_FROM_LE (nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
264 }
271 }
273 resource_dir = (WapiImageResourceDirectory *)get_ptr_from_rva (resource_rva, (WapiImageNTHeaders32 *)nt_headers, file_map);
279 }
281 entries = GUINT16_FROM_LE (resource_dir->NumberOfNamedEntries) + GUINT16_FROM_LE (resource_dir->NumberOfIdEntries);
292 }
293 }
296 }
298 static gpointer
302 {
303 /* Figure this out when we support 64bit PE files */
310 }
311 }
313 static gpointer
315 {
319 gpointer file_map;
321 /* According to the MSDN docs, a search path is applied to
322 * filename. FIXME: implement this, for now just pass it
323 * straight to fopen
324 */
332 }
342 }
351 }
354 /* Check basic file size */
362 }
372 }
374 /* Don't need the fd any more */
379 }
381 static void
383 {
385 }
387 static guint32
389 {
395 }
396 len++;
398 }
400 static gboolean
402 {
406 }
409 }
412 }
414 /* compare a little-endian null-terminated utf16 string and a normal string.
415 * Can be used only for ascii or latin1 chars.
416 */
417 static gboolean
419 {
423 }
426 }
429 }
432 {
433 guint16 data_len;
434 guint16 value_len;
435 guint16 type;
439 /* Returns a pointer to the value data, because there's no way to know
440 * how big that data is (value_len is set to zero for most blocks :-( )
441 */
442 static gconstpointer
444 {
450 /* No idea what the type is supposed to indicate */
455 /* Skip over the key (including the terminator) */
458 /* align on a 32-bit boundary */
462 }
464 static gconstpointer
466 {
467 gconstpointer data_ptr;
477 }
483 }
491 }
494 }
496 static gconstpointer
498 {
499 /* data is pointing at a Var block
500 */
504 }
506 static gconstpointer
512 {
517 /* data_ptr is pointing at an array of one or more String blocks
518 * with total length (not including alignment padding) of
519 * data_len
520 */
522 /* align on a 32-bit boundary */
527 /* We must have hit padding, so give up
528 * processing now
529 */
533 }
543 }
545 /* Skip over the value */
547 }
550 }
552 /* Returns a pointer to the byte following the Stringtable block, or
553 * NULL if the data read hits padding. We can't recover from this
554 * because the data length does not include padding bytes, so it's not
555 * possible to just return the start position + length
556 *
557 * If lang == NULL it means we're just stepping through this block
558 */
559 static gconstpointer
566 {
572 /* data_ptr is pointing at an array of StringTable blocks,
573 * with total length (not including alignment padding) of
574 * data_len
575 */
578 /* align on a 32-bit boundary */
583 /* We must have hit padding, so give up
584 * processing now
585 */
588 }
596 }
604 /* Got the one we're interested in */
606 string_value,
611 }
616 /* Child block hit padding */
619 }
620 }
623 }
625 #if G_BYTE_ORDER == G_BIG_ENDIAN
626 static gconstpointer
628 {
634 /* data_ptr is pointing at an array of one or more String
635 * blocks with total length (not including alignment padding)
636 * of data_len
637 */
639 /* align on a 32-bit boundary */
644 /* We must have hit padding, so give up
645 * processing now
646 */
649 }
656 NULL);
660 }
662 /* The swapped string should be exactly the same
663 * length as the original little-endian one, but only
664 * copy the number of original chars just to be on the
665 * safe side
666 */
673 NULL);
677 }
683 }
686 }
688 /* Returns a pointer to the byte following the Stringtable block, or
689 * NULL if the data read hits padding. We can't recover from this
690 * because the data length does not include padding bytes, so it's not
691 * possible to just return the start position + length
692 */
693 static gconstpointer
695 {
700 /* data_ptr is pointing at an array of StringTable blocks,
701 * with total length (not including alignment padding) of
702 * data_len
703 */
706 /* align on a 32-bit boundary */
711 /* We must have hit padding, so give up
712 * processing now
713 */
716 }
725 }
733 /* Child block hit padding */
736 }
737 }
740 }
742 /* Follows the data structures and turns all UTF-16 strings from the
743 * LE found in the resource section into UTF-16BE
744 */
745 static void
747 {
748 gconstpointer data_ptr;
750 version_data block;
756 /* Byteswap all the fields */
769 /* The FFI and header occupies the first 92 bytes
770 */
774 /* There now follow zero or one StringFileInfo blocks
775 * and zero or one VarFileInfo blocks
776 */
778 /* align on a 32-bit boundary */
783 /* We must have hit padding, so give
784 * up processing now
785 */
788 }
801 /* Bogus data */
804 }
807 /* Child block hit padding */
810 }
811 }
812 }
813 }
814 #endif
816 gboolean
817 VerQueryValue (gconstpointer datablock, const gunichar2 *subblock, gpointer *buffer, guint32 *len)
818 {
821 version_data block;
822 gconstpointer data_ptr;
835 }
848 }
857 }
861 /* The FFI and header occupies the first 92
862 * bytes
863 */
867 /* There now follow zero or one StringFileInfo
868 * blocks and zero or one VarFileInfo blocks
869 */
871 /* align on a 32-bit boundary */
877 /* We must have hit padding,
878 * so give up processing now
879 */
882 }
894 /* Skip over the Var block */
896 }
898 data_ptr = get_stringtable_block (data_ptr, lang_utf8, string_key, &string_value, &string_value_len, &block);
906 }
908 /* Bogus data */
911 }
914 /* Child block hit padding */
917 }
918 }
919 }
920 }
922 done:
925 }
929 }
931 guint32
933 {
934 gpointer file_map;
935 gpointer versioninfo;
937 gint32 map_size;
938 guint32 size;
940 /* This value is unused, but set to zero */
946 }
950 /* Didn't find the resource, so set the return value
951 * to 0
952 */
954 }
959 }
961 gboolean
962 GetFileVersionInfo (gunichar2 *filename, guint32 handle G_GNUC_UNUSED, guint32 len, gpointer data)
963 {
964 gpointer file_map;
965 gpointer versioninfo;
967 gint32 map_size;
968 guint32 size;
974 }
979 /* This could probably process the data so that
980 * VerQueryValue() doesn't have to follow the data
981 * blocks every time. But hey, these functions aren't
982 * likely to appear in many profiles.
983 */
987 #if G_BYTE_ORDER == G_BIG_ENDIAN
989 #endif
990 }
995 }
997 static guint32
999 {
1015 }
1020 }
1022 guint32
1024 {
1037 }
1090 }
1100 }
1110 }
1130 }
1140 }
1150 }
1170 }
1180 }
1233 }
1303 }
1313 }
1336 }
1346 }
1356 }
1366 }
1377 }
1387 }
1397 }
1408 }
1419 }
1429 }
1440 }
1447 }
1457 }
1467 }
1498 }
1508 }
1518 }
1531 }
1541 }
1551 }
1561 }
1571 }
1581 }
1591 }
1601 }
1611 }
1621 }
1631 }
1638 }
1648 }
1658 }
1668 }
1681 }
1691 }
1701 }
1711 }
1721 }
1731 }
1741 }
1751 }
1761 }
1771 }
1781 }
1791 }
1825 }
1832 }
1843 }
1853 }
1863 }
1873 }
1880 }
1893 }
1903 }
1911 }
1921 }
1931 }
1941 }
1951 }
1961 }
1969 }
1976 }
1986 }
1996 }
2009 }
2019 }
2029 }
2036 }
2043 }
2053 }
2063 }
2073 }
2080 }
2090 }
2097 }
2104 }
2111 }
2118 }
2125 }
2132 }
2142 }
2149 }
2156 }
2170 }
2180 }
2187 }
2194 }
2201 }
2208 }
2215 }
2222 }
2229 }
2236 }
2243 }
2253 }
2260 }
2267 }
2274 }
2281 }
2288 }
2295 }
2302 }
2308 }
2314 }