| /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- |
| * |
| * ***** BEGIN LICENSE BLOCK ***** |
| * Version: MPL 1.1/GPL 2.0/LGPL 2.1 |
| * |
| * The contents of this file are subject to the Mozilla Public License Version |
| * 1.1 (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * http://www.mozilla.org/MPL/ |
| * |
| * Software distributed under the License is distributed on an "AS IS" basis, |
| * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License |
| * for the specific language governing rights and limitations under the |
| * License. |
| * |
| * The Original Code is msdump2symdb.c code, released |
| * Jan 16, 2003. |
| * |
| * The Initial Developer of the Original Code is |
| * Netscape Communications Corporation. |
| * Portions created by the Initial Developer are Copyright (C) 2002 |
| * the Initial Developer. All Rights Reserved. |
| * |
| * Contributor(s): |
| * Garrett Arch Blythe, 16-January-2003 |
| * |
| * Alternatively, the contents of this file may be used under the terms of |
| * either the GNU General Public License Version 2 or later (the "GPL"), or |
| * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), |
| * in which case the provisions of the GPL or the LGPL are applicable instead |
| * of those above. If you wish to allow use of your version of this file only |
| * under the terms of either the GPL or the LGPL, and not to allow others to |
| * use your version of this file under the terms of the MPL, indicate your |
| * decision by deleting the provisions above and replace them with the notice |
| * and other provisions required by the GPL or the LGPL. If you do not delete |
| * the provisions above, a recipient may use your version of this file under |
| * the terms of any one of the MPL, the GPL or the LGPL. |
| * |
| * ***** END LICENSE BLOCK ***** */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <time.h> |
| #include <ctype.h> |
| #include <errno.h> |
| |
| #define ERROR_REPORT(num, val, msg) fprintf(stderr, "error(%d):\t\"%s\"\t%s\n", (num), (val), (msg)); |
| #define CLEANUP(ptr) do { if(NULL != ptr) { free(ptr); ptr = NULL; } } while(0) |
| |
| |
| typedef struct __struct_Options |
| /* |
| ** Options to control how we perform. |
| ** |
| ** mProgramName Used in help text. |
| ** mInput File to read for input. |
| ** Default is stdin. |
| ** mInputName Name of the file. |
| ** mOutput Output file, append. |
| ** Default is stdout. |
| ** mOutputName Name of the file. |
| ** mHelp Whether or not help should be shown. |
| */ |
| { |
| const char* mProgramName; |
| FILE* mInput; |
| char* mInputName; |
| FILE* mOutput; |
| char* mOutputName; |
| int mHelp; |
| } |
| Options; |
| |
| |
| typedef struct __struct_Switch |
| /* |
| ** Command line options. |
| */ |
| { |
| const char* mLongName; |
| const char* mShortName; |
| int mHasValue; |
| const char* mValue; |
| const char* mDescription; |
| } |
| Switch; |
| |
| #define DESC_NEWLINE "\n\t\t" |
| |
| static Switch gInputSwitch = {"--input", "-i", 1, NULL, "Specify input file." DESC_NEWLINE "stdin is default."}; |
| static Switch gOutputSwitch = {"--output", "-o", 1, NULL, "Specify output file." DESC_NEWLINE "Appends if file exists." DESC_NEWLINE "stdout is default."}; |
| static Switch gHelpSwitch = {"--help", "-h", 0, NULL, "Information on usage."}; |
| |
| static Switch* gSwitches[] = { |
| &gInputSwitch, |
| &gOutputSwitch, |
| &gHelpSwitch |
| }; |
| |
| |
| typedef struct __struct_MSDump_Symbol |
| /* |
| ** Struct to hold infomration on a symbol. |
| ** |
| ** mSize Size of the symbol once all work is complete. |
| ** mOffset Offset of the symbol in the section. |
| ** mName Symbolic name. |
| */ |
| { |
| unsigned mSize; |
| unsigned mOffset; |
| char* mName; |
| } |
| MSDump_Symbol; |
| |
| |
| typedef struct __struct_MSDump_Section |
| /* |
| ** Struct for holding information on a section. |
| ** |
| ** mLength Length of the section in bytes. |
| ** mUsed Number of bytes used in the section thus far. |
| ** Should eventually match mLength after work is done. |
| ** mType Type of section, as string (.data, .text, et. al.) |
| ** mSymbols Symbols found inside the section. |
| ** mSymbolCount Number of symbols in array. |
| */ |
| { |
| unsigned mLength; |
| unsigned mUsed; |
| char* mType; |
| |
| MSDump_Symbol* mSymbols; |
| unsigned mSymbolCount; |
| } |
| MSDump_Section; |
| |
| |
| typedef struct __struct_MSDump_Object |
| /* |
| ** Struct for holding object's data. |
| */ |
| { |
| char* mObject; |
| |
| MSDump_Section* mSections; |
| unsigned mSectionCount; |
| } |
| MSDump_Object; |
| |
| |
| typedef struct __struct_MSDump_ReadState |
| /* |
| ** State flags while reading the input gives us hints on what to do. |
| ** |
| ** mSkipLines Number of lines to skip without parsing. |
| ** mSectionDetails Section information next, like line length. |
| ** mCurrentObject Object file we are dealing with. |
| */ |
| { |
| unsigned mSkipLines; |
| unsigned mSectionDetails; |
| MSDump_Object* mCurrentObject; |
| } |
| MSDump_ReadState; |
| |
| |
| typedef struct __struct_MSDump_Container |
| /* |
| ** Umbrella container for all data encountered. |
| */ |
| { |
| MSDump_ReadState mReadState; |
| |
| MSDump_Object* mObjects; |
| unsigned mObjectCount; |
| } |
| MSDump_Container; |
| |
| |
| void trimWhite(char* inString) |
| /* |
| ** Remove any whitespace from the end of the string. |
| */ |
| { |
| int len = strlen(inString); |
| |
| while(len) |
| { |
| len--; |
| |
| if(isspace(*(inString + len))) |
| { |
| *(inString + len) = '\0'; |
| } |
| else |
| { |
| break; |
| } |
| } |
| } |
| |
| |
| const char* skipWhite(const char* inString) |
| /* |
| ** Return pointer to first non white space character. |
| */ |
| { |
| const char* retval = inString; |
| |
| while('\0' != *retval && isspace(*retval)) |
| { |
| retval++; |
| } |
| |
| return retval; |
| } |
| |
| |
| const char* skipNonWhite(const char* inString) |
| /* |
| ** Return pointer to first white space character. |
| */ |
| { |
| const char* retval = inString; |
| |
| while('\0' != *retval && !isspace(*retval)) |
| { |
| retval++; |
| } |
| |
| return retval; |
| } |
| |
| |
| void slash2bs(char* inString) |
| /* |
| ** Change any forward slash to a backslash. |
| */ |
| { |
| char* slash = inString; |
| |
| while(NULL != (slash = strchr(slash, '/'))) |
| { |
| *slash = '\\'; |
| slash++; |
| } |
| } |
| |
| |
| const char* skipToArg(const char* inString, unsigned inArgIndex) |
| /* |
| ** Return pointer either to the arg or NULL. |
| ** 1 indexed. |
| */ |
| { |
| const char* retval = NULL; |
| |
| while(0 != inArgIndex && '\0' != *inString) |
| { |
| inArgIndex--; |
| |
| inString = skipWhite(inString); |
| if(0 != inArgIndex) |
| { |
| inString = skipNonWhite(inString); |
| } |
| } |
| |
| if('\0' != *inString) |
| { |
| retval = inString; |
| } |
| |
| return retval; |
| } |
| |
| |
| const char* getLastArg(const char* inString) |
| /* |
| ** Return pointer to last arg in string. |
| */ |
| { |
| const char* retval = NULL; |
| int length = 0; |
| int sawString = 0; |
| |
| length = strlen(inString); |
| while(0 != length) |
| { |
| length--; |
| |
| if(0 == sawString) |
| { |
| if(0 == isspace(inString[length])) |
| { |
| sawString = __LINE__; |
| } |
| } |
| else |
| { |
| if(0 != isspace(inString[length])) |
| { |
| retval = inString + length + 1; |
| } |
| } |
| } |
| |
| return retval; |
| } |
| |
| |
| int processLine(Options* inOptions, MSDump_Container* inContainer, const char* inLine) |
| /* |
| ** Handle one line at a time. |
| ** Looking for several different types of lines. |
| ** Ignore all other lines. |
| ** The container is the state machine. |
| ** returns 0 on no error. |
| */ |
| { |
| int retval = 0; |
| |
| /* |
| ** Check to see if we were expecting section details. |
| */ |
| if(0 != inContainer->mReadState.mSectionDetails) |
| { |
| const char* length = NULL; |
| unsigned sectionIndex = 0; |
| |
| /* |
| ** Detail is a 1 based index.... |
| ** Reset. |
| */ |
| sectionIndex = inContainer->mReadState.mSectionDetails - 1; |
| inContainer->mReadState.mSectionDetails = 0; |
| |
| if(0 == strncmp(" Section length", inLine, 18)) |
| { |
| const char* sectionLength = NULL; |
| unsigned numericLength = 0; |
| char* endScan = NULL; |
| |
| sectionLength = skipWhite(inLine + 18); |
| |
| errno = 0; |
| numericLength = strtoul(sectionLength, &endScan, 16); |
| if(0 == errno && endScan != sectionLength) |
| { |
| inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mLength = numericLength; |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "Cannot scan for section length."); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "Cannot parse section line."); |
| } |
| } |
| /* |
| ** Check for switching object file symbols. |
| */ |
| else if(0 == strncmp("Dump of file ", inLine, 13)) |
| { |
| const char* dupMe = inLine + 13; |
| char* dup = NULL; |
| |
| dup = strdup(dupMe); |
| if(NULL != dup) |
| { |
| void* growth = NULL; |
| |
| trimWhite(dup); |
| slash2bs(dup); |
| |
| |
| growth = realloc(inContainer->mObjects, (inContainer->mObjectCount + 1) * sizeof(MSDump_Object)); |
| if(NULL != growth) |
| { |
| unsigned int index = inContainer->mObjectCount; |
| |
| inContainer->mObjectCount++; |
| inContainer->mObjects = growth; |
| memset(inContainer->mObjects + index, 0, sizeof(MSDump_Object)); |
| |
| inContainer->mObjects[index].mObject = dup; |
| |
| /* |
| ** Reset the read state for this new object. |
| */ |
| memset(&inContainer->mReadState, 0, sizeof(MSDump_ReadState)); |
| |
| /* |
| ** Record our current object file. |
| */ |
| inContainer->mReadState.mCurrentObject = inContainer->mObjects + index; |
| |
| /* |
| ** We can skip a few lines. |
| */ |
| inContainer->mReadState.mSkipLines = 4; |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, dup, "Unable to grow object array."); |
| free(dup); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, dupMe, "Unable to copy string."); |
| |
| } |
| } |
| /* |
| ** Check for a symbol dump or a section header. |
| */ |
| else if(isxdigit(*inLine) && isxdigit(*(inLine + 1)) && isxdigit(*(inLine + 2))) |
| { |
| const char* sectionString = NULL; |
| |
| /* |
| ** Determine the section for this line. |
| ** Ignore DEBUG sections. |
| */ |
| sectionString = skipToArg(inLine, 3); |
| if(NULL != sectionString) |
| { |
| if(0 != strncmp(sectionString, "DEBUG", 5) && 0 != strncmp(sectionString, "ABS", 3) && 0 != strncmp(sectionString, "UNDEF", 5)) |
| { |
| /* |
| ** MUST start with "SECT" |
| */ |
| if(0 == strncmp(sectionString, "SECT", 4)) |
| { |
| unsigned sectionIndex1 = 0; |
| |
| char *endScan = NULL; |
| |
| sectionString += 4; |
| |
| /* |
| ** Convert the remaining string to an index. |
| ** It will be 1 based. |
| */ |
| errno = 0; |
| sectionIndex1 = strtoul(sectionString, &endScan, 16); |
| if(0 == errno && endScan != sectionString && 0 != sectionIndex1) |
| { |
| unsigned sectionIndex = sectionIndex1 - 1; |
| |
| /* |
| ** Is this a new section? Assumed to be ascending. |
| ** Or is this a symbol in the section? |
| */ |
| if(sectionIndex1 > inContainer->mReadState.mCurrentObject->mSectionCount) |
| { |
| const char* typeArg = NULL; |
| |
| /* |
| ** New Section, figure out the type. |
| */ |
| typeArg = skipToArg(sectionString, 5); |
| if(NULL != typeArg) |
| { |
| char* typeDup = NULL; |
| |
| /* |
| ** Skip the leading period before duping. |
| */ |
| if('.' == *typeArg) |
| { |
| typeArg++; |
| } |
| typeDup = strdup(typeArg); |
| |
| if(NULL != typeDup) |
| { |
| void* moved = NULL; |
| char* nonWhite = NULL; |
| |
| /* |
| ** Terminate the duplicate after the section type. |
| */ |
| nonWhite = (char*)skipNonWhite(typeDup); |
| if(NULL != nonWhite) |
| { |
| *nonWhite = '\0'; |
| } |
| |
| /* |
| ** Create more space for the section in the object... |
| */ |
| moved = realloc(inContainer->mReadState.mCurrentObject->mSections, sizeof(MSDump_Section) * sectionIndex1); |
| if(NULL != moved) |
| { |
| unsigned oldCount = inContainer->mReadState.mCurrentObject->mSectionCount; |
| |
| inContainer->mReadState.mCurrentObject->mSections = (MSDump_Section*)moved; |
| inContainer->mReadState.mCurrentObject->mSectionCount = sectionIndex1; |
| memset(&inContainer->mReadState.mCurrentObject->mSections[oldCount], 0, sizeof(MSDump_Section) * (sectionIndex1 - oldCount)); |
| |
| /* |
| ** Other section details. |
| */ |
| inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mType = typeDup; |
| |
| |
| /* |
| ** Mark it so that we look for the length on the next line. |
| ** This happens on next entry into the read state. |
| */ |
| inContainer->mReadState.mSectionDetails = sectionIndex1; |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "Unable to grow for new section."); |
| free(typeDup); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, typeArg, "Unable to duplicate type."); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "Unable to determine section type."); |
| } |
| |
| } |
| else |
| { |
| const char* offsetArg = NULL; |
| const char* classArg = NULL; |
| unsigned classWords = 1; |
| const char* symbolArg = NULL; |
| |
| /* |
| ** This is an section we've seen before, and must list a symbol. |
| ** Figure out the things we want to know about the symbol, e.g. size. |
| ** We will ignore particular classes of symbols. |
| */ |
| |
| offsetArg = skipToArg(inLine, 2); |
| |
| classArg = skipToArg(offsetArg, 4); |
| if(0 == strncmp(classArg, "()", 2)) |
| { |
| classArg = skipToArg(classArg, 2); |
| } |
| if(0 == strncmp(classArg, ".bf or.ef", 9)) |
| { |
| classWords = 2; |
| } |
| |
| symbolArg = skipToArg(classArg, 3 + (classWords - 1)); |
| |
| /* |
| ** Skip particular lines/items. |
| */ |
| if( |
| 0 != strncmp(classArg, "Label", 5) && |
| 0 != strncmp(symbolArg, ".bf", 3) && |
| 0 != strncmp(symbolArg, ".lf", 3) && |
| 0 != strncmp(symbolArg, ".ef", 3) |
| ) |
| { |
| char* endOffsetArg = NULL; |
| unsigned offset = 0; |
| |
| /* |
| ** Convert the offset to something meaninful (size). |
| */ |
| errno = 0; |
| offset = strtoul(offsetArg, &endOffsetArg, 16); |
| if(0 == errno && endOffsetArg != offsetArg) |
| { |
| void* moved = NULL; |
| |
| /* |
| ** Increase the size of the symbol array in the section. |
| ** Assumed symbols are unique within each section. |
| */ |
| moved = realloc(inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols, sizeof(MSDump_Symbol) * (inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbolCount + 1)); |
| if(NULL != moved) |
| { |
| unsigned symIndex = 0; |
| |
| /* |
| ** Record symbol details. |
| ** Assumed symbols are encountered in order for their section (size calc depends on it). |
| */ |
| symIndex = inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbolCount; |
| inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbolCount++; |
| inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols = (MSDump_Symbol*)moved; |
| memset(&inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex], 0, sizeof(MSDump_Symbol)); |
| |
| inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex].mOffset = offset; |
| |
| /* |
| ** We could allocate smarter here if it ever mattered. |
| */ |
| inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex].mName = strdup(symbolArg); |
| if(NULL != inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex].mName) |
| { |
| char* trim = NULL; |
| |
| trim = (char*)skipNonWhite(inContainer->mReadState.mCurrentObject->mSections[sectionIndex].mSymbols[symIndex].mName); |
| if(NULL != trim) |
| { |
| *trim = '\0'; |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "Unable to duplicate symbol name."); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "Unable to grow symbol array for section."); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "Unable to convert offset to a number."); |
| } |
| } |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "Unable to determine section index."); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "No match for section prefix."); |
| } |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inLine, "Unable to scan for section."); |
| } |
| } |
| |
| return retval; |
| } |
| |
| |
| void dumpCleanup(MSDump_Container* inContainer) |
| /* |
| ** Attempt to be nice and free up what we have allocated. |
| */ |
| { |
| unsigned objectLoop = 0; |
| unsigned sectionLoop = 0; |
| unsigned symbolLoop = 0; |
| |
| for(objectLoop = 0; objectLoop < inContainer->mObjectCount; objectLoop++) |
| { |
| for(sectionLoop = 0; sectionLoop < inContainer->mObjects[objectLoop].mSectionCount; sectionLoop++) |
| { |
| for(symbolLoop = 0; symbolLoop < inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount; symbolLoop++) |
| { |
| CLEANUP(inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mName); |
| } |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount = 0; |
| CLEANUP(inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols); |
| CLEANUP(inContainer->mObjects[objectLoop].mSections[sectionLoop].mType); |
| } |
| inContainer->mObjects[objectLoop].mSectionCount = 0; |
| CLEANUP(inContainer->mObjects[objectLoop].mSections); |
| } |
| CLEANUP(inContainer->mObjects); |
| inContainer->mObjectCount = 0; |
| } |
| |
| |
| int qsortSymOffset(const void* in1, const void* in2) |
| /* |
| ** qsort callback to sort the symbols by their offset. |
| */ |
| { |
| MSDump_Symbol* sym1 = (MSDump_Symbol*)in1; |
| MSDump_Symbol* sym2 = (MSDump_Symbol*)in2; |
| int retval = 0; |
| |
| if(sym1->mOffset < sym2->mOffset) |
| { |
| retval = 1; |
| } |
| else if(sym1->mOffset > sym2->mOffset) |
| { |
| retval = -1; |
| } |
| |
| return retval; |
| } |
| |
| |
| int calcContainer(Options* inOptions, MSDump_Container* inContainer) |
| /* |
| ** Resposible for doing any size calculations based on the offsets known. |
| ** After this calculation, each sections mUsed will match mSize. |
| ** After this calculation, all symbols should know how big they are. |
| */ |
| { |
| int retval = 0; |
| unsigned objectLoop = 0; |
| unsigned sectionLoop = 0; |
| unsigned symbolLoop = 0; |
| |
| |
| /* |
| ** Need to sort all symbols by their offsets. |
| */ |
| for(objectLoop = 0; 0 == retval && objectLoop < inContainer->mObjectCount; objectLoop++) |
| { |
| for(sectionLoop = 0; 0 == retval && sectionLoop < inContainer->mObjects[objectLoop].mSectionCount; sectionLoop++) |
| { |
| qsort( |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols, |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount, |
| sizeof(MSDump_Symbol), |
| qsortSymOffset |
| ); |
| } |
| } |
| |
| |
| /* |
| ** Need to go through all symbols and calculate their size. |
| */ |
| for(objectLoop = 0; 0 == retval && objectLoop < inContainer->mObjectCount; objectLoop++) |
| { |
| for(sectionLoop = 0; 0 == retval && sectionLoop < inContainer->mObjects[objectLoop].mSectionCount; sectionLoop++) |
| { |
| for(symbolLoop = 0; 0 == retval && symbolLoop < inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount; symbolLoop++) |
| { |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mSize = |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mLength - |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mUsed - |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mOffset; |
| |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mUsed += |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mSize; |
| } |
| } |
| } |
| |
| |
| return retval; |
| } |
| |
| |
| int reportContainer(Options* inOptions, MSDump_Container* inContainer) |
| /* |
| ** Display all symbols and their data. |
| ** We'll use a tsv format. |
| */ |
| { |
| int retval = 0; |
| unsigned objectLoop = 0; |
| unsigned sectionLoop = 0; |
| unsigned symbolLoop = 0; |
| int printRes = 0; |
| |
| for(objectLoop = 0; 0 == retval && objectLoop < inContainer->mObjectCount; objectLoop++) |
| { |
| for(sectionLoop = 0; 0 == retval && sectionLoop < inContainer->mObjects[objectLoop].mSectionCount; sectionLoop++) |
| { |
| for(symbolLoop = 0; 0 == retval && symbolLoop < inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbolCount; symbolLoop++) |
| { |
| printRes = fprintf(inOptions->mOutput, "%s\t%s\t%.8X\t%s\n", |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mName, |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mType, |
| inContainer->mObjects[objectLoop].mSections[sectionLoop].mSymbols[symbolLoop].mSize, |
| inContainer->mObjects[objectLoop].mObject |
| ); |
| |
| if(0 > printRes) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inOptions->mOutputName, "Unable to write to file."); |
| } |
| } |
| } |
| } |
| |
| return retval; |
| } |
| |
| |
| int dump2symdb(Options* inOptions) |
| /* |
| ** Convert the input into the output, respecting the options. |
| ** Returns 0 on success. |
| */ |
| { |
| int retval = 0; |
| char lineBuffer[0x800]; |
| MSDump_Container container; |
| |
| memset(&container, 0, sizeof(container)); |
| |
| /* |
| ** Read the file line by line. |
| */ |
| while(0 == retval && NULL != fgets(lineBuffer, sizeof(lineBuffer), inOptions->mInput)) |
| { |
| if(0 != container.mReadState.mSkipLines) |
| { |
| container.mReadState.mSkipLines--; |
| continue; |
| } |
| retval = processLine(inOptions, &container, lineBuffer); |
| } |
| |
| /* |
| ** Perform whatever calculations desired. |
| */ |
| if(0 == retval) |
| { |
| retval = calcContainer(inOptions, &container); |
| } |
| |
| /* |
| ** Output what we know. |
| */ |
| if(0 == retval) |
| { |
| retval = reportContainer(inOptions, &container); |
| } |
| |
| /* |
| ** Cleanup what we've done. |
| */ |
| dumpCleanup(&container); |
| |
| return retval; |
| } |
| |
| |
| int initOptions(Options* outOptions, int inArgc, char** inArgv) |
| /* |
| ** returns int 0 if successful. |
| */ |
| { |
| int retval = 0; |
| int loop = 0; |
| int switchLoop = 0; |
| int match = 0; |
| const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]); |
| Switch* current = NULL; |
| |
| /* |
| ** Set any defaults. |
| */ |
| memset(outOptions, 0, sizeof(Options)); |
| outOptions->mProgramName = inArgv[0]; |
| outOptions->mInput = stdin; |
| outOptions->mInputName = strdup("stdin"); |
| outOptions->mOutput = stdout; |
| outOptions->mOutputName = strdup("stdout"); |
| |
| if(NULL == outOptions->mOutputName || NULL == outOptions->mInputName) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, "stdin/stdout", "Unable to strdup."); |
| } |
| |
| /* |
| ** Go through and attempt to do the right thing. |
| */ |
| for(loop = 1; loop < inArgc && 0 == retval; loop++) |
| { |
| match = 0; |
| current = NULL; |
| |
| for(switchLoop = 0; switchLoop < switchCount && 0 == retval; switchLoop++) |
| { |
| if(0 == strcmp(gSwitches[switchLoop]->mLongName, inArgv[loop])) |
| { |
| match = __LINE__; |
| } |
| else if(0 == strcmp(gSwitches[switchLoop]->mShortName, inArgv[loop])) |
| { |
| match = __LINE__; |
| } |
| |
| if(match) |
| { |
| if(gSwitches[switchLoop]->mHasValue) |
| { |
| /* |
| ** Attempt to absorb next option to fullfill value. |
| */ |
| if(loop + 1 < inArgc) |
| { |
| loop++; |
| |
| current = gSwitches[switchLoop]; |
| current->mValue = inArgv[loop]; |
| } |
| } |
| else |
| { |
| current = gSwitches[switchLoop]; |
| } |
| |
| break; |
| } |
| } |
| |
| if(0 == match) |
| { |
| outOptions->mHelp = __LINE__; |
| retval = __LINE__; |
| ERROR_REPORT(retval, inArgv[loop], "Unknown command line switch."); |
| } |
| else if(NULL == current) |
| { |
| outOptions->mHelp = __LINE__; |
| retval = __LINE__; |
| ERROR_REPORT(retval, inArgv[loop], "Command line switch requires a value."); |
| } |
| else |
| { |
| /* |
| ** Do something based on address/swtich. |
| */ |
| if(current == &gInputSwitch) |
| { |
| CLEANUP(outOptions->mInputName); |
| if(NULL != outOptions->mInput && stdin != outOptions->mInput) |
| { |
| fclose(outOptions->mInput); |
| outOptions->mInput = NULL; |
| } |
| |
| outOptions->mInput = fopen(current->mValue, "r"); |
| if(NULL == outOptions->mInput) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mValue, "Unable to open input file."); |
| } |
| else |
| { |
| outOptions->mInputName = strdup(current->mValue); |
| if(NULL == outOptions->mInputName) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mValue, "Unable to strdup."); |
| } |
| } |
| } |
| else if(current == &gOutputSwitch) |
| { |
| CLEANUP(outOptions->mOutputName); |
| if(NULL != outOptions->mOutput && stdout != outOptions->mOutput) |
| { |
| fclose(outOptions->mOutput); |
| outOptions->mOutput = NULL; |
| } |
| |
| outOptions->mOutput = fopen(current->mValue, "a"); |
| if(NULL == outOptions->mOutput) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mValue, "Unable to open output file."); |
| } |
| else |
| { |
| outOptions->mOutputName = strdup(current->mValue); |
| if(NULL == outOptions->mOutputName) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mValue, "Unable to strdup."); |
| } |
| } |
| } |
| else if(current == &gHelpSwitch) |
| { |
| outOptions->mHelp = __LINE__; |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mLongName, "No handler for command line switch."); |
| } |
| } |
| } |
| |
| return retval; |
| } |
| |
| |
| void cleanOptions(Options* inOptions) |
| /* |
| ** Clean up any open handles. |
| */ |
| { |
| CLEANUP(inOptions->mInputName); |
| if(NULL != inOptions->mInput && stdin != inOptions->mInput) |
| { |
| fclose(inOptions->mInput); |
| } |
| CLEANUP(inOptions->mOutputName); |
| if(NULL != inOptions->mOutput && stdout != inOptions->mOutput) |
| { |
| fclose(inOptions->mOutput); |
| } |
| |
| memset(inOptions, 0, sizeof(Options)); |
| } |
| |
| |
| void showHelp(Options* inOptions) |
| /* |
| ** Show some simple help text on usage. |
| */ |
| { |
| int loop = 0; |
| const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]); |
| const char* valueText = NULL; |
| |
| printf("usage:\t%s [arguments]\n", inOptions->mProgramName); |
| printf("\n"); |
| printf("arguments:\n"); |
| |
| for(loop = 0; loop < switchCount; loop++) |
| { |
| if(gSwitches[loop]->mHasValue) |
| { |
| valueText = " <value>"; |
| } |
| else |
| { |
| valueText = ""; |
| } |
| |
| printf("\t%s%s\n", gSwitches[loop]->mLongName, valueText); |
| printf("\t %s%s", gSwitches[loop]->mShortName, valueText); |
| printf(DESC_NEWLINE "%s\n\n", gSwitches[loop]->mDescription); |
| } |
| |
| printf("This tool takes the output of \"dumpbin /symbols\" to produce a simple\n"); |
| printf("tsv db file of symbols and their respective attributes, like size.\n"); |
| } |
| |
| |
| int main(int inArgc, char** inArgv) |
| { |
| int retval = 0; |
| Options options; |
| |
| retval = initOptions(&options, inArgc, inArgv); |
| if(options.mHelp) |
| { |
| showHelp(&options); |
| } |
| else if(0 == retval) |
| { |
| retval = dump2symdb(&options); |
| } |
| |
| cleanOptions(&options); |
| return retval; |
| } |
| |
