| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_soltools.hxx" |
| |
| #include <string.h> |
| #include <direct.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| #include "ldump.hxx" |
| #include "hashtbl.hxx" |
| |
| #define MAXSYM 65536 |
| #define MAXBASE 98304 |
| #define MAX_MAN 4096 |
| |
| int bFilter = 0; |
| int bLdump3 = 0; |
| int bUseDirectives = 0; |
| int bVerbose = 0; |
| int bExportByName = 0; |
| |
| class ExportSet : public HashTable |
| { |
| public: |
| ExportSet |
| ( |
| unsigned long lSize, |
| double dMaxLoadFactor = HashTable::m_defMaxLoadFactor, |
| double dGrowFactor = HashTable::m_defDefGrowFactor |
| ) |
| : HashTable(lSize,false,dMaxLoadFactor,dGrowFactor) {} |
| |
| virtual ~ExportSet() {} |
| |
| LibExport * Find (char * const& Key) const |
| { return (LibExport *) HashTable::Find((char *) Key); } |
| |
| bool Insert (char * const& Key, LibExport * Object) |
| { return HashTable::Insert((char *) Key, (void*) Object); } |
| |
| LibExport * Delete (char * const&Key) |
| { return (LibExport *) HashTable::Delete ((char *) Key); } |
| }; |
| |
| LibDump::LibDump( char *cFileName, int bExportByName ) |
| : cBName( NULL ), |
| cAPrefix( NULL ), |
| cLibName( NULL ), |
| cFilterName( NULL ), |
| cModName( NULL ) |
| { |
| fprintf( stderr, "LIB-NT File Dumper v4.00 (C) 2000 Sun Microsystems, Inc.\n\n" ); |
| fprintf( stderr, "%s ", cFileName ); |
| |
| bExportName = bExportByName; |
| |
| unsigned long nSlots = 0xfffff; |
| pBaseTab = new ExportSet( nSlots ); |
| pIndexTab = new ExportSet( nSlots ); |
| pFilterLines = new char * [MAXFILT]; |
| CheckLibrary(cFileName); |
| bBase = 0; |
| bAll = false; |
| nDefStart = 0; |
| nBaseLines = 0; |
| nFilterLines = 0; |
| bDef = true; |
| cAPrefix = new char[ 1 ]; |
| cAPrefix[ 0 ] = 0; |
| if (!bExportName) |
| CheckDataBase(); |
| } |
| |
| bool LibDump::Dump() |
| { |
| FILE *pList; |
| char aBuf[MAX_MAN]; |
| int nLen; |
| char aName[MAX_MAN]; |
| |
| pList = fopen( cLibName, "rb"); |
| if (!pList) |
| DumpError(10); |
| |
| // forget about offset when working on linker directives |
| if ( !bUseDirectives ) |
| { |
| // calculating offset for name section |
| unsigned char TmpBuffer[4]; |
| fread( TmpBuffer, 1, 4, pList); |
| // anzahl bigendian mal laenge + ueberspringen der naechsten laengenangabe |
| unsigned long nOffSet = (unsigned long) ( TmpBuffer[2] * 256 + TmpBuffer[3] ) * 4 + 4; |
| fseek( pList, (long) nOffSet, 0); |
| } |
| |
| char aTmpBuf[4096]; |
| // reading file containing symbols |
| while( !feof( pList ) ) |
| { |
| int i = 0; |
| if ( !bUseDirectives ) |
| { |
| // symbol komplett einlesen |
| for (;;) |
| { |
| int c = fgetc( pList ); |
| if ( c == '\0' ) |
| { |
| break; |
| } |
| if ( ((c >= 33) && (c <= 126)) && ( c!=40 && c!=41) ) |
| aBuf[i] = static_cast< char >(c); |
| else |
| { |
| aBuf[0] = '\0'; |
| break; |
| } |
| i++; |
| } |
| // Namen found |
| aBuf[i] = '\0'; |
| } |
| else |
| { |
| fgets( aTmpBuf, 4096, pList ); |
| char * pEnd = 0; |
| char *pFound = 0; |
| aBuf[0] = '\0'; |
| pFound = strchr( aTmpBuf, 'E' ); |
| while ( pFound ) |
| { |
| if ( strncmp( "EXPORT:", pFound, 7) == 0 ) |
| { |
| pFound += 7; |
| pEnd = strchr( pFound, ','); |
| if ( pEnd ) |
| *pEnd = '\0'; |
| strncpy( aBuf, pFound, strlen( pFound)); |
| aBuf[ strlen( pFound) ] = '\0'; |
| // fprintf( stderr, "\n--- %s\n", aBuf); |
| break; |
| } |
| else |
| { |
| pFound++; |
| pFound = strchr( pFound, 'E' ); |
| } |
| } |
| } |
| |
| if ((aBuf[0] =='?') || !strncmp(aBuf, "__CT",4)) |
| { |
| nLen = (int) strlen(aBuf); |
| memset( aName, 0, sizeof( aName ) ); |
| int nName = 0; |
| for( i = 0; i < nLen; i++ ) |
| { |
| if ( (aBuf[i] != '\n') && (aBuf[i] != '\r') ) |
| { |
| aName[nName] = aBuf[i]; |
| nName++; |
| } |
| } |
| // und raus damit |
| PrintSym( aName, bExportByName ); |
| } |
| else if ( bAll == true ) |
| { |
| int nPreLen = (int) strlen( cAPrefix ); |
| |
| nLen = (int) strlen(aBuf); |
| memset( aName, 0, sizeof( aName ) ); |
| int nName = 0; |
| |
| for( i = 0; i < nLen; i++ ) |
| { |
| if ( (aBuf[i] != '\n') && (aBuf[i] != '\r') ) |
| { |
| aName[nName] = aBuf[i]; |
| nName++; |
| } |
| } |
| //fprintf( stderr, "Gefundenen Prefix : %s %d \n", aTmpBuf, nPreLen ); |
| // den ersten _ raus |
| nLen = (int) strlen(aName); |
| if (aName[0] == '_') |
| strcpy( aBuf , &aName[1] ); |
| strncpy ( aTmpBuf, aBuf, (size_t) nPreLen ); |
| aTmpBuf[nPreLen] = '\0'; |
| if ( !strcmp( aTmpBuf, cAPrefix )) |
| { |
| if ( bLdump3 ) { |
| int nChar = '@'; |
| char *pNeu = strchr( aBuf, nChar ); |
| int nPos = pNeu - aBuf + 1; |
| if ( nPos > 0 ) |
| { |
| char aOldBuf[MAX_MAN]; |
| strcpy( aOldBuf, aBuf ); |
| char pChar[MAX_MAN]; |
| strncpy( pChar, aBuf, (size_t) (nPos -1) ); |
| pChar[nPos-1] = '\0'; |
| strcpy( aBuf, pChar ); |
| strcat( aBuf, "=" ); |
| strcat( aBuf, aOldBuf ); |
| strcpy( pChar, "" ); |
| } |
| } |
| // und raus damit |
| PrintSym( aBuf, true ); |
| } |
| } |
| } |
| fclose(pList); |
| return true; |
| } |
| |
| bool LibDump::ReadFilter( char * cFilterName ) |
| { |
| FILE* pfFilter = 0; |
| char aBuf[MAX_MAN]; |
| char* pStr; |
| int nLen; |
| |
| pfFilter = fopen( cFilterName, "r" ); |
| |
| if ( !pfFilter ) |
| { |
| ::bFilter = 0; |
| DumpError( 500 ); |
| } |
| |
| while( fgets( aBuf, MAX_MAN, pfFilter ) != 0 ) |
| { |
| nLen = (int) strlen(aBuf); |
| pStr = new char[(unsigned int) nLen]; |
| if ( !pStr ) |
| DumpError( 98 ); |
| memcpy( pStr, aBuf, (unsigned int) nLen ); |
| if ( *(pStr+nLen-1) == '\n' ) |
| *(pStr+nLen-1) = '\0'; |
| pFilterLines[nFilterLines] = pStr; |
| nFilterLines++; |
| if ( nFilterLines >= MAXFILT ) |
| DumpError( 510 ); |
| } |
| |
| fclose( pfFilter ); |
| return true; |
| } |
| |
| bool LibDump::PrintSym(char *pName, bool bName ) |
| { |
| LibExport *pData; |
| |
| |
| // Filter auswerten |
| if ( Filter( pName ) ) |
| { |
| if ( strlen( pName ) > 3 ) |
| { |
| if ( bDef ) |
| { |
| if (!bBase) |
| if (bExportName) { |
| fprintf( stdout, "\t%s\n", pName ); |
| } else { |
| fprintf( stdout, "\t%s\t\t@%lu\n", pName, nDefStart ); |
| } |
| else |
| { |
| pData = pBaseTab->Find( pName ); |
| if ( pData ) |
| { |
| pData->bExport = true; |
| if ( bName ) |
| pData->bByName = true; |
| else |
| pData->bByName = false; |
| if ( bVerbose ) |
| fprintf(stderr,"."); |
| } |
| else |
| { |
| // neuen Export eintragen |
| pData = new LibExport; |
| pData->cExportName = new char[ strlen( pName ) + 1 ]; |
| strcpy( pData->cExportName, pName ); |
| pData->nOrdinal = nBaseLines++; |
| pData->bExport = true; |
| if ( bName ) |
| pData->bByName = true; |
| else |
| pData->bByName = false; |
| pBaseTab->Insert( pData->cExportName, pData ); |
| char *cBuffer = new char[ 30 ]; |
| sprintf( cBuffer, "%lu", pData->nOrdinal ); |
| pIndexTab->Insert( cBuffer, pData ); |
| delete [] cBuffer; |
| if ( bVerbose ) |
| fprintf(stderr,"n"); |
| } |
| } |
| } |
| else |
| printf( "%s\n", pName ); |
| nDefStart++; |
| } |
| } |
| return true; |
| } |
| |
| bool LibDump::IsFromAnonymousNamespace (char *pExportName) { |
| char* pattern1 = "@?A0x"; |
| |
| if (strstr(pExportName, pattern1)) { |
| return true; |
| }; |
| return false; |
| }; |
| |
| bool LibDump::Filter(char *pExportName) |
| { |
| unsigned long i; |
| char pTest[256]; |
| |
| // filter out symbols from anonymous namespaces |
| if (IsFromAnonymousNamespace (pExportName)) |
| return false; |
| |
| // Kein Filter gesetzt |
| if ( ::bFilter == 0 ) |
| return true; |
| |
| for ( i=0; i<nFilterLines; i++ ) |
| { |
| //Zum vergleichen muá das Plus abgeschnitteb werden |
| if(pFilterLines[i][0] != '+') |
| { |
| if ( strstr( pExportName, pFilterLines[i])) |
| return false; |
| } |
| else |
| { |
| strcpy(pTest,&pFilterLines[i][1]); |
| if ( strstr( pExportName, pTest)) |
| return true; |
| } |
| } |
| return true; |
| } |
| |
| bool LibDump::SetFilter(char * cFilterName) |
| { |
| ReadFilter( cFilterName ); |
| return true; |
| } |
| |
| bool LibDump::CheckLibrary(char * cName) |
| { |
| delete [] cLibName; |
| cLibName = new char[ strlen( cName ) + 1 ]; |
| strcpy( cLibName, cName ); |
| return true; |
| } |
| |
| bool LibDump::ReadDataBase() |
| { |
| FILE* pfBase = 0; |
| char aBuf[MAX_MAN]; |
| char* pStr; |
| char cBuffer[ 30 ]; |
| int nLen; |
| LibExport *pData; |
| |
| pfBase = fopen( cBName, "r" ); |
| |
| if ( !pfBase ) |
| { |
| bBase = 0; |
| DumpError( 600 ); |
| } |
| |
| bool bRet = true; |
| while( fgets( aBuf, MAX_MAN, pfBase ) != 0 ) |
| { |
| nLen = (int) strlen(aBuf); |
| pStr = new char[(unsigned int) nLen]; |
| if ( !pStr ) |
| DumpError( 98 ); |
| memcpy( pStr, aBuf, (size_t) nLen ); |
| if ( *(pStr+nLen-1) == '\n' ) |
| *(pStr+nLen-1) = '\0'; |
| pData = new LibExport; |
| pData->cExportName = pStr; |
| pData->nOrdinal = nBaseLines; |
| pData->bExport=false; |
| |
| if (pBaseTab->Insert(pData->cExportName, pData ) == NULL) |
| bRet = false; |
| ltoa( (long) pData->nOrdinal, cBuffer, 10 ); |
| if (pIndexTab->Insert( cBuffer, pData ) == NULL) |
| bRet = false; |
| nBaseLines++; |
| if ( nBaseLines >= MAXBASE ) |
| DumpError( 610 ); |
| } |
| fclose( pfBase ); |
| return bRet; |
| } |
| |
| class ExportSetIter : public HashTableIterator |
| { |
| public: |
| ExportSetIter(HashTable const& aTable) |
| : HashTableIterator(aTable) {} |
| |
| LibExport * GetFirst() |
| { return (LibExport *)HashTableIterator::GetFirst(); } |
| LibExport * GetNext() |
| { return (LibExport *)HashTableIterator::GetNext(); } |
| LibExport * GetLast() |
| { return (LibExport *)HashTableIterator::GetLast(); } |
| LibExport * GetPrev() |
| { return (LibExport *)HashTableIterator::GetPrev(); } |
| |
| private: |
| void operator =(ExportSetIter &); // not defined |
| }; |
| |
| bool LibDump::PrintDataBase() |
| { |
| if (bExportName) |
| return true; |
| FILE *pFp; |
| pFp = fopen (cBName,"w+"); |
| if (!pFp) |
| fprintf( stderr, "Error opening DataBase File\n" ); |
| |
| LibExport *pData; |
| for ( unsigned long i=0; i < nBaseLines+10; i++ ) |
| { |
| char * cBuffer = new char[ 30 ]; |
| sprintf( cBuffer, "%lu", i ); |
| pData = pIndexTab->Find( cBuffer ); |
| delete [] cBuffer; |
| if ( pData ) |
| fprintf(pFp,"%s\n",pData->cExportName); |
| } |
| fclose(pFp); |
| return true; |
| } |
| |
| bool LibDump::PrintDefFile() |
| { |
| #ifdef FAST |
| ExportSetIter aIterator( *pBaseTab ); |
| for ( LibExport *pData = aIterator.GetFirst(); pData != NULL; |
| pData = aIterator.GetNext() ) |
| { |
| if ( pData->bExport ) |
| { |
| if ( pData->bByName ) |
| { |
| fprintf(stdout,"\t%s\n", |
| pData->sExportName.GetBuffer()); |
| } |
| else |
| { |
| fprintf(stdout,"\t%s\t\t@%d NONAME\n", |
| pData->sExportName.GetBuffer(), pData->nOrdinal+nBegin); |
| } |
| } |
| } |
| #else |
| // sortiert nach Ordinals; |
| LibExport *pData; |
| for ( unsigned long i=0; i<nBaseLines+1; i++) |
| { |
| char * cBuffer = new char[ 30 ]; |
| sprintf( cBuffer, "%lu", i ); |
| pData = pIndexTab->Find( cBuffer ); |
| delete [] cBuffer; |
| if ( pData ) |
| if ( pData->bExport ) |
| { |
| if ( pData->bByName ) |
| { |
| if ( strlen( pData->cExportName )) |
| fprintf(stdout,"\t%s\n", |
| pData->cExportName); |
| } |
| else |
| { |
| if ( strlen( pData->cExportName )) |
| fprintf(stdout,"\t%s\t\t@%d NONAME\n", |
| pData->cExportName, pData->nOrdinal+nBegin); |
| } |
| } |
| } |
| #endif |
| return true; |
| } |
| |
| bool LibDump::CheckDataBase() |
| { |
| // existiert eine Datenbasis ? |
| if (!bBase) |
| { |
| cBName = new char[ 2048 ]; |
| char *pTmp = "defs\\"; |
| |
| FILE *fp; |
| #ifdef OS2 |
| _mkdir ("defs", 0777); |
| #else |
| _mkdir ("defs"); |
| #endif |
| strcpy(cBName,pTmp); |
| #ifdef OS2 |
| strcat(cBName,"gcc"); |
| #else |
| strcat(cBName,getenv ("COMP_ENV")); |
| #endif |
| |
| fp = fopen (cBName,"r"); |
| if (fp) |
| { |
| bBase = true; |
| } |
| else |
| { |
| fp = fopen (cBName,"w+"); |
| bBase = true; |
| } |
| fclose (fp); |
| } |
| // lese Datenbasis ! |
| if (bBase) |
| { |
| ReadDataBase(); |
| } |
| return true; |
| } |
| |
| LibDump::~LibDump() |
| { |
| delete [] cBName; |
| delete [] cAPrefix; |
| // delete [] cLibName; |
| delete [] cFilterName; |
| delete [] cModName; |
| } |
| |
| void LibDump::SetCExport( char* pName ) |
| { |
| delete [] cAPrefix; |
| cAPrefix = new char[ strlen( pName ) + 1 ]; |
| strcpy( cAPrefix, pName );bAll = true; |
| } |
| |
| //****************************************************************** |
| //* Error() - Gibt Fehlermeldumg aus |
| //****************************************************************** |
| |
| void LibDump::DumpError( unsigned long n ) |
| { |
| char *p; |
| |
| switch (n) |
| { |
| case 1: p = "Input error in library file"; break; |
| case 2: p = "Position error in library file (no THEADR set)"; break; |
| case 3: p = "Overflow of symbol table"; break; |
| #ifdef WNT |
| case 10: p = "EXP file not found"; break; |
| case 11: p = "No valid EXP file"; break; |
| #else |
| case 10: p = "Library file not found"; break; |
| case 11: p = "No valid library file"; break; |
| #endif |
| case 98: p = "Out of memory"; break; |
| case 99: p = "LDUMP [-LD3] [-D] [-N] [-A] [-E nn] [-F name] Filename[.LIB]\n" |
| "-LD3 : Supports feature set of ldump3 (default: ldump/ldump2)\n" |
| "-A : all symbols (default: only C++)\n" |
| "-E nn : gerenration of export table beginning with number nn\n" |
| "-F name: Filter file\n" |
| "-D : file contains \"dumpbin\" directives\n" |
| "-N : export by name\n" |
| "-V : be verbose\n"; break; |
| case 500: p = "Unable to open filter file\n"; break; |
| case 510: p = "Overflow of filter table\n"; break; |
| case 600: p = "Unable to open base database file\n"; break; |
| case 610: p = "Overflow in base database table\n"; break; |
| default: p = "Unspecified error"; |
| } |
| fprintf( stdout, "%s\n", p ); |
| exit (1); |
| } |
| |
| /********************************************************************* |
| Test Funktionen |
| *********************************************************************/ |
| |
| |
| void usage() |
| { |
| LibDump::DumpError(99); |
| } |
| |
| #define STATE_NON 0x0000 |
| #define STATE_BEGIN 0x0001 |
| #define STATE_FILTER 0x0002 |
| #define STATE_CEXPORT 0x0003 |
| |
| int |
| #ifdef WNT |
| __cdecl |
| #endif |
| main( int argc, char **argv ) |
| { |
| char *pLibName = NULL, *pFilterName = NULL, *pCExport= NULL; |
| unsigned short nBegin=1; |
| |
| unsigned short nState = STATE_NON; |
| |
| if ( argc == 1 ) { |
| usage(); |
| } |
| |
| for ( int i = 1; i < argc; i++ ) { |
| if (( !strcmp( argv[ i ], "-H" )) || |
| ( !strcmp( argv[ i ], "-h" )) || |
| ( !strcmp( argv[ i ], "-?" ))) |
| { |
| usage(); |
| } |
| else if (( !strcmp( argv[ i ], "-LD3" )) || |
| ( !strcmp( argv[ i ], "-Ld3" )) || |
| ( !strcmp( argv[ i ], "-ld3" )) || |
| ( !strcmp( argv[ i ], "-lD3" ))) |
| { |
| if ( nState != STATE_NON ) { |
| usage(); |
| } |
| bLdump3 = 1; |
| } |
| else if (( !strcmp( argv[ i ], "-E" )) || ( !strcmp( argv[ i ], "-e" ))) { |
| if ( nState != STATE_NON ) { |
| usage(); |
| } |
| nState = STATE_BEGIN; |
| } |
| else if (( !strcmp( argv[ i ], "-F" )) || ( !strcmp( argv[ i ], "-f" ))) { |
| if ( nState != STATE_NON ) { |
| usage(); |
| } |
| nState = STATE_FILTER; |
| } |
| else if (( !strcmp( argv[ i ], "-A" )) || ( !strcmp( argv[ i ], "-a" ))) { |
| if ( nState != STATE_NON ) { |
| usage(); |
| } |
| nState = STATE_CEXPORT; |
| pCExport = new char[ 1 ]; |
| pCExport[ 0 ] = 0; |
| } |
| else if (( !strcmp( argv[ i ], "-D" )) || ( !strcmp( argv[ i ], "-d" ))) { |
| if ( nState != STATE_NON ) { |
| usage(); |
| } |
| bUseDirectives = 1; |
| } |
| else if (( !strcmp( argv[ i ], "-N" )) || ( !strcmp( argv[ i ], "-n" ))) { |
| if ( nState != STATE_NON ) { |
| usage(); |
| } |
| bExportByName = 1; |
| } |
| else if (( !strcmp( argv[ i ], "-V" )) || ( !strcmp( argv[ i ], "-v" ))) { |
| if ( nState != STATE_NON ) { |
| usage(); |
| } |
| bVerbose = 1; |
| } |
| else { |
| switch ( nState ) { |
| case STATE_BEGIN: |
| nBegin = static_cast< unsigned short >(atoi( argv[ i ] )); |
| nState = STATE_NON; |
| break; |
| case STATE_FILTER: |
| pFilterName = new char[ strlen( argv[ i ] ) + 1 ]; |
| strcpy( pFilterName, argv[ i ] ); |
| bFilter = 1; |
| nState = STATE_NON; |
| break; |
| case STATE_CEXPORT: |
| delete [] pCExport; |
| pCExport = new char[ strlen( argv[ i ] ) + 1 ]; |
| strcpy( pCExport, argv[ i ] ); |
| nState = STATE_NON; |
| break; |
| default: |
| pLibName = new char[ strlen( argv[ i ] ) + 1 ]; |
| strcpy( pLibName, argv[ i ] ); |
| break; |
| } |
| } |
| } |
| |
| if ( !pLibName ) { |
| usage(); |
| } |
| |
| LibDump *pDump = new LibDump( pLibName, bExportByName ); |
| pDump->SetBeginExport(nBegin); |
| if ( bFilter != 0 ) |
| pDump->SetFilter( pFilterName ); |
| if ( pCExport ) |
| pDump->SetCExport( pCExport ); |
| else { |
| char *pEmpty = ""; |
| pDump->SetCExport( pEmpty ); |
| } |
| pDump->Dump(); |
| pDump->PrintDefFile(); |
| pDump->PrintDataBase(); |
| delete pDump; |
| return 0; |
| } |
