Ghidra is a software reverse engineering (SRE) framework
/* ###
* IP: GHIDRA
*
* Licensed 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.
*/
#include "pdb.h"
#include "find.h"
#include "print.h"
#include "symbol.h"
#include <atlcomcli.h>
#include <comutil.h>
#include <vector>
// Returns a mixture of static strings and allocated strings.
// Abandon all hope of memory management, ye who enter here
std::wstring printVariant( VARIANT & v ) {
// handle results that don't need a format buffer
switch( v.vt ) {
case VT_BOOL://Indicates a Boolean value.
return v.boolVal == 0 ? L"false" : L"true";
case VT_BSTR://Indicates a BSTR string.
return v.bstrVal;
case VT_EMPTY://Indicates that a value was not specified.
return L"empty";
case VT_NULL://Indicates a null reference (Nothing in Visual Basic) value, similar to a null value in SQL.
return L"null";
}
const int blen = 100;
wchar_t variant[blen] = {};
switch( v.vt ) {
case VT_ARRAY://Indicates a SAFEARRAY pointer.
swprintf_s(variant, blen, L"%I64d", (ULONGLONG) v.parray);//TODO
return variant;
case VT_BYREF://Indicates that a value is a reference.
swprintf_s(variant, blen, L"%I64d", (ULONGLONG) v.cVal);//TODO
return variant;
case VT_CY://Indicates a currency value.
swprintf_s(variant, blen, L"%I64d", (ULONGLONG) v.cyVal.int64);
return variant;
case VT_DATE://Indicates a DATE value.
swprintf_s(variant, blen, L"%I64d", (ULONGLONG) v.date);
return variant;
case VT_DISPATCH://Indicates an IDispatch pointer.
swprintf_s(variant, blen, L"%I64d", (ULONGLONG) v.pdispVal);
return variant;
case VT_ERROR://Indicates an SCODE.
swprintf_s(variant, blen, L"0x%x", v.scode);
return variant;
case VT_I1://CHAR
swprintf_s(variant, blen, L"%d", v.cVal);
return variant;
case VT_I2://SHORT
swprintf_s(variant, blen, L"%d", v.iVal);
return variant;
case VT_I4://LONG
swprintf_s(variant, blen, L"%d", v.lVal );
return variant;
case VT_I8: //LONGLONG
swprintf_s(variant, blen, L"%I64d", v.llVal );
return variant;
case VT_INT://INT
swprintf_s(variant, blen, L"%d", v.intVal);
return variant;
case VT_R4://Indicates a float value.
swprintf_s(variant, blen, L"%f", v.fltVal);
return variant;
case VT_R8://Indicates a double value.
swprintf_s(variant, blen, L"%f", v.dblVal);
return variant;
case VT_UI1://BYTE
swprintf_s(variant, blen, L"%d", v.bVal);
return variant;
case VT_UI2://USHORT
swprintf_s(variant, blen, L"%d", v.uiVal);
return variant;
case VT_UI4://ULONG
swprintf_s(variant, blen, L"%d", v.ulVal);
return variant;
case VT_UI8://ULONGLONG
swprintf(variant, blen, L"%I64d", v.ullVal);
return variant;
case VT_UINT://UINT
swprintf_s(variant, blen, L"%d", v.uintVal);
return variant;
case VT_UNKNOWN://Indicates an IUnknown pointer.
swprintf_s(variant, blen, L"%I64d", (ULONGLONG) v.punkVal);
return variant;
case VT_VARIANT://Indicates a VARIANT far pointer.
swprintf_s(variant, blen, L"%I64d", (ULONGLONG) v.pvarVal);
return variant;
default:
return L"unknown";
}
}
void printBound( IDiaSymbol& bound ) {
DWORD tag = 0;
DWORD kind = 0;
bound.get_symTag( &tag );
bound.get_locationType( &kind );
bstr_t name;
if ( tag == SymTagData && kind == LocIsConstant ) {
//TODO
//CComVariant v;
//pBound->get_value( &v );
//printVariant( v );
}
else if ( bound.get_name( name.GetAddress()) == S_OK ) {
printf( "%ws", name.GetBSTR() );
}
}
std::wstring printType( IDiaSymbol * pType, const std::wstring& suffix ) {
if (pType == NULL) {
return L"";
}
std::wstring name = getName(*pType);
DWORD tag = getTag(*pType);
if ( tag == SymTagPointerType ) {
CComPtr<IDiaSymbol> pBaseType;
if ( pType->get_type( &pBaseType ) == S_OK ) {
return printType(pBaseType, suffix + L" *");
}
else {
return L"";
}
}
if ( tag == SymTagBaseType ) {
return getBaseTypeAsString( *pType ) + suffix;
}
if ( tag == SymTagArrayType ) {
CComPtr<IDiaSymbol> pBaseType = getType( *pType );
if ( pBaseType == NULL ) {
return L"";
}
const size_t strLen = suffix.length() + 64 + 3; // length of suffix + wag_for_numeric_value + "[]\0"
std::vector<wchar_t> str(strLen);
swprintf_s(str.data(), strLen, L"%s[%d]", suffix.c_str(), getCount( *pType ));
return printType(pBaseType, str.data());
}
if ( tag == SymTagFunctionType ) {
return L"void *"; // was L"Function" but...
}
if ( tag == SymTagCustomType ) {
DWORD id = 0;
DWORD rec = 0;
GUID guid = GUID_NULL;
if ( pType->get_guid(&guid) == S_OK ) {
const int maxGUIDStrLen = 64 + 1;
std::vector<wchar_t> guidStr(maxGUIDStrLen);
if (StringFromGUID2(guid, guidStr.data(), maxGUIDStrLen) > 0) {
return guidStr.data();
}
}
else if ( pType->get_oemId( &id ) == S_OK && pType->get_oemSymbolId( &rec ) == S_OK ) {
const size_t strLen = 256; // wag_for_2_hex_numbers "0xNNNNN:0xNNNNN"
wchar_t str[strLen] = {};
if (str != NULL) {
swprintf_s(str, L"0x%x:0x%x", id, rec);
return str;
}
}
return L"";
}
if ( !name.empty() ) {
return name + suffix;
}
return L"Undefined";
}
void printScopeName( IDiaSymbol& pscope ) {
printf("<scope name=\"%S\" tag=\"%S\" />\n", getName( pscope ).c_str(), getTagAsString( pscope ).c_str());
}
void printNameFromScope( IDiaSymbol& scope, IDiaEnumSymbols& myEnum ) {
CComPtr<IDiaSymbol> pSym;
DWORD celt = 0;
while ( myEnum.Next( 1, &pSym, &celt ) == S_OK && celt == 1 ) {
printf( "\t%S %S found in ", getTagAsString(*pSym).c_str(), getName(*pSym).c_str() );
printScopeName( scope );
printf( "\n" );
pSym = 0;
}
}