![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symedit.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 / symedit|
Return to symedit.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / symedit |
1.1 root 1: /*++
2:
3:
4: Copyright (c) 1992 Microsoft Corporation
5:
6: Module Name:
7:
8: symedit.c
9:
10: Abstract:
11:
12:
13: Author:
14:
15: Wesley A. Witt (wesw) 19-April-1993
16:
17: Environment:
18:
19: Win32, User Mode
20:
21: --*/
22:
23: #include <windows.h>
24: #include <stdlib.h>
25: #include <stdio.h>
26: #include <string.h>
27:
28: #include "symcvt.h"
29: #include "cv.h"
30: #include "cofftocv.h"
31: #include "symtocv.h"
32: #include "strings.h"
33:
34: #include <imagehlp.h>
35:
36:
37: /*
38: * prototypes for this module
39: */
40:
41: BOOL CalculateOutputFilePointers( PIMAGEPOINTERS pi, PIMAGEPOINTERS po );
42: void ProcessCommandLineArgs( int argc, char *argv[] );
43: void PrintCopyright( void );
44: void PrintUsage( void );
45: void FatalError( int, ... );
46: BOOL MapOutputFile ( PPOINTERS p, char *fname, int );
47: void ComputeChecksum( char *szExeFile );
48: void ReadDebugInfo( PPOINTERS p );
49: void WriteDebugInfo( PPOINTERS p, BOOL, BOOL );
50: void MungeDebugHeadersCoffToCv( PPOINTERS p, BOOL fAddCV );
51: void MungeExeName( PPOINTERS p, char * szExeName );
52: void DoCoffToCv(char *, char *, BOOL);
53: void DoSymToCv(char *, char *, char *, char *);
54: void DoNameChange(char *, char *, char *);
55: void DoExtract(char *, char *, char *);
56: void DoStrip(char *, char *);
57:
58: IMAGE_DEBUG_DIRECTORY DbgDirSpare;
59: IMAGE_DEBUG_DIRECTORY DbgDirCoff;
60:
61: #define AdjustPtr(ptr) (((ptr) != NULL) ? ((DWORD)ptr - (DWORD)pi->fptr + (DWORD)po->fptr) : ((DWORD)(ptr)))
62:
63:
64:
65: int _CRTAPI1
66: main(
67: int argc,
68: char * argv[]
69: )
70: /*++
71:
72: Routine Description:
73:
74: Shell for this utility.
75:
76: Arguments:
77:
78: argc - argument count
79: argv - argument pointers
80:
81:
82: Return Value:
83:
84: 0 - image was converted
85: >0 - image could not be converted
86:
87: --*/
88:
89: {
90: /*
91: * Scan the command line and check what operations we are doing
92: */
93:
94: ProcessCommandLineArgs( argc, argv );
95: return 0;
96: }
97:
98: void
99: PrintCopyright( void )
100:
101: /*++
102:
103: Routine Description:
104:
105: Prints the MS copyright message to stdout.
106:
107: Arguments:
108:
109: void
110:
111:
112: Return Value:
113:
114: void
115:
116: --*/
117:
118: {
119: printf( "\nMicrosoft(R) Windows NT SymEdit Version 1.0\n" );
120: printf( "(C) 1989-1993 Microsoft Corp. All rights reserved.\n\n");
121: }
122:
123: void
124: PrintUsage( void )
125:
126: /*++
127:
128: Routine Description:
129:
130: Prints the command line help to stdout
131:
132: Arguments:
133:
134: void
135:
136:
137: Return Value:
138:
139: void
140:
141: --*/
142:
143: {
144: PrintCopyright();
145: printf("\nUsage: SYMEDIT <OPERATION> -q -o<file out> <file in>\n\n" );
146: printf("\t<OPERATION> is:\n");
147: printf("\tA\tAdd debug information\n");
148: printf("\tC\tConvert symbol information\n" );
149: printf("\tN\tEdit name field\n");
150: printf("\tX\tExtract debug information\n");
151: printf("\tS\tStrip all debug information\n\n");
152: printf("Options:\n");
153: printf("\t-a\t\tAdd CodeView debug info to file\n");
154: printf("\t-n<name>\tName to change to\n");
155: printf("\t-o<file>\tspecify output file\n" );
156: printf("\t-q\t\tquiet mode\n" );
157: printf("\t-s<file>\tSym file source\n");
158: }
159:
160: void
161: ProcessCommandLineArgs( int argc, char *argv[] )
162:
163: /*++
164:
165: Routine Description:
166:
167: Processes the command line arguments and sets global flags to
168: indicate the user's desired behavior.
169:
170: Arguments:
171:
172: argc - argument count
173: argv - argument pointers
174:
175:
176: Return Value:
177:
178: void
179:
180: --*/
181:
182: {
183: int i;
184: BOOL fQuiet = FALSE;
185: BOOL fSilent = FALSE;
186: char * szOutputFile = NULL;
187: char * szInputFile = NULL;
188: char * szExeName = NULL;
189: char * szDbgFile = NULL;
190: char * szSymFile = NULL;
191: int iOperation;
192: BOOLEAN fAddCV = FALSE;
193:
194: /*
195: * Minimun number of of arguments is 2 -- program and operation
196: */
197:
198: if (argc < 2) {
199: PrintUsage();
200: exit(1);
201: }
202:
203: if ((strcmp(argv[1], "-?") == 0) || (strcmp(argv[1], "?") == 0)) {
204: PrintUsage();
205: exit(1);
206: }
207:
208: /*
209: * All operations on 1 character wide
210: */
211:
212: if (argv[1][1] != 0) {
213: FatalError(ERR_OP_UNKNOWN, argv[1]);
214: }
215:
216: /*
217: * Validate the operation
218: */
219:
220: switch( argv[1][0] ) {
221: case 'C':
222: case 'N':
223: case 'X':
224: case 'S':
225: iOperation = argv[1][0];
226: break;
227: default:
228: FatalError(ERR_OP_UNKNOWN, argv[1]);
229: }
230:
231: /*
232: * Parse out any other switches on the command line
233: */
234:
235: for (i=2; i<argc; i++) {
236: if ((argv[i][0] == '-') || (argv[i][0] == '/')) {
237: switch (argv[i][1]) {
238: /*
239: * Add the CV debug information section rather than
240: * replace the COFF section with the CV info.
241: */
242: case 'a':
243: case 'A':
244: fAddCV = TRUE;
245: break;
246:
247: /*
248: * Specify the output name for the DBG file
249: */
250:
251: case 'd':
252: case 'D':
253: if (argv[i][2] == 0) {
254: i += 1;
255: szDbgFile = argv[i];
256: } else {
257: szDbgFile = &argv[i][2];
258: }
259: break;
260:
261: /*
262: * Specify a new name to shove into the name of the
263: * debuggee field in the Misc. Debug info field
264: */
265:
266: case 'N':
267: case 'n':
268: if (argv[i][2] == 0) {
269: i += 1;
270: szExeName = argv[i];
271: } else {
272: szExeName = &argv[i][2];
273: }
274: break;
275:
276: /*
277: * Specify the name of the output file
278: */
279:
280: case 'O':
281: case 'o':
282: if (argv[i][2] == 0) {
283: i += 1;
284: szOutputFile = argv[i];
285: } else {
286: szOutputFile = &argv[i][2];
287: }
288: break;
289:
290: /*
291: * Be quite and don't put out the banner
292: */
293:
294: case 'Q':
295: case 'q':
296: fQuiet = TRUE;
297: fSilent = TRUE;
298: break;
299:
300: /*
301: * Replace COFF debug information with CODEVIEW debug information
302: */
303:
304: case 'R':
305: case 'r':
306: break;
307:
308: /*
309: * Convert a Symbol File to CV info
310: */
311:
312: case 'S':
313: case 's':
314: if (argv[i][2] == 0) {
315: i += 1;
316: szSymFile = argv[i];
317: } else {
318: szSymFile = &argv[i][2];
319: }
320: break;
321:
322: /*
323: * Print the command line options
324: */
325:
326: case '?':
327: PrintUsage();
328: exit(1);
329: break;
330:
331: /*
332: * Unrecognized option
333: */
334:
335: default:
336: FatalError( ERR_OP_UNKNOWN, argv[i] );
337: break;
338: }
339: } else {
340: /*
341: * No leading switch character -- must be a file name
342: */
343:
344: szInputFile = &argv[i][0];
345:
346: /*
347: * Process the file(s)
348: */
349:
350: if (!fQuiet) {
351: PrintCopyright();
352: fQuiet = TRUE;
353: }
354:
355: if (!fSilent) {
356: printf("processing file: %s\n", szInputFile );
357: }
358:
359: /*
360: * Do switch validation cheching and setup any missing global variables
361: */
362:
363: switch ( iOperation ) {
364: /*
365: * Add debug information to an exe file
366: *
367: * Must specify in input file
368: * Optional outputfile
369: * Must specify a debug info file
370: */
371:
372: case 'A':
373: break;
374:
375: /*
376: * For conversions -- there are three types
377: *
378: * 1. Coff to CV -- add
379: * 2. Coff to CV -- replace
380: * 3. SYM to CV --- add
381: * 4. SYM to CV -- seperate file
382: *
383: * Optional input file (not needed for case 4)
384: * Optional output file
385: * Optional sym file (implys sym->CV)
386: * Optional DBG file
387: */
388:
389: case 'C':
390: if (szSymFile == NULL) {
391: DoCoffToCv(szInputFile, szOutputFile, fAddCV);
392: } else {
393: DoSymToCv(szInputFile, szOutputFile, szDbgFile, szSymFile);
394: }
395: szInputFile = NULL;
396: szOutputFile = NULL;
397: szDbgFile = NULL;
398: szSymFile = NULL;
399: break;
400:
401: /*
402: * For changing the name of the debuggee --
403: * Must specify input file
404: * Must specify new name
405: * Optional output file
406: */
407:
408: case 'N':
409: DoNameChange(szInputFile, szOutputFile, szExeName);
410: szInputFile = NULL;
411: szOutputFile = NULL;
412: szExeName = NULL;
413: break;
414:
415: /*
416: * For extraction of debug information
417: * Must specify input file
418: * Optional output file name
419: * Optional debug file name
420: */
421:
422: case 'X':
423: DoExtract(szInputFile, szOutputFile, szDbgFile);
424: break;
425:
426: /*
427: * For full strip of debug information
428: * Must specify input file
429: * Optional output file
430: * Optional debug file name
431: */
432:
433: case 'S':
434: DoStrip(szInputFile, szOutputFile);
435: break;
436: }
437: }
438: }
439: return;
440: } /* ProcessCommandLineArgs() */
441:
442:
443: void
444: ReadDebugInfo(
445: PPOINTERS p
446: )
447: /*++
448:
449: Routine Description:
450:
451: This function will go out and read in all of the debug information
452: into memory -- this is required because the input and output
453: files might be the same, if so then writing out informaiton may
454: destory data we need at a later time.
455:
456: Arguments:
457:
458: p - Supplies a pointer to the structure describing the debug info file
459:
460: Return Value:
461:
462: None.
463:
464: --*/
465:
466: {
467: int i;
468: int cb;
469: char * pb;
470: PIMAGE_COFF_SYMBOLS_HEADER pCoffDbgInfo;
471:
472:
473: /*
474: * Allocate space to save pointers to debug info
475: */
476:
477: p->iptrs.rgpbDebugSave = (PCHAR *) malloc(p->iptrs.cDebugDir * sizeof(PCHAR));
478: memset(p->iptrs.rgpbDebugSave, 0, p->iptrs.cDebugDir * sizeof(PCHAR));
479:
480: /*
481: * Check each possible debug type record
482: */
483:
484: for (i=0; i<p->iptrs.cDebugDir; i++) {
485: /*
486: * If there was debug information then copy over the
487: * description block and cache in the actual debug
488: * data.
489: */
490:
491: if ((i != IMAGE_DEBUG_TYPE_COFF) && (p->iptrs.rgDebugDir[i] != NULL)) {
492: p->iptrs.rgpbDebugSave[i] =
493: malloc( p->iptrs.rgDebugDir[i]->SizeOfData );
494: if (p->iptrs.rgpbDebugSave[i] == NULL) {
495: FatalError(ERR_NO_MEMORY);
496: }
497: _try {
498: memcpy(p->iptrs.rgpbDebugSave[i],
499: p->iptrs.fptr +
500: p->iptrs.rgDebugDir[i]->PointerToRawData,
501: p->iptrs.rgDebugDir[i]->SizeOfData );
502: } _except(EXCEPTION_EXECUTE_HANDLER ) {
503: free(p->iptrs.rgpbDebugSave[i]);
504: p->iptrs.rgpbDebugSave[i] = NULL;
505: }
506: }
507: }
508:
509: /*
510: * Treat COFF debug information seperately -- since the linker loves
511: * to mix it in with other things
512: */
513:
514: if (p->iptrs.rgDebugDir[IMAGE_DEBUG_TYPE_COFF] != NULL) {
515: DbgDirCoff = *COFF_DIR(&p->iptrs);
516:
517: /*
518: * Allocate space to save the coff debug info
519: */
520:
521: pb = p->iptrs.rgpbDebugSave[i] = malloc(DbgDirCoff.SizeOfData);
522:
523: /*
524: * Copy over and point to the description for the
525: * debug info.
526: */
527:
528: memcpy(pb, DbgDirCoff.PointerToRawData + p->iptrs.fptr,
529: sizeof(IMAGE_COFF_SYMBOLS_HEADER));
530: pCoffDbgInfo = (PIMAGE_COFF_SYMBOLS_HEADER) pb;
531:
532: /*
533: * Now figure out how much space we really have -- only things
534: * after the first symbol are "good" -- everything else is
535: * suspect as part of something else.
536: */
537:
538: cb = DbgDirCoff.SizeOfData - pCoffDbgInfo->LvaToFirstSymbol;
539:
540: /*
541: * Now copy over the real symbol information and set up the
542: * new pointers in the header record
543: */
544:
545: memcpy(pb+sizeof(IMAGE_COFF_SYMBOLS_HEADER),
546: p->iptrs.fptr + DbgDirCoff.PointerToRawData +
547: pCoffDbgInfo->LvaToFirstSymbol, cb);
548: pCoffDbgInfo->LvaToFirstSymbol = sizeof(IMAGE_COFF_SYMBOLS_HEADER);
549: DbgDirCoff.SizeOfData = cb + sizeof(IMAGE_COFF_SYMBOLS_HEADER);
550: pCoffDbgInfo->NumberOfLinenumbers = 0;
551: pCoffDbgInfo->LvaToFirstLinenumber = 0;
552: }
553: return;
554: } /* ReadDebugInfo() */
555:
556:
557:
558: void
559: WriteDebugInfo(
560: PPOINTERS p,
561: BOOL fAddCV,
562: BOOL fStrip
563: )
564: /*++
565:
566: Routine Description:
567:
568: This function will go out and read in all of the debug information
569: into memory -- this is required because the input and output
570: files might be the same, if so then writing out informaiton may
571: destory data we need at a later time.
572:
573: Arguments:
574:
575: p - Supplies a pointer to the structure describing the debug info file
576:
577: Return Value:
578:
579: None.
580:
581: --*/
582:
583: {
584: ULONG PointerToDebugData = 0; /* Offset from the start of the file
585: * to the current location to write
586: * debug information out.
587: */
588: ULONG BaseOfDebugData = 0;
589: int i;
590: PIMAGE_DEBUG_DIRECTORY pDir;
591: int flen;
592: PIMAGE_DEBUG_DIRECTORY pDbgDir = NULL;
593:
594:
595: if (p->optrs.debugSection) {
596: BaseOfDebugData = PointerToDebugData =
597: p->optrs.debugSection->PointerToRawData;
598: } else if (p->optrs.sepHdr) {
599: BaseOfDebugData = PointerToDebugData =
600: sizeof(IMAGE_SEPARATE_DEBUG_HEADER) +
601: p->optrs.sepHdr->NumberOfSections * sizeof(IMAGE_SECTION_HEADER) +
602: p->optrs.sepHdr->ExportedNamesSize;
603: }
604:
605:
606: /*
607: * Step 2. If the debug information is mapped, we know this
608: * from the section headers, then we may need to write
609: * out a new debug director to point to the debug information
610: */
611:
612: if (fAddCV) {
613: if (p->optrs.optHdr) {
614: p->optrs.optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].
615: VirtualAddress = p->optrs.debugSection->VirtualAddress;
616: p->optrs.optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size +=
617: sizeof(IMAGE_DEBUG_DIRECTORY);
618: } else if (p->optrs.sepHdr) {
619: p->optrs.sepHdr->DebugDirectorySize +=
620: sizeof(IMAGE_DEBUG_DIRECTORY);
621: } else {
622: exit(1);
623: }
624:
625: if (p->optrs.sepHdr) {
626: pDbgDir = (PIMAGE_DEBUG_DIRECTORY) malloc(p->optrs.cDebugDir * sizeof(IMAGE_DEBUG_DIRECTORY));
627: for (i=0; i<p->optrs.cDebugDir; i++) {
628: if (p->optrs.rgDebugDir[i] != NULL) {
629: pDbgDir[i] = *(p->optrs.rgDebugDir[i]);
630: p->optrs.rgDebugDir[i] = &pDbgDir[i];
631: }
632: }
633: }
634: for (i=0; i<p->optrs.cDebugDir; i++) {
635: if (p->optrs.rgDebugDir[i]) {
636: pDir = (PIMAGE_DEBUG_DIRECTORY) (PointerToDebugData +
637: p->optrs.fptr);
638: *pDir = *(p->optrs.rgDebugDir[i]);
639: p->optrs.rgDebugDir[i] = pDir;
640: PointerToDebugData += sizeof(IMAGE_DEBUG_DIRECTORY);
641: }
642: }
643: }
644:
645: /*
646: * For every debug info type, write out the debug information
647: * and update any header information required
648: */
649:
650: for (i=0; i<p->optrs.cDebugDir; i++) {
651: if (p->optrs.rgDebugDir[i] != NULL) {
652: if (!fStrip ||
653: (i == IMAGE_DEBUG_TYPE_FPO) ||
654: (i == IMAGE_DEBUG_TYPE_MISC)) {
655: if (p->optrs.rgpbDebugSave[i] != NULL) {
656: p->optrs.rgDebugDir[i]->PointerToRawData =
657: PointerToDebugData;
658: if (p->optrs.debugSection) {
659: p->optrs.rgDebugDir[i]->AddressOfRawData =
660: p->optrs.debugSection->VirtualAddress +
661: PointerToDebugData - BaseOfDebugData;
662: }
663: memcpy(p->optrs.fptr + PointerToDebugData,
664: p->optrs.rgpbDebugSave[i],
665: p->optrs.rgDebugDir[i]->SizeOfData);
666:
667: if ((i == IMAGE_DEBUG_TYPE_COFF) &&
668: (p->optrs.fileHdr != NULL)) {
669: p->optrs.fileHdr->PointerToSymbolTable =
670: PointerToDebugData + sizeof(IMAGE_COFF_SYMBOLS_HEADER);
671: }
672: }
673: PointerToDebugData += p->optrs.rgDebugDir[i]->SizeOfData;
674: }
675: }
676: }
677:
678: if ((PointerToDebugData == BaseOfDebugData) && fStrip) {
679: p->optrs.fileHdr->NumberOfSections -= 1;
680: }
681:
682: /*
683: * Step 4. Clean up any COFF structures if we are replacing
684: * the coff information with CV info.
685: */
686:
687: if ((p->optrs.rgDebugDir[IMAGE_DEBUG_TYPE_COFF] == NULL) &&
688: (p->optrs.fileHdr != NULL)) {
689: /*
690: * Since there is no coff debug information -- clean out
691: * both fields pointing to the debug info
692: */
693:
694: p->optrs.fileHdr->PointerToSymbolTable = 0;
695: p->optrs.fileHdr->NumberOfSymbols = 0;
696: }
697:
698: /*
699: * Step 5. Correct the alignments if needed. If there is
700: * a real .debug section in the file (i.e. it is mapped)
701: * then update the description of the section.
702: */
703:
704: if (p->optrs.debugSection) {
705: p->optrs.debugSection->SizeOfRawData =
706: FileAlign(PointerToDebugData - BaseOfDebugData);
707: /*
708: * update the optional header with the new image size
709: */
710:
711: p->optrs.optHdr->SizeOfImage =
712: SectionAlign(p->optrs.debugSection->VirtualAddress +
713: p->optrs.debugSection->SizeOfRawData);
714: p->optrs.optHdr->SizeOfInitializedData +=
715: p->optrs.debugSection->SizeOfRawData;
716: }
717:
718: /*
719: * calculate the new file size
720: */
721:
722: if (p->optrs.optHdr != NULL) {
723: flen = FileAlign(PointerToDebugData);
724: } else {
725: flen = PointerToDebugData;
726: }
727:
728: /*
729: * finally, update the eof pointer and close the file
730: */
731:
732: UnmapViewOfFile( p->optrs.fptr );
733:
734: if (!SetFilePointer( p->optrs.hFile, flen, 0, FILE_BEGIN )) {
735: FatalError( ERR_FILE_PTRS );
736: }
737:
738: if (!SetEndOfFile( p->optrs.hFile )) {
739: FatalError( ERR_SET_EOF );
740: }
741:
742: CloseHandle( p->optrs.hFile );
743:
744: /*
745: * Exit -- we are done.
746: */
747:
748: return;
749: } /* WriteDebugInfo() */
750:
751:
752:
753: void
754: MungeDebugHeadersCoffToCv(
755: PPOINTERS p,
756: BOOL fAddCV
757: )
758:
759: /*++
760:
761: Routine Description:
762:
763:
764: Arguments:
765:
766: p - pointer to a POINTERS structure (see cofftocv.h)
767:
768: Return Value:
769:
770: void
771:
772: --*/
773:
774: {
775: if (!fAddCV) {
776: CV_DIR(&p->optrs) = COFF_DIR(&p->optrs);
777: COFF_DIR(&p->optrs) = 0;
778: } else {
779: CV_DIR(&p->optrs) = &DbgDirSpare;
780: *(COFF_DIR(&p->optrs)) = *(COFF_DIR(&p->iptrs));
781: };
782:
783: *CV_DIR(&p->optrs) = *(COFF_DIR(&p->iptrs));
784: CV_DIR(&p->optrs)->Type = IMAGE_DEBUG_TYPE_CODEVIEW;
785: CV_DIR(&p->optrs)->SizeOfData = p->pCvStart.size;
786: p->optrs.rgpbDebugSave[IMAGE_DEBUG_TYPE_CODEVIEW] = p->pCvStart.ptr;
787:
788: return;
789: } /* MungeDebugHeadersCoffToCv() */
790:
791:
792:
793: BOOL
794: MapOutputFile ( PPOINTERS p, char *fname, int cb )
795:
796: /*++
797:
798: Routine Description:
799:
800: Maps the output file specified by the fname argument and saves the
801: file handle & file pointer in the POINTERS structure.
802:
803:
804: Arguments:
805:
806: p - pointer to a POINTERS structure (see cofftocv.h)
807: fname - ascii string for the file name
808:
809:
810: Return Value:
811:
812: TRUE - file mapped ok
813: FALSE - file could not be mapped
814:
815: --*/
816:
817: {
818: BOOL rval;
819: HANDLE hMap = NULL;
820: DWORD oSize;
821:
822: rval = FALSE;
823:
824: p->optrs.hFile = CreateFile( fname,
825: GENERIC_READ | GENERIC_WRITE,
826: FILE_SHARE_READ | FILE_SHARE_WRITE,
827: NULL,
828: OPEN_ALWAYS,
829: 0,
830: NULL );
831:
832: if (p->optrs.hFile == INVALID_HANDLE_VALUE) {
833: goto exit;
834: }
835:
836: oSize = p->iptrs.fsize;
837: if (p->pCvStart.ptr != NULL) {
838: oSize += p->pCvStart.size;
839: }
840: oSize += cb;
841: oSize += p->iptrs.cDebugDir * sizeof(IMAGE_DEBUG_DIRECTORY);
842:
843: hMap = CreateFileMapping( p->optrs.hFile, NULL, PAGE_READWRITE,
844: 0, oSize, NULL );
845:
846: if (hMap == NULL) {
847: goto exit;
848: }
849:
850: p->optrs.fptr = MapViewOfFile( hMap, FILE_MAP_WRITE, 0, 0, 0 );
851:
852: if (p->optrs.fptr == NULL) {
853: goto exit;
854: }
855: rval = TRUE;
856: exit:
857: return rval;
858: } /* MapOutputFile() */
859:
860: BOOL
861: CalculateOutputFilePointers( PIMAGEPOINTERS pi, PIMAGEPOINTERS po )
862:
863: /*++
864:
865: Routine Description:
866:
867: This function calculates the output file pointers based on the
868: input file pointers. The same address is used but they are all
869: re-based off the output file's file pointer.
870:
871: Arguments:
872:
873: p - pointer to a IMAGEPOINTERS structure (see cofftocv.h)
874:
875:
876: Return Value:
877:
878: TRUE - pointers were created
879: FALSE - pointers could not be created
880:
881: --*/
882: {
883: int i;
884:
885: // fixup the pointers relative the fptr for the output file
886: po->dosHdr = (PIMAGE_DOS_HEADER) AdjustPtr(pi->dosHdr);
887: po->ntHdr = (PIMAGE_NT_HEADERS) AdjustPtr(pi->ntHdr);
888: po->fileHdr = (PIMAGE_FILE_HEADER) AdjustPtr(pi->fileHdr);
889: po->optHdr = (PIMAGE_OPTIONAL_HEADER) AdjustPtr(pi->optHdr);
890: po->sectionHdrs = (PIMAGE_SECTION_HEADER) AdjustPtr(pi->sectionHdrs);
891: po->sepHdr = (PIMAGE_SEPARATE_DEBUG_HEADER) AdjustPtr(pi->sepHdr);
892: po->debugSection = (PIMAGE_SECTION_HEADER) AdjustPtr(pi->debugSection);
893: po->AllSymbols = (PIMAGE_SYMBOL) AdjustPtr(pi->AllSymbols);
894: po->stringTable = (PUCHAR) AdjustPtr(pi->stringTable);
895:
896: // move the data from the input file to the output file
897: memcpy( po->fptr, pi->fptr, pi->fsize );
898:
899: po->cDebugDir = pi->cDebugDir;
900: po->rgDebugDir = malloc(po->cDebugDir * sizeof(po->rgDebugDir[0]));
901: memset(po->rgDebugDir, 0, po->cDebugDir * sizeof(po->rgDebugDir[0]));
902:
903: for (i=0; i<po->cDebugDir; i++) {
904: po->rgDebugDir[i] = (PIMAGE_DEBUG_DIRECTORY) AdjustPtr(pi->rgDebugDir[i]);
905: }
906: po->rgpbDebugSave = pi->rgpbDebugSave;
907:
908: /*
909: * Point the input stream to the modified coff descriptor
910: */
911:
912: if (pi->rgDebugDir[IMAGE_DEBUG_TYPE_COFF] != NULL) {
913: pi->rgDebugDir[IMAGE_DEBUG_TYPE_COFF] = &DbgDirCoff;
914: }
915:
916: return TRUE;
917: }
918:
919:
920: void
921: FatalError(
922: int idMsg,
923: ...
924: )
925: /*++
926:
927: Routine Description:
928:
929: Prints a message string to stderr and then exits.
930:
931: Arguments:
932:
933: s - message string to be printed
934:
935: Return Value:
936:
937: void
938:
939: --*/
940:
941: {
942: va_list marker;
943: char rgchFormat[256];
944: char rgch[256];
945:
946: LoadString(GetModuleHandle(NULL), idMsg, rgchFormat, sizeof(rgchFormat));
947:
948: va_start(marker, idMsg);
949: vsprintf(rgch, rgchFormat, marker);
950: va_end(marker);
951:
952: fprintf(stderr, "%s\n", rgch);
953:
954: exit(1);
955: } /* FatalError() */
956:
957:
958: void
959: ComputeChecksum( char *szExeFile )
960:
961: /*++
962:
963: Routine Description:
964:
965: Computes a new checksum for the image by calling imagehlp.dll
966:
967: Arguments:
968:
969: szExeFile - exe file name
970:
971:
972: Return Value:
973:
974: void
975:
976: --*/
977:
978: {
979: DWORD dwHeaderSum = 0;
980: DWORD dwCheckSum = 0;
981: HANDLE hFile;
982: DWORD cb;
983: IMAGE_DOS_HEADER dosHdr;
984: IMAGE_NT_HEADERS ntHdr;
985:
986: if (MapFileAndCheckSum(szExeFile, &dwHeaderSum, &dwCheckSum) != CHECKSUM_SUCCESS) {
987: FatalError( ERR_CHECKSUM_CALC );
988: }
989:
990: hFile = CreateFile( szExeFile,
991: GENERIC_READ | GENERIC_WRITE,
992: FILE_SHARE_READ | FILE_SHARE_WRITE,
993: NULL,
994: OPEN_EXISTING,
995: 0,
996: NULL
997: );
998:
999: // seek to the beginning of the file
1000: SetFilePointer( hFile, 0, 0, FILE_BEGIN );
1001:
1002: // read in the dos header
1003: if ((ReadFile(hFile, &dosHdr, sizeof(dosHdr), &cb, 0) == FALSE) || (cb != sizeof(dosHdr))) {
1004: FatalError( ERR_CHECKSUM_CALC );
1005: }
1006:
1007: // read in the pe header
1008: if ((dosHdr.e_magic != IMAGE_DOS_SIGNATURE) ||
1009: (SetFilePointer(hFile, dosHdr.e_lfanew, 0, FILE_BEGIN) == -1L)) {
1010: FatalError( ERR_CHECKSUM_CALC );
1011: }
1012:
1013: // read in the nt header
1014: if ((!ReadFile(hFile, &ntHdr, sizeof(ntHdr), &cb, 0)) || (cb != sizeof(ntHdr))) {
1015: FatalError( ERR_CHECKSUM_CALC );
1016: }
1017:
1018: if (SetFilePointer(hFile, dosHdr.e_lfanew, 0, FILE_BEGIN) == -1L) {
1019: FatalError( ERR_CHECKSUM_CALC );
1020: }
1021:
1022: ntHdr.OptionalHeader.CheckSum = dwCheckSum;
1023:
1024: if (!WriteFile(hFile, &ntHdr, sizeof(ntHdr), &cb, NULL)) {
1025: FatalError( ERR_CHECKSUM_CALC );
1026: }
1027:
1028: CloseHandle(hFile);
1029: return;
1030: }
1031:
1032:
1033: void
1034: MungeExeName(
1035: PPOINTERS p,
1036: char * szExeName
1037: )
1038: /*++
1039:
1040: Routine Description:
1041:
1042: description-of-function.
1043:
1044: Arguments:
1045:
1046: argument-name - Supplies | Returns description of argument.
1047: .
1048: .
1049:
1050: Return Value:
1051:
1052: None.
1053:
1054: --*/
1055:
1056: {
1057: PIMAGE_DEBUG_MISC pMiscIn;
1058: PIMAGE_DEBUG_MISC pMiscOut;
1059: int cb;
1060: int i;
1061:
1062: for (i=0; i<p->iptrs.cDebugDir; i++) {
1063: if (p->optrs.rgDebugDir[i] != 0) {
1064: *(p->optrs.rgDebugDir[i]) = *(p->iptrs.rgDebugDir[i]);
1065: }
1066: }
1067:
1068: pMiscIn = (PIMAGE_DEBUG_MISC)
1069: p->iptrs.rgpbDebugSave[IMAGE_DEBUG_TYPE_MISC];
1070:
1071: if (p->optrs.rgDebugDir[IMAGE_DEBUG_TYPE_MISC] == NULL) {
1072: p->optrs.rgDebugDir[IMAGE_DEBUG_TYPE_MISC] = &DbgDirSpare;
1073: memset(&DbgDirSpare, 0, sizeof(DbgDirSpare));
1074: }
1075:
1076: pMiscOut = (PIMAGE_DEBUG_MISC)
1077: p->optrs.rgpbDebugSave[IMAGE_DEBUG_TYPE_MISC] =
1078: malloc(p->optrs.rgDebugDir[IMAGE_DEBUG_TYPE_MISC]->SizeOfData +
1079: strlen(szExeName));
1080: cb = p->optrs.rgDebugDir[IMAGE_DEBUG_TYPE_MISC]->SizeOfData;
1081:
1082: while ( cb > 0 ) {
1083: if (pMiscIn->DataType == IMAGE_DEBUG_MISC_EXENAME) {
1084: pMiscOut->DataType = IMAGE_DEBUG_MISC_EXENAME;
1085: pMiscOut->Length = (sizeof(IMAGE_DEBUG_MISC) +
1086: strlen(szExeName) + 3) & ~3;
1087: pMiscOut->Unicode = FALSE;
1088: strcpy(&pMiscOut->Data[0], szExeName);
1089: szExeName = NULL;
1090: } else {
1091: memcpy(pMiscOut, pMiscIn, pMiscIn->Length);
1092: }
1093:
1094: p->optrs.rgDebugDir[IMAGE_DEBUG_TYPE_MISC]->SizeOfData +=
1095: (pMiscOut->Length - pMiscIn->Length);
1096:
1097: cb -= pMiscIn->Length;
1098: pMiscIn = (PIMAGE_DEBUG_MISC) (((char *) pMiscIn) + pMiscIn->Length);
1099: pMiscOut = (PIMAGE_DEBUG_MISC) (((char *) pMiscOut) + pMiscOut->Length);
1100: }
1101:
1102: if (szExeName) {
1103: pMiscOut->DataType = IMAGE_DEBUG_MISC_EXENAME;
1104: pMiscOut->Length = (sizeof(IMAGE_DEBUG_MISC) +
1105: strlen(szExeName) + 3) & ~3;
1106: pMiscOut->Unicode = FALSE;
1107: strcpy(&pMiscOut->Data[0], szExeName);
1108: }
1109:
1110: return;
1111: } /* MungeExeName() */
1112:
1113:
1114: /*** DoCoffToCv
1115: *
1116: *
1117: */
1118:
1119: void DoCoffToCv(char * szInput, char * szOutput, BOOL fAddCV)
1120: {
1121: POINTERS p;
1122:
1123: /*
1124: * Do default checking
1125: */
1126:
1127: if (szOutput == NULL) {
1128: szOutput = szInput;
1129: }
1130:
1131: /*
1132: * Open the input file name and setup the pointers into the file
1133: */
1134:
1135: if (!MapInputFile( &p, NULL, szInput )) {
1136: FatalError( ERR_OPEN_INPUT_FILE, szInput );
1137: }
1138:
1139: /*
1140: * Now, if we thing we are playing with PE exes then we need
1141: * to setup the pointers into the map file
1142: */
1143:
1144: if (!CalculateNtImagePointers( &p.iptrs )) {
1145: FatalError( ERR_INVALID_PE, szInput );
1146: }
1147:
1148: /*
1149: * We are about to try and do the coff to cv symbol conversion.
1150: *
1151: * Verify that the operation is legal.
1152: *
1153: * 1. We need to have coff debug information to start with
1154: * 2. If the debug info is not mapped then we must not
1155: * be trying to add CodeView info.
1156: */
1157:
1158: if ((p.iptrs.AllSymbols == NULL) || (COFF_DIR(&p.iptrs) == NULL)) {
1159: FatalError( ERR_NO_COFF );
1160: }
1161:
1162: if (fAddCV && (p.iptrs.debugSection == 0) && (p.iptrs.sepHdr == NULL)) {
1163: FatalError( ERR_NOT_MAPPED );
1164: }
1165:
1166: /*
1167: * Now go out an preform the acutal conversion.
1168: */
1169:
1170: if (!ConvertCoffToCv( &p )) {
1171: FatalError( ERR_COFF_TO_CV );
1172: }
1173:
1174: /*
1175: * Read in any additional debug information in the file
1176: */
1177:
1178: ReadDebugInfo(&p);
1179:
1180: /*
1181: * Open the output file and adjust the pointers so that
1182: * we are ok.
1183: */
1184:
1185: if (!MapOutputFile( &p, szOutput, 0 )) {
1186: FatalError( ERR_MAP_FILE, szOutput );
1187: }
1188:
1189: CalculateOutputFilePointers( &p.iptrs, &p.optrs );
1190:
1191: /*
1192: * Munge the various debug information structures
1193: * to preform the correct operations
1194: */
1195:
1196: MungeDebugHeadersCoffToCv( &p, fAddCV );
1197:
1198: /*
1199: * Write out the debug information to the end of the exe
1200: */
1201:
1202: WriteDebugInfo( &p, fAddCV, FALSE );
1203:
1204: /*
1205: * and finally compute the checksum
1206: */
1207:
1208: if (p.iptrs.fileHdr != NULL) {
1209: ComputeChecksum( szOutput );
1210: }
1211:
1212: return;
1213: } /* DoCoffToCv() */
1214:
1215: /*** DoSymToCv
1216: *
1217: */
1218:
1219: void DoSymToCv(char * szInput, char * szOutput, char * szDbg, char * szSym)
1220: {
1221: POINTERS p;
1222: HANDLE hFile;
1223: DWORD cb;
1224: OFSTRUCT ofs;
1225:
1226: /*
1227: * Open the input file name and setup the pointers into the file
1228: */
1229:
1230: if (!MapInputFile( &p, NULL, szSym )) {
1231: FatalError(ERR_OPEN_INPUT_FILE, szSym);
1232: }
1233:
1234: /*
1235: * Now preform the desired operation
1236: */
1237:
1238: if ((szOutput == NULL) && (szDbg == NULL)) {
1239: szOutput = szInput;
1240: }
1241:
1242: ConvertSymToCv( &p );
1243:
1244: if (szOutput) {
1245: if (szOutput != szInput) {
1246: if (OpenFile(szInput, &ofs, OF_EXIST) == 0) {
1247: FatalError(ERR_OPEN_INPUT_FILE, szInput);
1248: }
1249: if (CopyFile(szInput, szOutput, FALSE) == 0) {
1250: FatalError(ERR_OPEN_WRITE_FILE, szOutput);
1251: }
1252: }
1253: hFile = CreateFile(szOutput, GENERIC_WRITE, 0, NULL,
1254: CREATE_ALWAYS,
1255: FILE_ATTRIBUTE_NORMAL, NULL);
1256: if (hFile == INVALID_HANDLE_VALUE) {
1257: FatalError(ERR_OPEN_WRITE_FILE, szOutput);
1258: }
1259: SetFilePointer(hFile, 0, 0, FILE_END);
1260: } else if (szDbg) {
1261: hFile = CreateFile(szDbg, GENERIC_WRITE, 0, NULL,
1262: OPEN_ALWAYS,
1263: FILE_ATTRIBUTE_NORMAL, NULL);
1264: if (hFile == INVALID_HANDLE_VALUE) {
1265: FatalError(ERR_OPEN_WRITE_FILE, szDbg);
1266: }
1267: }
1268:
1269: WriteFile(hFile, p.pCvStart.ptr, p.pCvStart.size, &cb, NULL);
1270: CloseHandle(hFile);
1271:
1272: return;
1273: } /* DoSymToCv() */
1274:
1275:
1276: void DoNameChange(char * szInput, char * szOutput, char * szNewName)
1277: {
1278: POINTERS p;
1279:
1280: /*
1281: * Open the input file name and setup the pointers into the file
1282: */
1283:
1284: if (!MapInputFile( &p, NULL, szInput )) {
1285: FatalError(ERR_OPEN_INPUT_FILE, szInput);
1286: }
1287:
1288: /*
1289: * Now, if we thing we are playing with PE exes then we need
1290: * to setup the pointers into the map file
1291: */
1292:
1293: if (!CalculateNtImagePointers( &p.iptrs )) {
1294: FatalError(ERR_INVALID_PE, szInput);
1295: }
1296:
1297: /*
1298: * Now preform the desired operation
1299: */
1300:
1301: if (szOutput == NULL) {
1302: szOutput = szInput;
1303: }
1304:
1305: if (szNewName == NULL) {
1306: szNewName = szOutput;
1307: }
1308:
1309: if (p.iptrs.sepHdr != NULL) {
1310: FatalError(ERR_EDIT_DBG_FILE);
1311: }
1312:
1313: /*
1314: * Read in all of the debug information
1315: */
1316:
1317: ReadDebugInfo(&p);
1318:
1319: /*
1320: * Open the output file and adjust the pointers.
1321: */
1322:
1323: if (!MapOutputFile(&p, szOutput,
1324: sizeof(szNewName) * 2 + sizeof(IMAGE_DEBUG_MISC))) {
1325: FatalError(ERR_MAP_FILE, szOutput);
1326: }
1327:
1328: CalculateOutputFilePointers(&p.iptrs, &p.optrs);
1329:
1330: /*
1331: * Munge the name of the file
1332: */
1333:
1334: MungeExeName(&p, szNewName);
1335:
1336: /*
1337: * Write out the debug information to the end of the exe
1338: */
1339:
1340: WriteDebugInfo(&p, FALSE, FALSE);
1341:
1342: /*
1343: * and finally compute the checksum
1344: */
1345:
1346: if (p.iptrs.fileHdr != NULL) {
1347: ComputeChecksum( szOutput );
1348: }
1349:
1350: return;
1351: } /* DoNameChange() */
1352:
1353:
1354: void MungeStrip(PPOINTERS p, BOOL fPartial)
1355: {
1356: PIMAGE_SECTION_HEADER pSection;
1357: ULONG flen;
1358:
1359: if (p->iptrs.debugSection == NULL) {
1360: /* unmapped */
1361: return;
1362: }
1363:
1364: /*
1365: * If the last section is not the debug section then
1366: * we can't do this.
1367: */
1368:
1369: pSection = &p->optrs.sectionHdrs[p->iptrs.numberOfSections-1];
1370: if (p->optrs.debugSection != pSection) {
1371: exit(1);
1372: }
1373: pSection -= 1;
1374:
1375: /*
1376: * If full strip ----
1377: * Reduced the number of sections by one, but don't bother
1378: * actucally removing the section descriptor, its not worth
1379: * the time.
1380: */
1381:
1382: if (!fPartial) {
1383: p->optrs.numberOfSections -= 1;
1384: p->optrs.fileHdr->NumberOfSections -= 1;
1385:
1386: /*
1387: * If we are doing a full strip then clear out all pointers
1388: * to debug info
1389: */
1390:
1391: p->optrs.optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress = 0;
1392: p->optrs.optHdr->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size = 0;
1393: p->optrs.fileHdr->PointerToSymbolTable = 0;
1394: p->optrs.fileHdr->NumberOfSymbols = 0;
1395:
1396: p->optrs.optHdr->SizeOfImage = SectionAlign(pSection->VirtualAddress +
1397: pSection->SizeOfRawData);
1398: p->optrs.optHdr->SizeOfInitializedData -=
1399: p->optrs.debugSection->SizeOfRawData;
1400:
1401: flen = FileAlign(pSection->VirtualAddress + pSection->SizeOfRawData );
1402: UnmapViewOfFile( p->optrs.fptr );
1403:
1404: if (!SetFilePointer( p->optrs.hFile, flen, 0, FILE_BEGIN )) {
1405: FatalError(ERR_FILE_PTRS);
1406: }
1407:
1408: if (!SetEndOfFile( p->optrs.hFile )) {
1409: FatalError( ERR_SET_EOF );
1410: }
1411:
1412: CloseHandle( p->optrs.hFile );
1413:
1414: return;
1415: }
1416:
1417: /*
1418: * Partial strip
1419: */
1420:
1421: p->optrs.fileHdr->PointerToSymbolTable = 0;
1422: p->optrs.fileHdr->NumberOfSymbols = 0;
1423:
1424: WriteDebugInfo( p, FALSE, TRUE );
1425:
1426: return;
1427: } /* MungeStrip() */
1428:
1429: void DoStrip(char * szInput, char * szOutput)
1430: {
1431: POINTERS p;
1432:
1433: if (szOutput == NULL) {
1434: szOutput = szInput;
1435: }
1436:
1437: /*
1438: * Open the input file and setup the pointers into it.
1439: */
1440:
1441: if (!MapInputFile(&p, NULL, szInput)) {
1442: FatalError(ERR_OPEN_INPUT_FILE, szInput);
1443: }
1444:
1445: /*
1446: * Now, setup the rest of the input points
1447: */
1448:
1449: if (!CalculateNtImagePointers(&p.iptrs)) {
1450: FatalError(ERR_INVALID_PE, szInput);
1451: }
1452:
1453: /*
1454: * Open the output file and adjust the pointers
1455: */
1456:
1457: if (!MapOutputFile(&p, szOutput, 0)) {
1458: FatalError(ERR_MAP_FILE, szOutput);
1459: }
1460:
1461: CalculateOutputFilePointers(&p.iptrs, &p.optrs);
1462:
1463: /*
1464: * Munge the file headers
1465: */
1466:
1467: MungeStrip(&p, FALSE);
1468:
1469: ComputeChecksum(szOutput);
1470:
1471: return;
1472: } /* DoStrip() */
1473:
1474: void DoExtract(char * szInput, char * szOutput, char * szDbgFile)
1475: {
1476: IMAGE_SEPARATE_DEBUG_HEADER sepHdr;
1477: DWORD * rgobDbgDir;
1478: PIMAGE_DEBUG_DIRECTORY rgDbgDir;
1479: POINTERS p;
1480: HANDLE hFile;
1481: int cb;
1482: int i;
1483: DWORD BaseOfDebugData;
1484: DWORD PointerToDebugData;
1485:
1486: if (!MapInputFile(&p, NULL, szInput)) {
1487: FatalError(ERR_OPEN_INPUT_FILE, szInput);
1488: }
1489:
1490: if (!CalculateNtImagePointers(&p.iptrs)) {
1491: FatalError(ERR_INVALID_PE, szInput);
1492: }
1493:
1494: if (szOutput == NULL) {
1495: szOutput = szInput;
1496: }
1497:
1498: if (!MapOutputFile(&p, szOutput, 0)) {
1499: FatalError(ERR_MAP_FILE, szOutput);
1500: }
1501:
1502: ReadDebugInfo(&p);
1503:
1504:
1505: CalculateOutputFilePointers(&p.iptrs, &p.optrs);
1506:
1507: /*
1508: * Open the DBG file to be dumped
1509: */
1510:
1511: if (szDbgFile == NULL) {
1512: char rgchDrive[_MAX_DRIVE];
1513: char rgchPath[_MAX_PATH];
1514: char rgchBase[_MAX_FNAME];
1515:
1516: _splitpath(szInput, rgchDrive, rgchPath, rgchBase, NULL);
1517: szDbgFile = malloc(strlen(rgchDrive) + strlen(rgchPath) +
1518: strlen(rgchBase) + 5);
1519: strcpy(szDbgFile, rgchDrive);
1520: strcat(szDbgFile, rgchPath);
1521: strcat(szDbgFile, rgchBase);
1522: strcat(szDbgFile, ".DBG");
1523: }
1524:
1525: hFile = CreateFile(szDbgFile, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS,
1526: FILE_ATTRIBUTE_NORMAL, NULL);
1527: if (hFile == INVALID_HANDLE_VALUE) {
1528: FatalError(ERR_OPEN_WRITE_FILE, szDbgFile);
1529: }
1530:
1531: /*
1532: * Create a header for the Dbg File
1533: */
1534:
1535: sepHdr.Signature = IMAGE_SEPARATE_DEBUG_SIGNATURE;
1536: sepHdr.Flags = 0;
1537: sepHdr.Machine = p.optrs.fileHdr->Machine;
1538: sepHdr.Characteristics = 0;
1539: sepHdr.TimeDateStamp = 0;
1540: sepHdr.CheckSum = 0;
1541: sepHdr.ImageBase = 0;
1542: sepHdr.SizeOfImage = 0;
1543: sepHdr.NumberOfSections = p.iptrs.numberOfSections;
1544: sepHdr.ExportedNamesSize = 0;
1545: sepHdr.DebugDirectorySize = 0;
1546:
1547: WriteFile(hFile, &sepHdr, sizeof(sepHdr), &cb, NULL);
1548:
1549: /*
1550: * Put out the new section headers
1551: */
1552:
1553: for (i=0; i<p.iptrs.numberOfSections; i++) {
1554: WriteFile(hFile, &p.iptrs.sectionHdrs[i], sizeof(IMAGE_SECTION_HEADER),
1555: &cb, NULL);
1556: }
1557:
1558: /*
1559: * Put out the export table
1560: */
1561:
1562: for (i=0; i<p.iptrs.numberOfSections; i++) {
1563: if (strcmp(p.iptrs.sectionHdrs[i].Name, ".edata") == 0) {
1564: WriteFile(hFile,
1565: p.iptrs.fptr + p.iptrs.sectionHdrs[i].PointerToRawData,
1566: p.iptrs.sectionHdrs[i].SizeOfRawData, &cb, NULL);
1567: sepHdr.ExportedNamesSize = p.iptrs.sectionHdrs[i].SizeOfRawData;
1568: break;
1569: }
1570: }
1571:
1572: /*
1573: * Put out the new dbg directory headers
1574: */
1575:
1576: BaseOfDebugData = PointerToDebugData =
1577: SetFilePointer(hFile, 0, 0, FILE_CURRENT);
1578:
1579: rgobDbgDir = (DWORD *) malloc(p.optrs.cDebugDir * sizeof(DWORD));
1580: rgDbgDir = (PIMAGE_DEBUG_DIRECTORY)
1581: malloc(p.optrs.cDebugDir * sizeof(IMAGE_DEBUG_DIRECTORY));
1582: memset(rgobDbgDir, 0, p.optrs.cDebugDir * sizeof(DWORD));
1583: memset(rgDbgDir, 0, p.optrs.cDebugDir * sizeof(IMAGE_DEBUG_DIRECTORY));
1584:
1585: for (i=0; i<p.iptrs.cDebugDir; i++) {
1586: if (p.iptrs.rgDebugDir[i] != NULL) {
1587: WriteFile(hFile, p.iptrs.rgDebugDir[i],
1588: sizeof(IMAGE_DEBUG_DIRECTORY), &cb, NULL);
1589: rgobDbgDir[i] = PointerToDebugData;
1590: rgDbgDir[i] = *(p.iptrs.rgDebugDir[i]);
1591: PointerToDebugData += sizeof(IMAGE_DEBUG_DIRECTORY);
1592: sepHdr.DebugDirectorySize += sizeof(IMAGE_DEBUG_DIRECTORY);
1593: }
1594: }
1595:
1596: /*
1597: * Write out debug info
1598: */
1599:
1600: for (i=0; i<p.iptrs.cDebugDir; i++) {
1601: if (p.iptrs.rgDebugDir[i] != NULL) {
1602: p.optrs.rgDebugDir[i]->AddressOfRawData = 0;
1603: rgDbgDir[i].AddressOfRawData = 0;
1604: p.optrs.rgDebugDir[i]->PointerToRawData =
1605: rgDbgDir[i].PointerToRawData =
1606: SetFilePointer(hFile, 0, 0, FILE_CURRENT);
1607: WriteFile(hFile, p.iptrs.rgpbDebugSave[i], rgDbgDir[i].SizeOfData,
1608: &cb, NULL);
1609: }
1610: }
1611:
1612:
1613: /*
1614: *
1615: */
1616:
1617: p.optrs.fileHdr->Characteristics |= IMAGE_FILE_DEBUG_STRIPPED;
1618: MungeStrip(&p, TRUE);
1619:
1620: ComputeChecksum(szOutput);
1621:
1622: UnmapViewOfFile( p.iptrs.fptr );
1623: CloseHandle( p.iptrs.hFile);
1624:
1625: if (!MapInputFile(&p, NULL, szOutput)) {
1626: FatalError(ERR_OPEN_INPUT_FILE, szOutput);
1627: }
1628:
1629: if (!CalculateNtImagePointers(&p.iptrs)) {
1630: FatalError(ERR_INVALID_PE, szOutput);
1631: }
1632:
1633: /*
1634: * Correct the header and the debug directory records
1635: */
1636:
1637: sepHdr.Characteristics = p.iptrs.fileHdr->Characteristics;
1638: sepHdr.TimeDateStamp = p.iptrs.fileHdr->TimeDateStamp;
1639: sepHdr.CheckSum = p.iptrs.optHdr->CheckSum;
1640: sepHdr.ImageBase = p.iptrs.optHdr->ImageBase;
1641: sepHdr.SizeOfImage = p.iptrs.optHdr->SizeOfImage;
1642:
1643: SetFilePointer(hFile, 0, 0, FILE_BEGIN);
1644: WriteFile(hFile, &sepHdr, sizeof(sepHdr), &cb, NULL);
1645: SetFilePointer(hFile, BaseOfDebugData, 0, FILE_BEGIN);
1646: for (i=0; i<p.iptrs.cDebugDir; i++) {
1647: if (p.iptrs.rgDebugDir[i] != NULL) {
1648: WriteFile(hFile, &rgDbgDir[i],
1649: sizeof(IMAGE_DEBUG_DIRECTORY), &cb, NULL);
1650: }
1651: }
1652:
1653: UnmapViewOfFile( p.iptrs.fptr );
1654: CloseHandle( p.iptrs.hFile);
1655: CloseHandle(hFile);
1656:
1657: return;
1658: } /* DoExtract() */
1659:
1660: void DoJoin(char * szInput, char * szOutput, char * szDbgFile)
1661: {
1662: } /* DoJoin() */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.