bool AddressBook::GetIdentHash (const std::string& address, i2p::data::IdentHash& ident)
{
auto pos = address.find(".b32.i2p");
if (pos != std::string::npos)
{
i2p::util::Base32ToByteStream (address.c_str(), pos, ident, 32);
return true;
}
else
{
pos = address.find (".i2p");
if (pos != std::string::npos)
{
auto identHash = FindAddress (address);
if (identHash)
{
ident = *identHash;
return true;
}
else
return false;
}
}
// if not .b32 we assume full base64 address
i2p::data::IdentityEx dest;
if (!dest.FromBase64 (address))
return false;
ident = dest.GetIdentHash ();
return true;
}
treeNode * FindAddress(treeNode *node, ADDRINT address)
{
if(node==NULL)
{
/* Element is not found */
return NULL;
}
if(address > node->address)
{
/* Search in the right sub tree. */
return FindAddress(node->right,address);
}
else if(address < node->address)
{
/* Search in the left sub tree. */
return FindAddress(node->left,address);
}
else
{
/* Element Found */
return node;
}
}
CPointer* CBinaryFile::FindPointer(object oIdentifier, int iOffset, unsigned int iLevel)
{
CPointer* ptr = FindAddress(oIdentifier);
if (ptr->IsValid())
{
ptr->m_ulAddr += iOffset;
while (iLevel > 0)
{
ptr = ptr->GetPtr();
iLevel = iLevel - 1;
}
}
return ptr;
}
/*
* Free
* Delete Allocation Info from BST
*/
VOID Free( CONTEXT * context, AFUNPTR orgFuncptr, void * ptr)
{
if(ptr != NULL)
{
if(!FindAddress(malloc_root, (ADDRINT)ptr))
{
PIN_RWMutexWriteLock(&malloc_lock);
malloc_root = DeleteMAddress(malloc_root, (ADDRINT)ptr);
PIN_RWMutexUnlock(&malloc_lock);
}
}
PIN_CallApplicationFunction( context, PIN_ThreadId(),
CALLINGSTD_DEFAULT, orgFuncptr,
PIN_PARG(void),
PIN_PARG(void *), ptr,
PIN_PARG_END() );
}
VOID * Realloc( CONTEXT * context, AFUNPTR orgFuncptr, void * ptr, size_t size)
{
VOID * ret;
PIN_CallApplicationFunction( context, PIN_ThreadId(),
CALLINGSTD_DEFAULT, orgFuncptr,
PIN_PARG(void *), &ret,
PIN_PARG(void *), ptr,
PIN_PARG(size_t), size,
PIN_PARG_END() );
PIN_RWMutexWriteLock(&malloc_lock);
if(ptr != NULL)
{
if(!FindAddress(malloc_root, (ADDRINT)ret))
{
malloc_root = DeleteMAddress(malloc_root, (ADDRINT)ptr);
malloc_root = InsertMAddress(malloc_root, (ADDRINT)ret, size, 0);
}
}
PIN_RWMutexUnlock(&malloc_lock);
return ret;
}
BOOL
ParseIntelAddress(
int *pMode,
WORD *pSelector,
PULONG pOffset
)
{
char sel_text[128], off_text[128];
char expr_text[256];
char *colon;
char *mode_prefix;
WORD segment;
char filename[9];
colon = strchr( lpArgumentString, ':' );
if ( colon == NULL ) {
LPSTR pSymbol = lpArgumentString;
BOOL bResult;
char chTemp;
SkipToNextWhiteSpace();
chTemp = *lpArgumentString;
*lpArgumentString = 0;
bResult = FindAddress( pSymbol,
filename,
&segment,
pSelector,
pOffset,
pMode,
FALSE);
*lpArgumentString = chTemp;
if (bResult) {
if (*pMode == NOT_LOADED) {
PRINTF("Could not determine base of '%s'\n", pSymbol);
return FALSE;
} else {
return TRUE;
}
} else {
PRINTF("Could not find symbol: %s\n", pSymbol);
return FALSE;
}
}
*pMode = GetContext( &ThreadContext );
mode_prefix = strchr( lpArgumentString, '&' );
if ( mode_prefix == NULL ) {
mode_prefix = strchr( lpArgumentString, '#' );
if ( mode_prefix != NULL ) {
if ( mode_prefix != lpArgumentString ) {
PRINTF("Address must have '&' symbol as the first character\n");
return FALSE;
}
*pMode = PROT_MODE;
lpArgumentString = mode_prefix+1;
}
} else {
if ( mode_prefix != lpArgumentString ) {
PRINTF("Address must have '#' symbol as the first character\n");
return FALSE;
}
*pMode = V86_MODE;
lpArgumentString = mode_prefix+1;
}
*colon = '\0';
strcpy( sel_text, lpArgumentString );
*colon = ':';
strcpy( off_text, colon+1 );
ParseForIntelRegisters(expr_text, sel_text);
*pSelector = (WORD) EXPRESSION( expr_text );
ParseForIntelRegisters(expr_text, off_text);
*pOffset = (ULONG) EXPRESSION( expr_text );
SkipToNextWhiteSpace();
return TRUE;
}