| blob | 2ba7fc96d5554ee1eaa5d1c7221aabaa020896ae |
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 #if 0
29 // #define DEBUG(...) g_message(__VA_ARGS__)
30 #else
31 #define DEBUG(...)
32 #endif
34 #define ALIGN32(ptr) ptr = (gpointer)((char *)ptr + 3); ptr = (gpointer)((char *)ptr - ((gsize)ptr & 3));
38 {
40 guint32 i;
46 }
51 }
52 }
55 }
57 /* This works for both 32bit and 64bit files, as the differences are
58 * all after the section header block
59 */
60 static gpointer
62 {
64 guint32 delta;
69 }
75 }
77 static gpointer
80 gpointer file_map,
84 {
85 WapiImageResourceDirectoryEntry swapped_entry;
99 /* Normally holds a directory entry for each type of
100 * resource
101 */
106 }
108 /* Normally holds a directory entry for each resource
109 * item
110 */
112 /* Normally holds a directory entry for each language
113 */
119 }
122 }
125 WapiImageResourceDirectory *res_dir = (WapiImageResourceDirectory *)((guint8 *)root + dir_offset);
126 WapiImageResourceDirectoryEntry *sub_entries = (WapiImageResourceDirectoryEntry *)(res_dir + 1);
129 entries = GUINT16_FROM_LE (res_dir->NumberOfNamedEntries) + GUINT16_FROM_LE (res_dir->NumberOfIdEntries);
133 gpointer ret;
140 }
141 }
145 WapiImageResourceDataEntry *data_entry = (WapiImageResourceDataEntry *)((guint8 *)root + data_offset);
149 }
150 }
152 static gpointer
156 {
170 }
177 }
179 nt_headers = (WapiImageNTHeaders32 *)((guint8 *)file_map + GUINT32_FROM_LE (dos_header->e_lfanew));
185 }
188 /* Do 64-bit stuff */
189 resource_rva = GUINT32_FROM_LE (((WapiImageNTHeaders64 *)nt_headers)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
191 resource_rva = GUINT32_FROM_LE (nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
192 }
199 }
201 resource_dir = (WapiImageResourceDirectory *)get_ptr_from_rva (resource_rva, (WapiImageNTHeaders32 *)nt_headers, file_map);
207 }
209 entries = GUINT16_FROM_LE (resource_dir->NumberOfNamedEntries) + GUINT16_FROM_LE (resource_dir->NumberOfIdEntries);
220 }
221 }
224 }
226 static gpointer
230 {
244 }
251 }
253 nt_headers = (WapiImageNTHeaders64 *)((guint8 *)file_map + GUINT32_FROM_LE (dos_header->e_lfanew));
260 }
263 /* Do 64-bit stuff */
264 resource_rva = GUINT32_FROM_LE (((WapiImageNTHeaders64 *)nt_headers)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
266 resource_rva = GUINT32_FROM_LE (nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
267 }
274 }
276 resource_dir = (WapiImageResourceDirectory *)get_ptr_from_rva (resource_rva, (WapiImageNTHeaders32 *)nt_headers, file_map);
282 }
284 entries = GUINT16_FROM_LE (resource_dir->NumberOfNamedEntries) + GUINT16_FROM_LE (resource_dir->NumberOfIdEntries);
295 }
296 }
299 }
301 static gpointer
305 {
306 /* Figure this out when we support 64bit PE files */
313 }
314 }
316 static gpointer
318 {
322 gpointer file_map;
324 /* According to the MSDN docs, a search path is applied to
325 * filename. FIXME: implement this, for now just pass it
326 * straight to fopen
327 */
335 }
345 }
354 }
357 /* Check basic file size */
365 }
375 }
377 /* Don't need the fd any more */
382 }
384 static void
386 {
388 }
390 static guint32
392 {
398 }
399 len++;
401 }
403 static gboolean
405 {
409 }
412 }
415 }
417 /* compare a little-endian null-terminated utf16 string and a normal string.
418 * Can be used only for ascii or latin1 chars.
419 */
420 static gboolean
422 {
426 }
429 }
432 }
435 {
436 guint16 data_len;
437 guint16 value_len;
438 guint16 type;
442 /* Returns a pointer to the value data, because there's no way to know
443 * how big that data is (value_len is set to zero for most blocks :-( )
444 */
445 static gconstpointer
447 {
453 /* No idea what the type is supposed to indicate */
458 /* Skip over the key (including the terminator) */
461 /* align on a 32-bit boundary */
465 }
467 static gconstpointer
469 {
470 gconstpointer data_ptr;
480 }
486 }
494 }
497 }
499 static gconstpointer
501 {
502 /* data is pointing at a Var block
503 */
507 }
509 static gconstpointer
515 {
520 /* data_ptr is pointing at an array of one or more String blocks
521 * with total length (not including alignment padding) of
522 * data_len
523 */
525 /* align on a 32-bit boundary */
530 /* We must have hit padding, so give up
531 * processing now
532 */
536 }
546 }
548 /* Skip over the value */
550 }
553 }
555 /* Returns a pointer to the byte following the Stringtable block, or
556 * NULL if the data read hits padding. We can't recover from this
557 * because the data length does not include padding bytes, so it's not
558 * possible to just return the start position + length
559 *
560 * If lang == NULL it means we're just stepping through this block
561 */
562 static gconstpointer
569 {
575 /* data_ptr is pointing at an array of StringTable blocks,
576 * with total length (not including alignment padding) of
577 * data_len
578 */
581 /* align on a 32-bit boundary */
586 /* We must have hit padding, so give up
587 * processing now
588 */
591 }
599 }
607 /* Got the one we're interested in */
609 string_value,
614 }
619 /* Child block hit padding */
622 }
623 }
626 }
628 #if G_BYTE_ORDER == G_BIG_ENDIAN
629 static gconstpointer
631 {
637 /* data_ptr is pointing at an array of one or more String
638 * blocks with total length (not including alignment padding)
639 * of data_len
640 */
642 /* align on a 32-bit boundary */
647 /* We must have hit padding, so give up
648 * processing now
649 */
652 }
659 NULL);
663 }
665 /* The swapped string should be exactly the same
666 * length as the original little-endian one, but only
667 * copy the number of original chars just to be on the
668 * safe side
669 */
676 NULL);
680 }
686 }
689 }
691 /* Returns a pointer to the byte following the Stringtable block, or
692 * NULL if the data read hits padding. We can't recover from this
693 * because the data length does not include padding bytes, so it's not
694 * possible to just return the start position + length
695 */
696 static gconstpointer
698 {
703 /* data_ptr is pointing at an array of StringTable blocks,
704 * with total length (not including alignment padding) of
705 * data_len
706 */
709 /* align on a 32-bit boundary */
714 /* We must have hit padding, so give up
715 * processing now
716 */
719 }
728 }
736 /* Child block hit padding */
739 }
740 }
743 }
745 /* Follows the data structures and turns all UTF-16 strings from the
746 * LE found in the resource section into UTF-16BE
747 */
748 static void
750 {
751 gconstpointer data_ptr;
753 version_data block;
759 /* Byteswap all the fields */
772 /* The FFI and header occupies the first 92 bytes
773 */
777 /* There now follow zero or one StringFileInfo blocks
778 * and zero or one VarFileInfo blocks
779 */
781 /* align on a 32-bit boundary */
786 /* We must have hit padding, so give
787 * up processing now
788 */
791 }
804 /* Bogus data */
807 }
810 /* Child block hit padding */
813 }
814 }
815 }
816 }
817 #endif
819 gboolean
820 VerQueryValue (gconstpointer datablock, const gunichar2 *subblock, gpointer *buffer, guint32 *len)
821 {
824 version_data block;
825 gconstpointer data_ptr;
838 }
851 }
860 }
864 /* The FFI and header occupies the first 92
865 * bytes
866 */
870 /* There now follow zero or one StringFileInfo
871 * blocks and zero or one VarFileInfo blocks
872 */
874 /* align on a 32-bit boundary */
880 /* We must have hit padding,
881 * so give up processing now
882 */
885 }
897 /* Skip over the Var block */
899 }
901 data_ptr = get_stringtable_block (data_ptr, lang_utf8, string_key, &string_value, &string_value_len, &block);
909 }
911 /* Bogus data */
914 }
917 /* Child block hit padding */
920 }
921 }
922 }
923 }
925 done:
928 }
932 }
934 guint32
936 {
937 gpointer file_map;
938 gpointer versioninfo;
940 gint32 map_size;
941 guint32 size;
943 /* This value is unused, but set to zero */
949 }
953 /* Didn't find the resource, so set the return value
954 * to 0
955 */
957 }
962 }
964 gboolean
965 GetFileVersionInfo (gunichar2 *filename, guint32 handle G_GNUC_UNUSED, guint32 len, gpointer data)
966 {
967 gpointer file_map;
968 gpointer versioninfo;
970 gint32 map_size;
971 guint32 size;
977 }
982 /* This could probably process the data so that
983 * VerQueryValue() doesn't have to follow the data
984 * blocks every time. But hey, these functions aren't
985 * likely to appear in many profiles.
986 */
990 #if G_BYTE_ORDER == G_BIG_ENDIAN
992 #endif
993 }
998 }
1000 static guint32
1002 {
1018 }
1023 }
1025 guint32
1027 {
1040 }
1093 }
1103 }
1113 }
1133 }
1143 }
1153 }
1173 }
1183 }
1236 }
1306 }
1316 }
1339 }
1349 }
1359 }
1369 }
1380 }
1390 }
1400 }
1411 }
1422 }
1432 }
1443 }
1450 }
1460 }
1470 }
1501 }
1511 }
1521 }
1534 }
1544 }
1554 }
1564 }
1574 }
1584 }
1594 }
1604 }
1614 }
1624 }
1634 }
1641 }
1651 }
1661 }
1671 }
1684 }
1694 }
1704 }
1714 }
1724 }
1734 }
1744 }
1754 }
1764 }
1774 }
1784 }
1794 }
1828 }
1835 }
1846 }
1856 }
1866 }
1876 }
1883 }
1896 }
1906 }
1914 }
1924 }
1934 }
1944 }
1954 }
1964 }
1972 }
1979 }
1989 }
1999 }
2012 }
2022 }
2032 }
2039 }
2046 }
2056 }
2066 }
2076 }
2083 }
2093 }
2100 }
2107 }
2114 }
2121 }
2128 }
2135 }
2145 }
2152 }
2159 }
2173 }
2183 }
2190 }
2197 }
2204 }
2211 }
2218 }
2225 }
2232 }
2239 }
2246 }
2256 }
2263 }
2270 }
2277 }
2284 }
2291 }
2298 }
2305 }
2311 }
2317 }