1 /*
2 * Dump a shortcut (lnk) file
3 *
4 * Copyright 2005 Mike McCormack
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23 #include "winedump.h"
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #ifdef HAVE_UNISTD_H
28 # include <unistd.h>
29 #endif
30 #ifdef HAVE_SYS_TYPES_H
31 # include <sys/types.h>
32 #endif
33 #include <fcntl.h>
34 #include <stdarg.h>
35
36 #include "windef.h"
37 #include "winbase.h"
38
39 #include "pshpack1.h"
40
41 typedef enum {
42 SLDF_HAS_ID_LIST = 0x00000001,
43 SLDF_HAS_LINK_INFO = 0x00000002,
44 SLDF_HAS_NAME = 0x00000004,
45 SLDF_HAS_RELPATH = 0x00000008,
46 SLDF_HAS_WORKINGDIR = 0x00000010,
47 SLDF_HAS_ARGS = 0x00000020,
48 SLDF_HAS_ICONLOCATION = 0x00000040,
49 SLDF_UNICODE = 0x00000080,
50 SLDF_FORCE_NO_LINKINFO = 0x00000100,
51 SLDF_HAS_EXP_SZ = 0x00000200,
52 SLDF_RUN_IN_SEPARATE = 0x00000400,
53 SLDF_HAS_LOGO3ID = 0x00000800,
54 SLDF_HAS_DARWINID = 0x00001000,
55 SLDF_RUNAS_USER = 0x00002000,
56 SLDF_HAS_EXP_ICON_SZ = 0x00004000,
57 SLDF_NO_PIDL_ALIAS = 0x00008000,
58 SLDF_FORCE_UNCNAME = 0x00010000,
59 SLDF_RUN_WITH_SHIMLAYER = 0x00020000,
60 SLDF_FORCE_NO_LINKTRACK = 0x00040000,
61 SLDF_ENABLE_TARGET_METADATA = 0x00080000,
62 SLDF_DISABLE_KNOWNFOLDER_RELATIVE_TRACKING = 0x00200000,
63 SLDF_RESERVED = 0x80000000,
64 } SHELL_LINK_DATA_FLAGS;
65
66 #define EXP_SZ_LINK_SIG 0xa0000001
67 #define EXP_SPECIAL_FOLDER_SIG 0xa0000005
68 #define EXP_DARWIN_ID_SIG 0xa0000006
69 #define EXP_SZ_ICON_SIG 0xa0000007
70
71 typedef struct tagDATABLOCKHEADER
72 {
73 DWORD cbSize;
74 DWORD dwSignature;
75 } DATABLOCK_HEADER;
76
77 typedef struct _LINK_HEADER
78 {
79 DWORD dwSize; /* 0x00 size of the header - 0x4c */
80 GUID MagicGuid; /* 0x04 is CLSID_ShellLink */
81 DWORD dwFlags; /* 0x14 describes elements following */
82 DWORD dwFileAttr; /* 0x18 attributes of the target file */
83 FILETIME Time1; /* 0x1c */
84 FILETIME Time2; /* 0x24 */
85 FILETIME Time3; /* 0x2c */
86 DWORD dwFileLength; /* 0x34 File length */
87 DWORD nIcon; /* 0x38 icon number */
88 DWORD fStartup; /* 0x3c startup type */
89 DWORD wHotKey; /* 0x40 hotkey */
90 DWORD Unknown5; /* 0x44 */
91 DWORD Unknown6; /* 0x48 */
92 } LINK_HEADER, * PLINK_HEADER;
93
94 typedef struct tagLINK_SZ_BLOCK
95 {
96 DWORD size;
97 DWORD magic;
98 CHAR bufA[MAX_PATH];
99 WCHAR bufW[MAX_PATH];
100 } LINK_SZ_BLOCK;
101
102 typedef struct _LOCATION_INFO
103 {
104 DWORD dwTotalSize;
105 DWORD dwHeaderSize;
106 DWORD dwFlags;
107 DWORD dwVolTableOfs;
108 DWORD dwLocalPathOfs;
109 DWORD dwNetworkVolTableOfs;
110 DWORD dwFinalPathOfs;
111 } LOCATION_INFO;
112
113 typedef struct _LOCAL_VOLUME_INFO
114 {
115 DWORD dwSize;
116 DWORD dwType;
117 DWORD dwVolSerial;
118 DWORD dwVolLabelOfs;
119 } LOCAL_VOLUME_INFO;
120
121 typedef struct
122 {
123 DWORD cbSize;
124 DWORD dwSignature;
125 DWORD idSpecialFolder;
126 DWORD cbOffset;
127 } EXP_SPECIAL_FOLDER;
128
129 typedef struct lnk_string_tag
130 {
131 unsigned short size;
132 union {
133 unsigned short w[1];
134 unsigned char a[1];
135 } str;
136 } lnk_string;
137
138 #include "poppack.h"
139
140 static unsigned offset;
141
142 static const void* fetch_block(void)
143 {
144 const unsigned* u;
145 const void* ret;
146
147 if (!(u = PRD(offset, sizeof(*u)))) return 0;
148 if ((ret = PRD(offset, *u))) offset += *u;
149 return ret;
150 }
151
152 static const lnk_string* fetch_string(int unicode)
153 {
154 const unsigned short* s;
155 unsigned short len;
156 const void* ret;
157
158 if (!(s = PRD(offset, sizeof(*s)))) return 0;
159 len = *s * (unicode ? sizeof(WCHAR) : sizeof(char));
160 if ((ret = PRD(offset, sizeof(*s) + len))) offset += sizeof(*s) + len;
161 return ret;
162 }
163
164
165 static int dump_pidl(void)
166 {
167 const lnk_string *pidl;
168 int i, n = 0, sz = 0;
169
170 pidl = fetch_string(FALSE);
171 if (!pidl)
172 return -1;
173
174 printf("PIDL\n");
175 printf("----\n\n");
176
177 while(sz<pidl->size)
178 {
179 const lnk_string *segment = (const lnk_string*) &pidl->str.a[sz];
180
181 if(!segment->size)
182 break;
183 sz+=segment->size;
184 if(sz>pidl->size)
185 {
186 printf("bad pidl\n");
187 break;
188 }
189 n++;
190 printf("segment %d (%2d bytes) : ",n,segment->size);
191 for(i=0; i<segment->size; i++)
192 printf("%02x ",segment->str.a[i]);
193 printf("\n");
194 }
195 printf("\n");
196
197 return 0;
198 }
199
200 static int dump_string(const char *what, int unicode)
201 {
202 const lnk_string *data;
203 unsigned sz;
204
205 data = fetch_string(unicode);
206 if (!data)
207 return -1;
208 printf("%s : ", what);
209 sz = data->size;
210 if (unicode)
211 while (sz) printf("%c", data->str.w[data->size - sz--]);
212 else
213 while (sz) printf("%c", data->str.a[data->size - sz--]);
214 printf("\n");
215
216 return 0;
217 }
218
219 static int dump_location(void)
220 {
221 const LOCATION_INFO *loc;
222 const char *p;
223
224 loc = fetch_block();
225 if (!loc)
226 return -1;
227 p = (const char*)loc;
228
229 printf("Location\n");
230 printf("--------\n\n");
231 printf("Total size = %d\n", loc->dwTotalSize);
232 printf("Header size = %d\n", loc->dwHeaderSize);
233 printf("Flags = %08x\n", loc->dwFlags);
234
235 /* dump out information about the volume the link points to */
236 printf("Volume ofs = %08x ", loc->dwVolTableOfs);
237 if (loc->dwVolTableOfs && (loc->dwVolTableOfs<loc->dwTotalSize))
238 {
239 const LOCAL_VOLUME_INFO *vol = (const LOCAL_VOLUME_INFO *)&p[loc->dwVolTableOfs];
240
241 printf("size %d type %d serial %08x label %d ",
242 vol->dwSize, vol->dwType, vol->dwVolSerial, vol->dwVolLabelOfs);
243 if(vol->dwVolLabelOfs)
244 printf("(\"%s\")", &p[loc->dwVolTableOfs + vol->dwVolLabelOfs]);
245 }
246 printf("\n");
247
248 /* dump out the path the link points to */
249 printf("LocalPath ofs = %08x ", loc->dwLocalPathOfs);
250 if( loc->dwLocalPathOfs && (loc->dwLocalPathOfs < loc->dwTotalSize) )
251 printf("(\"%s\")", &p[loc->dwLocalPathOfs]);
252 printf("\n");
253
254 printf("Net Path ofs = %08x\n", loc->dwNetworkVolTableOfs);
255 printf("Final Path = %08x ", loc->dwFinalPathOfs);
256 if( loc->dwFinalPathOfs && (loc->dwFinalPathOfs < loc->dwTotalSize) )
257 printf("(\"%s\")", &p[loc->dwFinalPathOfs]);
258 printf("\n");
259 printf("\n");
260
261 return 0;
262 }
263
264 static const unsigned char table_dec85[0x80] = {
265 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
266 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
267 0xff,0x00,0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0xff,
268 0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0xff,0xff,0xff,0x16,0xff,0x17,
269 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
270 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0x34,0x35,0x36,
271 0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,
272 0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0xff,0x53,0x54,0xff,
273 };
274
275 static int base85_to_guid( const char *str, LPGUID guid )
276 {
277 DWORD i, val = 0, base = 1, *p;
278 unsigned char ch;
279
280 p = (DWORD*) guid;
281 for( i=0; i<20; i++ )
282 {
283 if( (i%5) == 0 )
284 {
285 val = 0;
286 base = 1;
287 }
288 ch = str[i];
289 if( ch >= 0x80 )
290 return 0;
291 val += table_dec85[ch] * base;
292 if( table_dec85[ch] == 0xff )
293 return 0;
294 if( (i%5) == 4 )
295 p[i/5] = val;
296 base *= 85;
297 }
298 return 1;
299 }
300
301 static int dump_special_folder_block(const DATABLOCK_HEADER* bhdr)
302 {
303 const EXP_SPECIAL_FOLDER *sfb = (const EXP_SPECIAL_FOLDER*)bhdr;
304 printf("Special folder block\n");
305 printf("--------------------\n\n");
306 printf("folder = 0x%04x\n", sfb->idSpecialFolder);
307 printf("offset = %d\n", sfb->cbOffset);
308 printf("\n");
309 return 0;
310 }
311
312 static int dump_sz_block(const DATABLOCK_HEADER* bhdr, const char* label)
313 {
314 const LINK_SZ_BLOCK *szp = (const LINK_SZ_BLOCK*)bhdr;
315 printf("String block\n");
316 printf("-----------\n\n");
317 printf("magic = %x\n", szp->magic);
318 printf("%s = %s\n", label, szp->bufA);
319 printf("\n");
320 return 0;
321 }
322
323 static int dump_darwin_id(const DATABLOCK_HEADER* bhdr)
324 {
325 const LINK_SZ_BLOCK *szp = (const LINK_SZ_BLOCK*)bhdr;
326 char comp_str[40];
327 const char *feat, *comp, *prod_str, *feat_str;
328 GUID guid;
329
330 printf("Advertise Info\n");
331 printf("--------------\n\n");
332 printf("msi string = %s\n", szp->bufA);
333
334 if (base85_to_guid(szp->bufA, &guid))
335 prod_str = get_guid_str(&guid);
336 else
337 prod_str = "?";
338
339 comp = &szp->bufA[20];
340 feat = strchr(comp, '>');
341 if (!feat)
342 feat = strchr(comp, '<');
343 if (feat)
344 {
345 memcpy(comp_str, comp, feat - comp);
346 comp_str[feat-comp] = 0;
347 }
348 else
349 {
350 strcpy(comp_str, "?");
351 }
352
353 if (feat && feat[0] == '>' && base85_to_guid( &feat[1], &guid ))
354 feat_str = get_guid_str( &guid );
355 else
356 feat_str = "";
357
358 printf(" product: %s\n", prod_str);
359 printf(" component: %s\n", comp_str );
360 printf(" feature: %s\n", feat_str);
361 printf("\n");
362
363 return 0;
364 }
365
366 static int dump_raw_block(const DATABLOCK_HEADER* bhdr)
367 {
368 int data_size;
369
370 printf("Raw Block\n");
371 printf("---------\n\n");
372 printf("size = %d\n", bhdr->cbSize);
373 printf("magic = %x\n", bhdr->dwSignature);
374
375 data_size=bhdr->cbSize-sizeof(*bhdr);
376 if (data_size > 0)
377 {
378 unsigned int i;
379 const unsigned char *data;
380
381 printf("data = ");
382 data=(const unsigned char*)bhdr+sizeof(*bhdr);
383 while (data_size > 0)
384 {
385 for (i=0; i < 16; i++)
386 {
387 if (i < data_size)
388 printf("%02x ", data[i]);
389 else
390 printf(" ");
391 }
392 for (i=0; i < data_size && i < 16; i++)
393 printf("%c", (data[i] >= 32 && data[i] < 128 ? data[i] : '.'));
394 printf("\n");
395 data_size-=16;
396 if (data_size <= 0)
397 break;
398 data+=16;
399 printf(" ");
400 }
401 }
402 printf("\n");
403
404 return 1;
405 }
406
407 static const GUID CLSID_ShellLink = {0x00021401L, 0, 0, {0xC0,0,0,0,0,0,0,0x46}};
408
409 enum FileSig get_kind_lnk(void)
410 {
411 const LINK_HEADER* hdr;
412
413 hdr = PRD(0, sizeof(*hdr));
414 if (hdr && hdr->dwSize == sizeof(LINK_HEADER) &&
415 !memcmp(&hdr->MagicGuid, &CLSID_ShellLink, sizeof(GUID)))
416 return SIG_LNK;
417 return SIG_UNKNOWN;
418 }
419
420 void lnk_dump(void)
421 {
422 const LINK_HEADER* hdr;
423 const DATABLOCK_HEADER* bhdr;
424 DWORD dwFlags;
425
426 offset = 0;
427 hdr = fetch_block();
428 if (!hdr)
429 return;
430
431 printf("Header\n");
432 printf("------\n\n");
433 printf("Size: %04x\n", hdr->dwSize);
434 printf("GUID: %s\n", get_guid_str(&hdr->MagicGuid));
435
436 printf("FileAttr: %08x\n", hdr->dwFileAttr);
437 printf("FileLength: %08x\n", hdr->dwFileLength);
438 printf("nIcon: %d\n", hdr->nIcon);
439 printf("Startup: %d\n", hdr->fStartup);
440 printf("HotKey: %08x\n", hdr->wHotKey);
441 printf("Unknown5: %08x\n", hdr->Unknown5);
442 printf("Unknown6: %08x\n", hdr->Unknown6);
443
444 /* dump out all the flags */
445 printf("Flags: %04x ( ", hdr->dwFlags);
446 dwFlags=hdr->dwFlags;
447 #define FLAG(x) do \
448 { \
449 if (dwFlags & SLDF_##x) \
450 { \
451 printf("%s ", #x); \
452 dwFlags&=~SLDF_##x; \
453 } \
454 } while (0)
455 FLAG(HAS_ID_LIST);
456 FLAG(HAS_LINK_INFO);
457 FLAG(HAS_NAME);
458 FLAG(HAS_RELPATH);
459 FLAG(HAS_WORKINGDIR);
460 FLAG(HAS_ARGS);
461 FLAG(HAS_ICONLOCATION);
462 FLAG(UNICODE);
463 FLAG(FORCE_NO_LINKINFO);
464 FLAG(HAS_EXP_SZ);
465 FLAG(RUN_IN_SEPARATE);
466 FLAG(HAS_LOGO3ID);
467 FLAG(HAS_DARWINID);
468 FLAG(RUNAS_USER);
469 FLAG(HAS_EXP_ICON_SZ);
470 FLAG(NO_PIDL_ALIAS);
471 FLAG(FORCE_UNCNAME);
472 FLAG(RUN_WITH_SHIMLAYER);
473 FLAG(FORCE_NO_LINKTRACK);
474 FLAG(ENABLE_TARGET_METADATA);
475 FLAG(DISABLE_KNOWNFOLDER_RELATIVE_TRACKING);
476 FLAG(RESERVED);
477 #undef FLAG
478 if (dwFlags)
479 printf("+%04x", dwFlags);
480 printf(")\n");
481
482 printf("Length: %04x\n", hdr->dwFileLength);
483 printf("\n");
484
485 if (hdr->dwFlags & SLDF_HAS_ID_LIST)
486 dump_pidl();
487 if (hdr->dwFlags & SLDF_HAS_LINK_INFO)
488 dump_location();
489 if (hdr->dwFlags & SLDF_HAS_NAME)
490 dump_string("Description", hdr->dwFlags & SLDF_UNICODE);
491 if (hdr->dwFlags & SLDF_HAS_RELPATH)
492 dump_string("Relative path", hdr->dwFlags & SLDF_UNICODE);
493 if (hdr->dwFlags & SLDF_HAS_WORKINGDIR)
494 dump_string("Working directory", hdr->dwFlags & SLDF_UNICODE);
495 if (hdr->dwFlags & SLDF_HAS_ARGS)
496 dump_string("Arguments", hdr->dwFlags & SLDF_UNICODE);
497 if (hdr->dwFlags & SLDF_HAS_ICONLOCATION)
498 dump_string("Icon path", hdr->dwFlags & SLDF_UNICODE);
499
500 bhdr=fetch_block();
501 while (bhdr)
502 {
503 if (!bhdr->cbSize)
504 break;
505 switch (bhdr->dwSignature)
506 {
507 case EXP_SZ_LINK_SIG:
508 dump_sz_block(bhdr, "exp.link");
509 break;
510 case EXP_SPECIAL_FOLDER_SIG:
511 dump_special_folder_block(bhdr);
512 break;
513 case EXP_SZ_ICON_SIG:
514 dump_sz_block(bhdr, "icon");
515 break;
516 case EXP_DARWIN_ID_SIG:
517 dump_darwin_id(bhdr);
518 break;
519 default:
520 dump_raw_block(bhdr);
521 }
522 bhdr=fetch_block();
523 }
524 }
525
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.