![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to module.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / drwatson|
Return to module.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / drwatson |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1993 Microsoft Corporation ! 4: ! 5: Module Name: ! 6: ! 7: module.c ! 8: ! 9: Abstract: ! 10: ! 11: This file implements the module load debug events. ! 12: ! 13: Author: ! 14: ! 15: Wesley Witt (wesw) 1-May-1993 ! 16: ! 17: Environment: ! 18: ! 19: User Mode ! 20: ! 21: --*/ ! 22: ! 23: #include <windows.h> ! 24: #include <stdlib.h> ! 25: #include <stdio.h> ! 26: #include <string.h> ! 27: ! 28: #include "drwatson.h" ! 29: #include "proto.h" ! 30: #include "messages.h" ! 31: ! 32: // ! 33: // defines for symbol (.dbg) file searching ! 34: // ! 35: #define SYMBOL_PATH "_NT_SYMBOL_PATH" ! 36: #define ALTERNATE_SYMBOL_PATH "_NT_ALT_SYMBOL_PATH" ! 37: ! 38: // ! 39: // local prototypes ! 40: // ! 41: void ExtractDebugInfoFromImage( PMODULEINFO mi ); ! 42: LPSTR GetSymbolSearchPath( void ); ! 43: BOOL NormalizeFilename( char *szName ); ! 44: HANDLE FindDebugInfoFile( LPSTR FileName, LPSTR SymbolPath, LPSTR DebugFilePath ); ! 45: BOOL SearchTreeForFile(LPSTR RootPath,PCHAR InputPathName,PCHAR OutputPathBuffer); ! 46: BOOL GetDebugInfoFromDbg( PMODULEINFO mi, PUCHAR fptr ); ! 47: BOOL GetDebugInfoFromExe( PMODULEINFO mi, PUCHAR fptr ); ! 48: PMODULEINFO AllocMi( PDEBUGPACKET dp ); ! 49: ! 50: ! 51: ! 52: BOOL ! 53: ProcessModuleLoad ( PDEBUGPACKET dp, LPDEBUG_EVENT de ) ! 54: ! 55: /*++ ! 56: ! 57: Routine Description: ! 58: ! 59: Process all module load debug events, create process & dll load. ! 60: The purpose is to allocate a MODULEINFO structure, fill in the ! 61: necessary values, and load the symbol table. ! 62: ! 63: Arguments: ! 64: ! 65: dp - pointer to a debug packet ! 66: de - pointer to a debug event structure ! 67: ! 68: Return Value: ! 69: ! 70: TRUE - everything worked ! 71: FALSE - we're hosed ! 72: ! 73: --*/ ! 74: ! 75: { ! 76: HANDLE hFile = NULL; ! 77: DWORD len = 0; ! 78: DWORD li = 0; ! 79: LPSTR lpSymbolPath = NULL; ! 80: LPSTR DebugFilePath = NULL; ! 81: PIMAGE_DOS_HEADER dosHdr = NULL; ! 82: PIMAGE_NT_HEADERS ntHdr = NULL; ! 83: PIMAGE_FILE_HEADER fileHdr = NULL; ! 84: PIMAGE_OPTIONAL_HEADER optHdr = NULL; ! 85: HANDLE hMap = NULL; ! 86: PUCHAR fptr = NULL; ! 87: DWORD rva = 0; ! 88: DWORD i = 0; ! 89: DWORD numDebugDirs = 0; ! 90: PIMAGE_DEBUG_DIRECTORY debugDir = NULL; ! 91: PIMAGE_SECTION_HEADER sh = NULL; ! 92: PMODULEINFO mi = NULL; ! 93: DWORD dwSize = 0; ! 94: PIMAGE_DEBUG_MISC miscData = NULL; ! 95: LPSTR pExeName = NULL; ! 96: PIMAGE_DEBUG_DIRECTORY miscDir = NULL; ! 97: char buf [MAX_PATH]; ! 98: ! 99: ! 100: // ! 101: // allocate a moduleinfo structure ! 102: // ! 103: mi = AllocMi( dp ); ! 104: if (mi == NULL) { ! 105: return FALSE; ! 106: } ! 107: ! 108: // ! 109: // setup the debug event specific values ! 110: // ! 111: if (de->dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT) { ! 112: hFile = de->u.CreateProcessInfo.hFile; ! 113: dp->hProcess = de->u.CreateProcessInfo.hProcess; ! 114: dp->dwProcessId = de->dwProcessId; ! 115: mi->dwLoadAddress = (DWORD)de->u.CreateProcessInfo.lpBaseOfImage; ! 116: } ! 117: else ! 118: if (de->dwDebugEventCode == LOAD_DLL_DEBUG_EVENT) { ! 119: hFile = de->u.LoadDll.hFile; ! 120: mi->dwLoadAddress = (DWORD)de->u.LoadDll.lpBaseOfDll; ! 121: } ! 122: ! 123: // ! 124: // map the input file (exe or dll) ! 125: // ! 126: hMap = CreateFileMapping( hFile, ! 127: NULL, ! 128: PAGE_READONLY, ! 129: 0, ! 130: 0, ! 131: NULL ! 132: ); ! 133: ! 134: if (hMap == INVALID_HANDLE_VALUE) { ! 135: return FALSE; ! 136: } ! 137: ! 138: fptr = MapViewOfFile( hMap, FILE_MAP_READ, 0, 0, 0 ); ! 139: ! 140: if (fptr == NULL) { ! 141: return FALSE; ! 142: } ! 143: ! 144: // ! 145: // next, setup the pointers to the necessary header for access to the ! 146: // miscellaneous debug directory ! 147: // ! 148: dosHdr = (PIMAGE_DOS_HEADER) fptr; ! 149: if (dosHdr->e_magic != IMAGE_DOS_SIGNATURE) { ! 150: return FALSE; ! 151: } ! 152: ntHdr = (PIMAGE_NT_HEADERS) ((DWORD)dosHdr->e_lfanew + (DWORD)fptr); ! 153: fileHdr = &ntHdr->FileHeader; ! 154: optHdr = &ntHdr->OptionalHeader; ! 155: ! 156: mi->dwImageSize = optHdr->SizeOfImage; ! 157: ! 158: if (optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size > 0) { ! 159: ! 160: // ! 161: // find the section header that contains the debug directories ! 162: // ! 163: rva = optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress; ! 164: ! 165: numDebugDirs = optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size / ! 166: sizeof(IMAGE_DEBUG_DIRECTORY); ! 167: ! 168: sh = IMAGE_FIRST_SECTION( ntHdr ); ! 169: ! 170: for (li=0; li<ntHdr->FileHeader.NumberOfSections; li++, sh++) { ! 171: if (rva >= sh->VirtualAddress && ! 172: rva < sh->VirtualAddress+sh->SizeOfRawData) { ! 173: break; ! 174: } ! 175: } ! 176: ! 177: // ! 178: // set the debugdir pointer to the first debug directory ! 179: // ! 180: debugDir = (PIMAGE_DEBUG_DIRECTORY) ( rva - sh->VirtualAddress + ! 181: sh->PointerToRawData + ! 182: fptr ! 183: ); ! 184: ! 185: // ! 186: // cruise thru all of the debug directories looking for the ! 187: // miscellaneous debug directory ! 188: // ! 189: for (li=0; li<numDebugDirs; li++, debugDir++) { ! 190: switch(debugDir->Type) { ! 191: case IMAGE_DEBUG_TYPE_FPO: ! 192: LoadFpoData( mi, ! 193: (PFPO_DATA)(debugDir->PointerToRawData + fptr), ! 194: debugDir->SizeOfData ! 195: ); ! 196: break; ! 197: ! 198: case IMAGE_DEBUG_TYPE_MISC: ! 199: // ! 200: // now, look for the data type containing the image name ! 201: // ! 202: miscData = (PIMAGE_DEBUG_MISC) (debugDir->PointerToRawData + ! 203: (DWORD)fptr); ! 204: li = debugDir->SizeOfData; ! 205: do { ! 206: if (miscData->DataType == IMAGE_DEBUG_MISC_EXENAME) { ! 207: strcpy( mi->szName, (LPSTR)miscData->Data ); ! 208: break; ! 209: } ! 210: li -= miscData->Length; ! 211: miscData = (PIMAGE_DEBUG_MISC) ( (DWORD)miscData + ! 212: miscData->Length); ! 213: } while (li > 0); ! 214: break; ! 215: ! 216: default: ! 217: break; ! 218: } ! 219: } ! 220: } ! 221: ! 222: // ! 223: // now find the pdata table, if there is one ! 224: // this is mips only, but it's ok to do it in this function ! 225: // because there won't be a pdata section on x86. ! 226: // ! 227: sh = IMAGE_FIRST_SECTION( ntHdr ); ! 228: ! 229: for (i=0; i<fileHdr->NumberOfSections; i++, sh++) { ! 230: if (strcmp(".pdata", sh->Name) == 0){ ! 231: LoadExceptionData( mi, ! 232: (PRUNTIME_FUNCTION)(sh->PointerToRawData+fptr), ! 233: sh->SizeOfRawData ! 234: ); ! 235: break; ! 236: } ! 237: } ! 238: ! 239: if (ntHdr->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) { ! 240: ! 241: // ! 242: // the characteristics are marked as having the symbols stripped ! 243: // so we must close the file handles and locate the .dbg file ! 244: // ! 245: CloseHandle( hMap ); ! 246: CloseHandle( hFile ); ! 247: ! 248: // ! 249: // get the path to use for searching for the .dbg file ! 250: // ! 251: lpSymbolPath = GetSymbolSearchPath(); ! 252: ! 253: // ! 254: // find the .dbg file and open it ! 255: // ! 256: buf[0] = '\0'; ! 257: hFile = FindDebugInfoFile( mi->szName, lpSymbolPath, buf ); ! 258: ! 259: if (hFile == NULL) { ! 260: lprintf( MSG_CANT_ACCESS_IMAGE, mi->szName ); ! 261: return FALSE; ! 262: } ! 263: ! 264: // ! 265: // map the .dbg file ! 266: // ! 267: hMap = CreateFileMapping( hFile, ! 268: NULL, ! 269: PAGE_READONLY, ! 270: 0, ! 271: 0, ! 272: NULL ! 273: ); ! 274: ! 275: if (hMap == INVALID_HANDLE_VALUE) { ! 276: return FALSE; ! 277: } ! 278: ! 279: fptr = MapViewOfFile( hMap, FILE_MAP_READ, 0, 0, 0 ); ! 280: ! 281: if (fptr == NULL) { ! 282: return FALSE; ! 283: } ! 284: ! 285: // ! 286: // get the debug information from the exe file ! 287: // ! 288: if (!GetDebugInfoFromDbg( mi, fptr )) { ! 289: return FALSE; ! 290: } ! 291: } ! 292: else { ! 293: // ! 294: // get the debug information from the dbg file ! 295: // ! 296: if (!GetDebugInfoFromExe( mi, fptr )) { ! 297: return FALSE; ! 298: } ! 299: } ! 300: ! 301: // ! 302: // close all file handles ! 303: // ! 304: CloseHandle( hMap ); ! 305: CloseHandle( hFile ); ! 306: ! 307: if (mi->szName[0] == 0) { ! 308: // ! 309: // we could not the image name so use the default ! 310: // ! 311: if (de->dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT) { ! 312: dwSize = sizeof(mi->szName); ! 313: GetTaskName( de->dwProcessId, mi->szName, &dwSize ); ! 314: } ! 315: else ! 316: if (de->dwDebugEventCode == LOAD_DLL_DEBUG_EVENT) { ! 317: strcpy( mi->szName, "app.dll" ); ! 318: } ! 319: } ! 320: else { ! 321: // ! 322: // put the path name & drive in the file name ! 323: // ! 324: NormalizeFilename( mi->szName ); ! 325: } ! 326: ! 327: return TRUE; ! 328: } ! 329: ! 330: BOOL ! 331: GetDebugInfoFromExe( PMODULEINFO mi, PUCHAR fptr ) ! 332: ! 333: /*++ ! 334: ! 335: Routine Description: ! 336: ! 337: Loads all of the appropriate debug information from an EXE/DLL file. ! 338: ! 339: Arguments: ! 340: ! 341: mi - pointer to a module information structure ! 342: fptr - base address of the EXE/DLL file ! 343: ! 344: Return Value: ! 345: ! 346: TRUE - everything worked ! 347: FALSE - we're hosed ! 348: ! 349: --*/ ! 350: ! 351: { ! 352: DWORD i = 0; ! 353: DWORD li = 0; ! 354: DWORD rva = 0; ! 355: DWORD numDebugDirs = 0; ! 356: PIMAGE_DEBUG_DIRECTORY debugDir = NULL; ! 357: PIMAGE_SECTION_HEADER sh = NULL; ! 358: PIMAGE_DOS_HEADER dosHdr = NULL; ! 359: PIMAGE_NT_HEADERS ntHdr = NULL; ! 360: PIMAGE_FILE_HEADER fileHdr = NULL; ! 361: PIMAGE_OPTIONAL_HEADER optHdr = NULL; ! 362: PUCHAR stringTable = NULL; ! 363: PIMAGE_SYMBOL allSymbols = NULL; ! 364: PIMAGE_DEBUG_DIRECTORY coffDir = NULL; ! 365: PIMAGE_DEBUG_DIRECTORY cvDir = NULL; ! 366: PIMAGE_EXPORT_DIRECTORY exportDir = NULL; ! 367: PUCHAR exportName = NULL; ! 368: ! 369: ! 370: // ! 371: // setup the image header pointers ! 372: // ! 373: dosHdr = (PIMAGE_DOS_HEADER) fptr; ! 374: if (dosHdr->e_magic != IMAGE_DOS_SIGNATURE) { ! 375: return FALSE; ! 376: } ! 377: ! 378: ntHdr = (PIMAGE_NT_HEADERS) ((DWORD)dosHdr->e_lfanew + (DWORD)fptr); ! 379: fileHdr = &ntHdr->FileHeader; ! 380: optHdr = &ntHdr->OptionalHeader; ! 381: ! 382: mi->dwImageSize = optHdr->SizeOfImage; ! 383: ! 384: if (!(fileHdr->Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE)) { ! 385: return FALSE; ! 386: } ! 387: ! 388: // ! 389: // establish the COFF symbol table pointers ! 390: // ! 391: if (fileHdr->PointerToSymbolTable > 0 || fileHdr->NumberOfSymbols > 0) { ! 392: stringTable = fileHdr->PointerToSymbolTable + fptr + ! 393: (IMAGE_SIZEOF_SYMBOL * fileHdr->NumberOfSymbols); ! 394: allSymbols = (PIMAGE_SYMBOL) (fileHdr->PointerToSymbolTable + fptr); ! 395: } ! 396: ! 397: if (optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size > 0) { ! 398: ! 399: // ! 400: // find the section header that the debug directories are in ! 401: // ! 402: rva = optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress; ! 403: ! 404: numDebugDirs = optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size / ! 405: sizeof(IMAGE_DEBUG_DIRECTORY); ! 406: if (numDebugDirs == 0) { ! 407: return FALSE; ! 408: } ! 409: ! 410: sh = IMAGE_FIRST_SECTION( ntHdr ); ! 411: ! 412: for (i=0; i<fileHdr->NumberOfSections; i++, sh++) { ! 413: if (rva >= sh->VirtualAddress && ! 414: rva < sh->VirtualAddress+sh->SizeOfRawData) { ! 415: break; ! 416: } ! 417: } ! 418: ! 419: debugDir = (PIMAGE_DEBUG_DIRECTORY) ( rva - sh->VirtualAddress + ! 420: sh->PointerToRawData + ! 421: fptr ! 422: ); ! 423: ! 424: // ! 425: // process each debug directory ! 426: // ! 427: for (li=0; li<numDebugDirs; li++, debugDir++) { ! 428: switch(debugDir->Type) { ! 429: case IMAGE_DEBUG_TYPE_COFF: ! 430: coffDir = debugDir; ! 431: break; ! 432: ! 433: case IMAGE_DEBUG_TYPE_CODEVIEW: ! 434: cvDir = debugDir; ! 435: break; ! 436: ! 437: case IMAGE_DEBUG_TYPE_FPO: ! 438: LoadFpoData( mi, ! 439: (PFPO_DATA)(debugDir->PointerToRawData + fptr), ! 440: debugDir->SizeOfData ! 441: ); ! 442: break; ! 443: ! 444: default: ! 445: break; ! 446: } ! 447: } ! 448: ! 449: if (cvDir != NULL) { ! 450: LoadCodeViewSymbols( mi, ! 451: cvDir->PointerToRawData + fptr, ! 452: IMAGE_FIRST_SECTION( ntHdr ), ! 453: fileHdr->NumberOfSections ! 454: ); ! 455: } ! 456: else ! 457: if (coffDir != NULL) { ! 458: LoadCoffSymbols( mi, ! 459: stringTable, ! 460: allSymbols, ! 461: fileHdr->NumberOfSymbols ! 462: ); ! 463: } ! 464: } ! 465: ! 466: // ! 467: // now find the exports table, if there is one ! 468: // ! 469: rva = optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress; ! 470: ! 471: sh = IMAGE_FIRST_SECTION( ntHdr ); ! 472: ! 473: // ! 474: // Find the section the where the export table is located in ! 475: // ! 476: for (i=0; i<fileHdr->NumberOfSections; i++, sh++) { ! 477: if (rva >= sh->VirtualAddress && ! 478: rva < sh->VirtualAddress+sh->SizeOfRawData) { ! 479: break; ! 480: } ! 481: } ! 482: ! 483: // ! 484: // is there an export table ? ! 485: // ! 486: if (i != fileHdr->NumberOfSections) { ! 487: exportDir = (PIMAGE_EXPORT_DIRECTORY) ( rva - ! 488: (DWORD)sh->VirtualAddress + ! 489: sh->PointerToRawData + ! 490: (DWORD)fptr ); ! 491: ! 492: exportName = (PUCHAR) ( exportDir->Name - ! 493: (DWORD)sh->VirtualAddress + ! 494: sh->PointerToRawData + ! 495: (DWORD)fptr ); ! 496: ! 497: if (mi->szName[0] == '\0') { ! 498: strcpy( mi->szName, exportName ); ! 499: } ! 500: } ! 501: ! 502: return TRUE; ! 503: } ! 504: ! 505: BOOL ! 506: GetDebugInfoFromDbg( PMODULEINFO mi, PUCHAR fptr ) ! 507: ! 508: /*++ ! 509: ! 510: Routine Description: ! 511: ! 512: Loads all of the appropriate debug information from a DBG file. ! 513: ! 514: Arguments: ! 515: ! 516: mi - pointer to a module information structure ! 517: fptr - base address of the EXE/DLL file ! 518: ! 519: Return Value: ! 520: ! 521: TRUE - everything worked ! 522: FALSE - we're hosed ! 523: ! 524: --*/ ! 525: ! 526: { ! 527: DWORD li = 0; ! 528: DWORD numDebugDirs = 0; ! 529: PIMAGE_DEBUG_DIRECTORY debugDir = NULL; ! 530: PIMAGE_SECTION_HEADER sh = NULL; ! 531: PIMAGE_SEPARATE_DEBUG_HEADER sdh = NULL; ! 532: PIMAGE_COFF_SYMBOLS_HEADER coffSymHead = NULL; ! 533: PUCHAR stringTable = NULL; ! 534: PIMAGE_SYMBOL allSymbols = NULL; ! 535: PIMAGE_DEBUG_DIRECTORY coffDir = NULL; ! 536: PIMAGE_DEBUG_DIRECTORY cvDir = NULL; ! 537: ! 538: ! 539: // ! 540: // setup the basic image pointers ! 541: // ! 542: sdh = (PIMAGE_SEPARATE_DEBUG_HEADER) fptr; ! 543: sh = (PIMAGE_SECTION_HEADER) (sdh + 1); ! 544: debugDir = (PIMAGE_DEBUG_DIRECTORY)((DWORD)((DWORD)sh + (sdh->NumberOfSections*IMAGE_SIZEOF_SECTION_HEADER)) + sdh->ExportedNamesSize); ! 545: ! 546: mi->dwImageSize = sdh->SizeOfImage; ! 547: ! 548: if (sdh->DebugDirectorySize > 0) { ! 549: ! 550: // ! 551: // process each debug directory ! 552: // ! 553: numDebugDirs = sdh->DebugDirectorySize / sizeof(IMAGE_DEBUG_DIRECTORY); ! 554: if (numDebugDirs == 0) { ! 555: return FALSE; ! 556: } ! 557: ! 558: for (li=0; li<numDebugDirs; li++, debugDir++) { ! 559: switch(debugDir->Type) { ! 560: case IMAGE_DEBUG_TYPE_COFF: ! 561: coffDir = debugDir; ! 562: break; ! 563: ! 564: case IMAGE_DEBUG_TYPE_CODEVIEW: ! 565: cvDir = debugDir; ! 566: break; ! 567: ! 568: case IMAGE_DEBUG_TYPE_FPO: ! 569: LoadFpoData( mi, ! 570: (PFPO_DATA)(debugDir->PointerToRawData + fptr), ! 571: debugDir->SizeOfData ! 572: ); ! 573: break; ! 574: ! 575: case IMAGE_DEBUG_TYPE_EXCEPTION: ! 576: if (debugDir->SizeOfData > 0) { ! 577: LoadExceptionData( mi, ! 578: (PRUNTIME_FUNCTION)(debugDir->PointerToRawData+fptr), ! 579: debugDir->SizeOfData ); ! 580: } ! 581: break; ! 582: ! 583: default: ! 584: break; ! 585: } ! 586: } ! 587: } ! 588: ! 589: if (cvDir != NULL) { ! 590: LoadCodeViewSymbols( mi, ! 591: cvDir->PointerToRawData + fptr, ! 592: sh, ! 593: sdh->NumberOfSections ! 594: ); ! 595: } ! 596: else ! 597: if (coffDir != NULL) { ! 598: // ! 599: // setup the COFF symbol table pointers & load the COFF symbol table ! 600: // ! 601: coffSymHead = (PIMAGE_COFF_SYMBOLS_HEADER)(coffDir->PointerToRawData + fptr); ! 602: allSymbols = (PIMAGE_SYMBOL) ( (DWORD)coffSymHead + ! 603: coffSymHead->LvaToFirstSymbol ! 604: ); ! 605: stringTable = (PUCHAR)((DWORD)allSymbols + ! 606: (IMAGE_SIZEOF_SYMBOL * coffSymHead->NumberOfSymbols)); ! 607: LoadCoffSymbols( mi, ! 608: stringTable, ! 609: allSymbols, ! 610: coffSymHead->NumberOfSymbols ! 611: ); ! 612: } ! 613: ! 614: return TRUE; ! 615: } ! 616: ! 617: LPSTR ! 618: GetSymbolSearchPath( void ) ! 619: ! 620: /*++ ! 621: ! 622: Routine Description: ! 623: ! 624: Gets the search path to be used for locating a .DBG file. ! 625: ! 626: Arguments: ! 627: ! 628: None. ! 629: ! 630: Return Value: ! 631: ! 632: pointer to the path string ! 633: ! 634: --*/ ! 635: ! 636: { ! 637: LPSTR lpSymPathEnv = NULL; ! 638: LPSTR lpAltSymPathEnv = NULL; ! 639: LPSTR lpSystemRootEnv = NULL; ! 640: LPSTR SymbolSearchPath = NULL; ! 641: DWORD cbSymPath = 0; ! 642: ! 643: cbSymPath = 16; ! 644: if (lpSymPathEnv = getenv(SYMBOL_PATH)) { ! 645: cbSymPath += strlen(lpSymPathEnv) + 1; ! 646: } ! 647: if (lpAltSymPathEnv = getenv(ALTERNATE_SYMBOL_PATH)) { ! 648: cbSymPath += strlen(lpAltSymPathEnv) + 1; ! 649: } ! 650: if (lpSystemRootEnv = getenv("SystemRoot")) { ! 651: cbSymPath += strlen(lpSystemRootEnv) + 1; ! 652: } ! 653: ! 654: SymbolSearchPath = calloc(cbSymPath,1); ! 655: ! 656: if (lpAltSymPathEnv) { ! 657: strcat(SymbolSearchPath,lpAltSymPathEnv); ! 658: strcat(SymbolSearchPath,";"); ! 659: } ! 660: if (lpSymPathEnv) { ! 661: strcat(SymbolSearchPath,lpSymPathEnv); ! 662: strcat(SymbolSearchPath,";"); ! 663: } ! 664: if (lpSystemRootEnv) { ! 665: strcat(SymbolSearchPath,lpSystemRootEnv); ! 666: strcat(SymbolSearchPath,";"); ! 667: } ! 668: return SymbolSearchPath; ! 669: } ! 670: ! 671: BOOL ! 672: NormalizeFilename( char *szName ) ! 673: ! 674: /*++ ! 675: ! 676: Routine Description: ! 677: ! 678: Prefixes the base name passed in by szName with the fully qualified ! 679: path name of the file. ! 680: ! 681: Arguments: ! 682: ! 683: szName - buffer for the file name ! 684: ! 685: Return Value: ! 686: ! 687: TRUE - file name contains the path & base name ! 688: FALSE - file name contains the base name only ! 689: ! 690: --*/ ! 691: ! 692: { ! 693: DWORD rc = 0; ! 694: LPSTR lpszFilePart = NULL; ! 695: char szDrive [_MAX_DRIVE]; ! 696: char szDir [_MAX_DIR]; ! 697: char szFname [_MAX_FNAME]; ! 698: char szExt [_MAX_EXT]; ! 699: char buf [4096]; ! 700: char szFullPath [4096]; ! 701: ! 702: ! 703: // ! 704: // split the filename apart ! 705: // ! 706: _splitpath( szName, szDrive, szDir, szFname, szExt ); ! 707: ! 708: // ! 709: // create a base file name excluding any possible path ! 710: // ! 711: wsprintf( buf, "%s%s", szFname, szExt ); ! 712: ! 713: // ! 714: // create a full path name to the file based on our current ! 715: // working directory. this is done so that we can check the ! 716: // current directory before looking along the path env variable. ! 717: // ! 718: _fullpath( szFullPath, buf, sizeof(szFullPath) ); ! 719: ! 720: // ! 721: // split the path apart so the constituent parts can be used ! 722: // by the next call to searchpath ! 723: // ! 724: _splitpath( szFullPath, szDrive, szDir, szFname, szExt ); ! 725: ! 726: // ! 727: // look in the current working directory for the file ! 728: // ! 729: rc = SearchPath( szDir, szFname, szExt, sizeof(buf), buf, &lpszFilePart ); ! 730: if (rc > 0) { ! 731: // ! 732: // found it so copy the filename and exit ! 733: // ! 734: strcpy( szName, buf ); ! 735: return TRUE; ! 736: } ! 737: ! 738: // ! 739: // now look along the path environment variable for the filename ! 740: // ! 741: rc = SearchPath( NULL, szFname, szExt, sizeof(buf), buf, &lpszFilePart ); ! 742: if (rc > 0) { ! 743: // ! 744: // found it so copy the filename and exit ! 745: // ! 746: strcpy( szName, buf ); ! 747: return TRUE; ! 748: } ! 749: ! 750: // ! 751: // could not file the file anywhere so create a base filename ! 752: // and return ! 753: // ! 754: wsprintf( szName, "%s%s", szFname, szExt ); ! 755: return FALSE; ! 756: } ! 757: ! 758: HANDLE ! 759: FindDebugInfoFile( LPSTR FileName, LPSTR SymbolPath, LPSTR DebugFilePath ) ! 760: ! 761: /*++ ! 762: ! 763: Routine Description: ! 764: ! 765: Locates a .DBG file based on the FileName and the SymbolPath. ! 766: ! 767: Arguments: ! 768: ! 769: FileName - base EXE/DLL file name ! 770: SymbolPath - path to search for the .DBG file ! 771: DebugFilePath - buffer for .DBG file name ! 772: ! 773: Return Value: ! 774: ! 775: not NULL - a valid handle to a .DBG file ! 776: NULL - could not find the .DBG file ! 777: ! 778: --*/ ! 779: ! 780: { ! 781: HANDLE FileHandle; ! 782: LPSTR s, BaseName, Extension; ! 783: LPSTR Start, End; ! 784: UCHAR DirectoryPath[ MAX_PATH ]; ! 785: ! 786: BaseName = strcpy( DebugFilePath, FileName ); ! 787: BaseName += strlen( BaseName ); ! 788: while (BaseName > DebugFilePath) { ! 789: if (*--BaseName == '\\' || *BaseName == '/' || *BaseName == ':') { ! 790: BaseName += 1; ! 791: break; ! 792: } ! 793: } ! 794: if (!(Extension = strrchr( BaseName, '.' ))) { ! 795: Extension = strchr( BaseName, '\0' ); ! 796: } ! 797: strcpy( Extension, ".DBG" ); ! 798: s = BaseName; ! 799: if (s > DebugFilePath) { ! 800: s -= 1; ! 801: } ! 802: ! 803: while (TRUE) { ! 804: FileHandle = CreateFile( DebugFilePath, ! 805: GENERIC_READ, ! 806: FILE_SHARE_READ | FILE_SHARE_WRITE, ! 807: NULL, ! 808: OPEN_EXISTING, ! 809: 0, ! 810: NULL ! 811: ); ! 812: if (FileHandle != INVALID_HANDLE_VALUE) { ! 813: return FileHandle; ! 814: } ! 815: ! 816: while (s > DebugFilePath) { ! 817: if (*--s == '\\' || *s == '/' || *s == ':') { ! 818: break; ! 819: } ! 820: } ! 821: ! 822: if (s == DebugFilePath) { ! 823: break; ! 824: } ! 825: ! 826: strcpy( s, "\\Symbols\\" ); ! 827: strcat( s, BaseName ); ! 828: } ! 829: ! 830: Start = SymbolPath; ! 831: while (Start && *Start != '\0') { ! 832: if (End = strchr( Start, ';' )) { ! 833: strncpy( DirectoryPath, Start, End - Start ); ! 834: DirectoryPath[ End - Start ] = '\0'; ! 835: End += 1; ! 836: } ! 837: else { ! 838: strcpy( DirectoryPath, Start ); ! 839: } ! 840: ! 841: if (SearchTreeForFile( DirectoryPath, BaseName, DebugFilePath )) { ! 842: FileHandle = CreateFile( DebugFilePath, ! 843: GENERIC_READ, ! 844: FILE_SHARE_READ | FILE_SHARE_WRITE, ! 845: NULL, ! 846: OPEN_EXISTING, ! 847: 0, ! 848: NULL ! 849: ); ! 850: if (FileHandle != INVALID_HANDLE_VALUE) { ! 851: return FileHandle; ! 852: } ! 853: } ! 854: ! 855: Start = End; ! 856: } ! 857: ! 858: return NULL; ! 859: } ! 860: ! 861: #define MAX_DEPTH 32 ! 862: ! 863: BOOL ! 864: SearchTreeForFile( ! 865: LPSTR RootPath, ! 866: PCHAR InputPathName, ! 867: PCHAR OutputPathBuffer ! 868: ) ! 869: ! 870: /*++ ! 871: ! 872: Routine Description: ! 873: ! 874: Searches down the path(RootPath) for a file(InputPathName). ! 875: ! 876: Arguments: ! 877: ! 878: RootPath - path to search down ! 879: InputPathName - file name to look for ! 880: OutputPathBuffer - buffer for .DBG file name ! 881: ! 882: Return Value: ! 883: ! 884: TRUE - file found ! 885: FALSE - could not find the .DBG file ! 886: ! 887: --*/ ! 888: ! 889: { ! 890: PCHAR FileName; ! 891: PUCHAR Prefix = ""; ! 892: CHAR PathBuffer[ MAX_PATH ]; ! 893: ULONG Depth; ! 894: PCHAR PathTail[ MAX_DEPTH ]; ! 895: PCHAR FindHandle[ MAX_DEPTH ]; ! 896: LPWIN32_FIND_DATA FindFileData; ! 897: UCHAR FindFileBuffer[ MAX_PATH + sizeof( WIN32_FIND_DATA ) ]; ! 898: BOOL Result; ! 899: ! 900: strcpy( PathBuffer, RootPath ); ! 901: FileName = InputPathName; ! 902: while (*InputPathName) { ! 903: if (*InputPathName == ':' || *InputPathName == '\\' || *InputPathName == '/') { ! 904: FileName = ++InputPathName; ! 905: } ! 906: else { ! 907: InputPathName++; ! 908: } ! 909: } ! 910: FindFileData = (LPWIN32_FIND_DATA)FindFileBuffer; ! 911: Depth = 0; ! 912: Result = FALSE; ! 913: while (TRUE) { ! 914: startDirectorySearch: ! 915: PathTail[ Depth ] = strchr( PathBuffer, '\0' ); ! 916: if (PathTail[ Depth ] > PathBuffer && PathTail[ Depth ][ -1 ] != '\\') { ! 917: *(PathTail[ Depth ])++ = '\\'; ! 918: } ! 919: ! 920: strcpy( PathTail[ Depth ], "*.*" ); ! 921: FindHandle[ Depth ] = FindFirstFile( PathBuffer, FindFileData ); ! 922: if (FindHandle[ Depth ] != INVALID_HANDLE_VALUE) { ! 923: do { ! 924: if (FindFileData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { ! 925: if (strcmp( FindFileData->cFileName, "." ) && ! 926: strcmp( FindFileData->cFileName, ".." ) && ! 927: Depth < MAX_DEPTH ! 928: ) { ! 929: sprintf( PathTail[ Depth ], "%s\\", FindFileData->cFileName ); ! 930: Depth++; ! 931: goto startDirectorySearch; ! 932: } ! 933: } ! 934: else ! 935: if (!stricmp( FindFileData->cFileName, FileName )) { ! 936: strcpy( PathTail[ Depth ], FindFileData->cFileName ); ! 937: strcpy( OutputPathBuffer, PathBuffer ); ! 938: Result = TRUE; ! 939: } ! 940: ! 941: restartDirectorySearch: ! 942: if (Result) { ! 943: break; ! 944: } ! 945: } ! 946: while (FindNextFile( FindHandle[ Depth ], FindFileData )); ! 947: FindClose( FindHandle[ Depth ] ); ! 948: ! 949: if (Depth == 0) { ! 950: break; ! 951: } ! 952: ! 953: Depth--; ! 954: goto restartDirectorySearch; ! 955: } ! 956: } ! 957: ! 958: return Result; ! 959: } ! 960: ! 961: PMODULEINFO ! 962: AllocMi( PDEBUGPACKET dp ) ! 963: ! 964: /*++ ! 965: ! 966: Routine Description: ! 967: ! 968: Allocate a module information structure and link it in the ! 969: list of modules for this debugee. ! 970: ! 971: Arguments: ! 972: ! 973: dp - debug packet ! 974: ! 975: Return Value: ! 976: ! 977: pointer to module information structure ! 978: ! 979: --*/ ! 980: ! 981: { ! 982: PMODULEINFO mi; ! 983: ! 984: mi = (PMODULEINFO) malloc( sizeof(MODULEINFO) ); ! 985: if (mi == NULL) { ! 986: return NULL; ! 987: } ! 988: memset( mi, 0, sizeof(MODULEINFO) ); ! 989: ! 990: if (dp->miHead == NULL) { ! 991: dp->miHead = dp->miTail = mi; ! 992: } ! 993: else { ! 994: dp->miTail->next = mi; ! 995: dp->miTail = mi; ! 996: } ! 997: ! 998: return mi; ! 999: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.