?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
crypt32: Implement CryptBinaryToStringW(HEXRAW).
[wine.git] / tools / winedump / lnk.c
blob0a06b49a118289931ad671edbad119188618c672
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 #define EXP_PROPERTYSTORAGE_SIG 0xa0000009
71
72 typedef struct tagDATABLOCKHEADER
73 {
74 DWORD cbSize;
75 DWORD dwSignature;
76 } DATABLOCK_HEADER;
77
78 typedef struct _LINK_HEADER
79 {
80 DWORD dwSize; /* 0x00 size of the header - 0x4c */
81 GUID MagicGuid; /* 0x04 is CLSID_ShellLink */
82 DWORD dwFlags; /* 0x14 describes elements following */
83 DWORD dwFileAttr; /* 0x18 attributes of the target file */
84 FILETIME Time1; /* 0x1c */
85 FILETIME Time2; /* 0x24 */
86 FILETIME Time3; /* 0x2c */
87 DWORD dwFileLength; /* 0x34 File length */
88 DWORD nIcon; /* 0x38 icon number */
89 DWORD fStartup; /* 0x3c startup type */
90 DWORD wHotKey; /* 0x40 hotkey */
91 DWORD Unknown5; /* 0x44 */
92 DWORD Unknown6; /* 0x48 */
93 } LINK_HEADER, * PLINK_HEADER;
94
95 typedef struct tagLINK_SZ_BLOCK
96 {
97 DWORD size;
98 DWORD magic;
99 CHAR bufA[MAX_PATH];
100 WCHAR bufW[MAX_PATH];
101 } LINK_SZ_BLOCK;
102
103 typedef struct tagLINK_PROPERTYSTORAGE_GUID
104 {
105 DWORD size;
106 DWORD magic;
107 GUID fmtid;
108 } LINK_PROPERTYSTORAGE_GUID;
109
110 typedef struct tagLINK_PROPERTYSTORAGE_VALUE
111 {
112 DWORD size;
113 DWORD pid;
114 BYTE unknown8;
115 DWORD vt;
116 DWORD unknown25;
117 } LINK_PROPERTYSTORAGE_VALUE;
118
119 typedef struct _LOCATION_INFO
120 {
121 DWORD dwTotalSize;
122 DWORD dwHeaderSize;
123 DWORD dwFlags;
124 DWORD dwVolTableOfs;
125 DWORD dwLocalPathOfs;
126 DWORD dwNetworkVolTableOfs;
127 DWORD dwFinalPathOfs;
128 } LOCATION_INFO;
129
130 typedef struct _LOCAL_VOLUME_INFO
131 {
132 DWORD dwSize;
133 DWORD dwType;
134 DWORD dwVolSerial;
135 DWORD dwVolLabelOfs;
136 } LOCAL_VOLUME_INFO;
137
138 typedef struct _NETWORK_VOLUME_INFO
139 {
140 DWORD dwSize;
141 DWORD dwUnknown1;
142 DWORD dwShareNameOfs;
143 DWORD dwReserved;
144 DWORD dwUnknown2;
145 } NETWORK_VOLUME_INFO;
146
147 typedef struct
148 {
149 DWORD cbSize;
150 DWORD dwSignature;
151 DWORD idSpecialFolder;
152 DWORD cbOffset;
153 } EXP_SPECIAL_FOLDER;
154
155 typedef struct lnk_string_tag
156 {
157 unsigned short size;
158 union {
159 unsigned short w[1];
160 unsigned char a[1];
161 } str;
162 } lnk_string;
163
164 #include "poppack.h"
165
166 static unsigned offset;
167
168 static const void* fetch_block(void)
169 {
170 const unsigned* u;
171 const void* ret;
172
173 if (!(u = PRD(offset, sizeof(*u)))) return 0;
174 if ((ret = PRD(offset, *u))) offset += *u;
175 return ret;
176 }
177
178 static const lnk_string* fetch_string(int unicode)
179 {
180 const unsigned short* s;
181 unsigned short len;
182 const void* ret;
183
184 if (!(s = PRD(offset, sizeof(*s)))) return 0;
185 len = *s * (unicode ? sizeof(WCHAR) : sizeof(char));
186 if ((ret = PRD(offset, sizeof(*s) + len))) offset += sizeof(*s) + len;
187 return ret;
188 }
189
190
191 static void dump_pidl(void)
192 {
193 const lnk_string *pidl;
194 int i, n = 0, sz = 0;
195
196 pidl = fetch_string(FALSE);
197 if (!pidl)
198 return;
199
200 printf("PIDL\n");
201 printf("----\n\n");
202
203 while(sz<pidl->size)
204 {
205 const lnk_string *segment = (const lnk_string*) &pidl->str.a[sz];
206
207 if(!segment->size)
208 break;
209 sz+=segment->size;
210 if(sz>pidl->size)
211 {
212 printf("bad pidl\n");
213 break;
214 }
215 n++;
216 printf("segment %d (%2d bytes) : ",n,segment->size);
217 for(i=0; i<segment->size; i++)
218 printf("%02x ",segment->str.a[i]);
219 printf("\n");
220 }
221 printf("\n");
222 }
223
224 static void dump_string(const char *what, int unicode)
225 {
226 const lnk_string *data;
227 unsigned sz;
228
229 data = fetch_string(unicode);
230 if (!data)
231 return;
232 printf("%s : ", what);
233 sz = data->size;
234 if (unicode)
235 while (sz) printf("%c", data->str.w[data->size - sz--]);
236 else
237 while (sz) printf("%c", data->str.a[data->size - sz--]);
238 printf("\n");
239 }
240
241 static void dump_location(void)
242 {
243 const LOCATION_INFO *loc;
244 const char *p;
245
246 loc = fetch_block();
247 if (!loc)
248 return;
249 p = (const char*)loc;
250
251 printf("Location\n");
252 printf("--------\n\n");
253 printf("Total size = %d\n", loc->dwTotalSize);
254 printf("Header size = %d\n", loc->dwHeaderSize);
255 printf("Flags = %08x\n", loc->dwFlags);
256
257 /* dump information about the local volume the link points to */
258 printf("Local volume ofs = %08x ", loc->dwVolTableOfs);
259 if (loc->dwVolTableOfs &&
260 loc->dwVolTableOfs + sizeof(LOCAL_VOLUME_INFO) < loc->dwTotalSize)
261 {
262 const LOCAL_VOLUME_INFO *vol = (const LOCAL_VOLUME_INFO *)&p[loc->dwVolTableOfs];
263
264 printf("size %d type %d serial %08x label %d ",
265 vol->dwSize, vol->dwType, vol->dwVolSerial, vol->dwVolLabelOfs);
266 if(vol->dwVolLabelOfs)
267 printf("(\"%s\")", &p[loc->dwVolTableOfs + vol->dwVolLabelOfs]);
268 }
269 printf("\n");
270
271 /* dump information about the network volume the link points to */
272 printf("Network volume ofs = %08x ", loc->dwNetworkVolTableOfs);
273 if (loc->dwNetworkVolTableOfs &&
274 loc->dwNetworkVolTableOfs + sizeof(NETWORK_VOLUME_INFO) < loc->dwTotalSize)
275 {
276 const NETWORK_VOLUME_INFO *vol = (const NETWORK_VOLUME_INFO *)&p[loc->dwNetworkVolTableOfs];
277
278 printf("size %d name %d ", vol->dwSize, vol->dwShareNameOfs);
279 if(vol->dwShareNameOfs)
280 printf("(\"%s\")", &p[loc->dwNetworkVolTableOfs + vol->dwShareNameOfs]);
281 }
282 printf("\n");
283
284 /* dump out the path the link points to */
285 printf("LocalPath ofs = %08x ", loc->dwLocalPathOfs);
286 if( loc->dwLocalPathOfs && (loc->dwLocalPathOfs < loc->dwTotalSize) )
287 printf("(\"%s\")", &p[loc->dwLocalPathOfs]);
288 printf("\n");
289
290 printf("Net Path ofs = %08x\n", loc->dwNetworkVolTableOfs);
291 printf("Final Path = %08x ", loc->dwFinalPathOfs);
292 if( loc->dwFinalPathOfs && (loc->dwFinalPathOfs < loc->dwTotalSize) )
293 printf("(\"%s\")", &p[loc->dwFinalPathOfs]);
294 printf("\n");
295 printf("\n");
296 }
297
298 static const unsigned char table_dec85[0x80] = {
299 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
300 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
301 0xff,0x00,0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0xff,
302 0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0xff,0xff,0xff,0x16,0xff,0x17,
303 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
304 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0x34,0x35,0x36,
305 0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,
306 0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0xff,0x53,0x54,0xff,
307 };
308
309 static BOOL base85_to_guid( const char *str, LPGUID guid )
310 {
311 DWORD i, val = 0, base = 1, *p;
312 unsigned char ch;
313
314 p = (DWORD*) guid;
315 for( i=0; i<20; i++ )
316 {
317 if( (i%5) == 0 )
318 {
319 val = 0;
320 base = 1;
321 }
322 ch = str[i];
323 if( ch >= 0x80 )
324 return FALSE;
325 val += table_dec85[ch] * base;
326 if( table_dec85[ch] == 0xff )
327 return FALSE;
328 if( (i%5) == 4 )
329 p[i/5] = val;
330 base *= 85;
331 }
332 return TRUE;
333 }
334
335 static void dump_special_folder_block(const DATABLOCK_HEADER* bhdr)
336 {
337 const EXP_SPECIAL_FOLDER *sfb = (const EXP_SPECIAL_FOLDER*)bhdr;
338 printf("Special folder block\n");
339 printf("--------------------\n\n");
340 printf("folder = 0x%04x\n", sfb->idSpecialFolder);
341 printf("offset = %d\n", sfb->cbOffset);
342 printf("\n");
343 }
344
345 static void dump_sz_block(const DATABLOCK_HEADER* bhdr, const char* label)
346 {
347 const LINK_SZ_BLOCK *szp = (const LINK_SZ_BLOCK*)bhdr;
348 printf("String block\n");
349 printf("-----------\n\n");
350 printf("magic = %x\n", szp->magic);
351 printf("%s = %s\n", label, szp->bufA);
352 printf("\n");
353 }
354
355 static void dump_darwin_id(const DATABLOCK_HEADER* bhdr)
356 {
357 const LINK_SZ_BLOCK *szp = (const LINK_SZ_BLOCK*)bhdr;
358 char comp_str[40];
359 const char *feat, *comp, *prod_str, *feat_str;
360 GUID guid;
361
362 printf("Advertise Info\n");
363 printf("--------------\n\n");
364 printf("msi string = %s\n", szp->bufA);
365
366 if (base85_to_guid(szp->bufA, &guid))
367 prod_str = get_guid_str(&guid);
368 else
369 prod_str = "?";
370
371 comp = &szp->bufA[20];
372 feat = strchr(comp, '>');
373 if (!feat)
374 feat = strchr(comp, '<');
375 if (feat)
376 {
377 memcpy(comp_str, comp, feat - comp);
378 comp_str[feat-comp] = 0;
379 }
380 else
381 {
382 strcpy(comp_str, "?");
383 }
384
385 if (feat && feat[0] == '>' && base85_to_guid( &feat[1], &guid ))
386 feat_str = get_guid_str( &guid );
387 else
388 feat_str = "";
389
390 printf(" product: %s\n", prod_str);
391 printf(" component: %s\n", comp_str );
392 printf(" feature: %s\n", feat_str);
393 printf("\n");
394 }
395
396 static void dump_property_storage_value(const LINK_PROPERTYSTORAGE_VALUE *lnk_value_hdr,
397 DWORD data_size)
398 {
399 BOOL got_terminator = FALSE;
400 int i, value_size;
401 const unsigned char *value;
402
403 while (data_size >= sizeof(DWORD))
404 {
405 if (!lnk_value_hdr->size)
406 {
407 got_terminator = TRUE;
408 break;
409 }
410
411 if (lnk_value_hdr->size > data_size || lnk_value_hdr->size < sizeof(*lnk_value_hdr))
412 {
413 printf(" size: %d (invalid)\n", lnk_value_hdr->size);
414 return;
415 }
416
417 printf(" pid: %d\n", lnk_value_hdr->pid);
418 printf(" unknown8: %d\n", lnk_value_hdr->unknown8);
419 printf(" vartype: %d\n", lnk_value_hdr->vt);
420 printf(" unknown25: %d\n", lnk_value_hdr->unknown25);
421
422 value_size = lnk_value_hdr->size - sizeof(*lnk_value_hdr);
423 value = (const unsigned char*)(lnk_value_hdr+1);
424
425 printf(" value (%2d bytes) : ",value_size);
426 for(i=0; i<value_size; i++)
427 printf("%02x ",value[i]);
428 printf("\n\n");
429
430 data_size -= lnk_value_hdr->size;
431 lnk_value_hdr = (void*)((char*)lnk_value_hdr + lnk_value_hdr->size);
432 }
433
434 if (!got_terminator)
435 printf(" missing terminator!\n");
436 }
437
438 static void dump_property_storage(const DATABLOCK_HEADER* bhdr)
439 {
440 int data_size;
441 const LINK_PROPERTYSTORAGE_GUID *lnk_guid_hdr;
442 BOOL got_terminator = FALSE;
443
444 printf("Property Storage\n");
445 printf("--------------\n\n");
446
447 data_size=bhdr->cbSize-sizeof(*bhdr);
448
449 lnk_guid_hdr=(void*)((const char*)bhdr+sizeof(*bhdr));
450
451 while (data_size >= sizeof(DWORD))
452 {
453 if (!lnk_guid_hdr->size)
454 {
455 got_terminator = TRUE;
456 break;
457 }
458
459 if (lnk_guid_hdr->size > data_size || lnk_guid_hdr->size < sizeof(*lnk_guid_hdr))
460 {
461 printf("size: %d (invalid)\n", lnk_guid_hdr->size);
462 return;
463 }
464
465 if (lnk_guid_hdr->magic != 0x53505331)
466 printf("magic: %x\n", lnk_guid_hdr->magic);
467
468 printf("fmtid: %s\n", get_guid_str(&lnk_guid_hdr->fmtid));
469
470 dump_property_storage_value((void*)(lnk_guid_hdr + 1), lnk_guid_hdr->size - sizeof(*lnk_guid_hdr));
471
472 data_size -= lnk_guid_hdr->size;
473
474 lnk_guid_hdr = (void*)((char*)lnk_guid_hdr + lnk_guid_hdr->size);
475 }
476
477 if (!got_terminator)
478 printf("missing terminator!\n");
479
480 printf("\n");
481 }
482
483 static void dump_raw_block(const DATABLOCK_HEADER* bhdr)
484 {
485 int data_size;
486
487 printf("Raw Block\n");
488 printf("---------\n\n");
489 printf("size = %d\n", bhdr->cbSize);
490 printf("magic = %x\n", bhdr->dwSignature);
491
492 data_size=bhdr->cbSize-sizeof(*bhdr);
493 if (data_size > 0)
494 {
495 int i;
496 const unsigned char *data;
497
498 printf("data = ");
499 data=(const unsigned char*)bhdr+sizeof(*bhdr);
500 while (data_size > 0)
501 {
502 for (i=0; i < 16; i++)
503 {
504 if (i < data_size)
505 printf("%02x ", data[i]);
506 else
507 printf(" ");
508 }
509 for (i=0; i < data_size && i < 16; i++)
510 printf("%c", (data[i] >= 32 && data[i] < 128 ? data[i] : '.'));
511 printf("\n");
512 data_size-=16;
513 if (data_size <= 0)
514 break;
515 data+=16;
516 printf(" ");
517 }
518 }
519 printf("\n");
520 }
521
522 static const GUID CLSID_ShellLink = {0x00021401L, 0, 0, {0xC0,0,0,0,0,0,0,0x46}};
523
524 enum FileSig get_kind_lnk(void)
525 {
526 const LINK_HEADER* hdr;
527
528 hdr = PRD(0, sizeof(*hdr));
529 if (hdr && hdr->dwSize == sizeof(LINK_HEADER) &&
530 !memcmp(&hdr->MagicGuid, &CLSID_ShellLink, sizeof(GUID)))
531 return SIG_LNK;
532 return SIG_UNKNOWN;
533 }
534
535 void lnk_dump(void)
536 {
537 const LINK_HEADER* hdr;
538 const DATABLOCK_HEADER* bhdr;
539 DWORD dwFlags;
540
541 offset = 0;
542 hdr = fetch_block();
543 if (!hdr)
544 return;
545
546 printf("Header\n");
547 printf("------\n\n");
548 printf("Size: %04x\n", hdr->dwSize);
549 printf("GUID: %s\n", get_guid_str(&hdr->MagicGuid));
550
551 printf("FileAttr: %08x\n", hdr->dwFileAttr);
552 printf("FileLength: %08x\n", hdr->dwFileLength);
553 printf("nIcon: %d\n", hdr->nIcon);
554 printf("Startup: %d\n", hdr->fStartup);
555 printf("HotKey: %08x\n", hdr->wHotKey);
556 printf("Unknown5: %08x\n", hdr->Unknown5);
557 printf("Unknown6: %08x\n", hdr->Unknown6);
558
559 /* dump out all the flags */
560 printf("Flags: %04x ( ", hdr->dwFlags);
561 dwFlags=hdr->dwFlags;
562 #define FLAG(x) do \
563 { \
564 if (dwFlags & SLDF_##x) \
565 { \
566 printf("%s ", #x); \
567 dwFlags&=~SLDF_##x; \
568 } \
569 } while (0)
570 FLAG(HAS_ID_LIST);
571 FLAG(HAS_LINK_INFO);
572 FLAG(HAS_NAME);
573 FLAG(HAS_RELPATH);
574 FLAG(HAS_WORKINGDIR);
575 FLAG(HAS_ARGS);
576 FLAG(HAS_ICONLOCATION);
577 FLAG(UNICODE);
578 FLAG(FORCE_NO_LINKINFO);
579 FLAG(HAS_EXP_SZ);
580 FLAG(RUN_IN_SEPARATE);
581 FLAG(HAS_LOGO3ID);
582 FLAG(HAS_DARWINID);
583 FLAG(RUNAS_USER);
584 FLAG(HAS_EXP_ICON_SZ);
585 FLAG(NO_PIDL_ALIAS);
586 FLAG(FORCE_UNCNAME);
587 FLAG(RUN_WITH_SHIMLAYER);
588 FLAG(FORCE_NO_LINKTRACK);
589 FLAG(ENABLE_TARGET_METADATA);
590 FLAG(DISABLE_KNOWNFOLDER_RELATIVE_TRACKING);
591 FLAG(RESERVED);
592 #undef FLAG
593 if (dwFlags)
594 printf("+%04x", dwFlags);
595 printf(")\n");
596
597 printf("Length: %04x\n", hdr->dwFileLength);
598 printf("\n");
599
600 if (hdr->dwFlags & SLDF_HAS_ID_LIST)
601 dump_pidl();
602 if (hdr->dwFlags & SLDF_HAS_LINK_INFO)
603 dump_location();
604 if (hdr->dwFlags & SLDF_HAS_NAME)
605 dump_string("Description", hdr->dwFlags & SLDF_UNICODE);
606 if (hdr->dwFlags & SLDF_HAS_RELPATH)
607 dump_string("Relative path", hdr->dwFlags & SLDF_UNICODE);
608 if (hdr->dwFlags & SLDF_HAS_WORKINGDIR)
609 dump_string("Working directory", hdr->dwFlags & SLDF_UNICODE);
610 if (hdr->dwFlags & SLDF_HAS_ARGS)
611 dump_string("Arguments", hdr->dwFlags & SLDF_UNICODE);
612 if (hdr->dwFlags & SLDF_HAS_ICONLOCATION)
613 dump_string("Icon path", hdr->dwFlags & SLDF_UNICODE);
614
615 bhdr=fetch_block();
616 while (bhdr)
617 {
618 if (!bhdr->cbSize)
619 break;
620 switch (bhdr->dwSignature)
621 {
622 case EXP_SZ_LINK_SIG:
623 dump_sz_block(bhdr, "exp.link");
624 break;
625 case EXP_SPECIAL_FOLDER_SIG:
626 dump_special_folder_block(bhdr);
627 break;
628 case EXP_SZ_ICON_SIG:
629 dump_sz_block(bhdr, "icon");
630 break;
631 case EXP_DARWIN_ID_SIG:
632 dump_darwin_id(bhdr);
633 break;
634 case EXP_PROPERTYSTORAGE_SIG:
635 dump_property_storage(bhdr);
636 break;
637 default:
638 dump_raw_block(bhdr);
639 }
640 bhdr=fetch_block();
641 }
642 }
Windows API implementation