static URI_INLINE int URI_FUNC(UriStringToFilename)(const URI_CHAR * uriString,
URI_CHAR * filename, UriBool toUnix) {
const URI_CHAR * const prefix = toUnix ? _UT("file://") : _UT("file:///");
const int prefixLen = toUnix ? 7 : 8;
URI_CHAR * walker = filename;
size_t charsToCopy;
const UriBool absolute = (URI_STRNCMP(uriString, prefix, prefixLen) == 0);
const int charsToSkip = (absolute ? prefixLen : 0);
charsToCopy = URI_STRLEN(uriString + charsToSkip) + 1;
memcpy(filename, uriString + charsToSkip, charsToCopy * sizeof(URI_CHAR));
URI_FUNC(UnescapeInPlaceEx)(filename, URI_FALSE, URI_BR_DONT_TOUCH);
/* Convert forward slashes to backslashes */
if (!toUnix) {
while (walker[0] != _UT('\0')) {
if (walker[0] == _UT('/')) {
walker[0] = _UT('\\');
}
walker++;
}
}
return URI_SUCCESS;
}
static void dbg_dump_sf_prefixes(struct STREAM *stream, uint8_t *sf_prefixes, int sf_prefixes_len)
{
int i;
if (!sf_prefixes)
{
safe_unistrncpy(stream, _UT("unknown"));
}
else
{
if (!sf_prefixes_len)
safe_unistrncpy(stream, _UT("none"));
else
{
for(i = 0; i < sf_prefixes_len; i++)
{
itoa(stream, sf_prefixes[i], 0x1, 0x0, 0x10);
safe_unistrncpy(stream, _UT(", "));
}
}
}
stream ->bufflen += 2;
stream ->buff -= 2;
stream ->reallen -= 2;
}
static void dbg_dump_flags(struct STREAM *stream, struct INSTRUCTION *instr)
{
if (!instr ->flags)
safe_unistrncpy(stream, _UT("none"));
else
{
if (instr ->flags & INSTR_FLAG_MODRM)
{
safe_unistrncpy(stream, _UT("MODRM ("));
itoa(stream, instr ->modrm, 0x1, 0x0, 0x10);
safe_unistrncpy(stream, _UT("), "));
}
if (instr ->flags & INSTR_FLAG_SIB)
{
safe_unistrncpy(stream, _UT("SIB ("));
itoa(stream, instr ->sib, 0x1, 0x0, 0x10);
safe_unistrncpy(stream, _UT("), "));
}
if (instr ->flags & INSTR_FLAG_SF_PREFIXES)
safe_unistrncpy(stream, _UT("SF_PREFIXES, "));
if (instr ->flags & INSTR_FLAG_IOPL)
safe_unistrncpy(stream, _UT("IOPL, "));
if (instr ->flags & INSTR_FLAG_RING0)
safe_unistrncpy(stream, _UT("RING0, "));
if (instr ->flags & INSTR_FLAG_SERIAL)
safe_unistrncpy(stream, _UT("SERIAL, "));
if (instr ->flags & INSTR_FLAG_UNDOC)
safe_unistrncpy(stream, _UT("UNDOC, "));
stream ->bufflen += 2;
stream ->buff -= 2;
stream ->reallen -= 2;
}
}
static URI_INLINE int URI_FUNC(UriStringToFilename)(const URI_CHAR * uriString,
URI_CHAR * filename, UriBool toUnix) {
if ((uriString == NULL) || (filename == NULL)) {
return URI_ERROR_NULL;
}
{
const UriBool file_two_slashes =
URI_STRNCMP(uriString, _UT("file://"), URI_STRLEN(_UT("file://"))) == 0;
const UriBool file_three_slashes = file_two_slashes
&& (URI_STRNCMP(uriString, _UT("file:///"), URI_STRLEN(_UT("file:///"))) == 0);
const size_t charsToSkip = file_two_slashes
? file_three_slashes
? toUnix
/* file:///bin/bash */
? URI_STRLEN(_UT("file://"))
/* file:///E:/Documents%20and%20Settings */
: URI_STRLEN(_UT("file:///"))
/* file://Server01/Letter.txt */
: URI_STRLEN(_UT("file://"))
: 0;
const size_t charsToCopy = URI_STRLEN(uriString + charsToSkip) + 1;
const UriBool is_windows_network_with_authority =
(toUnix == URI_FALSE)
&& file_two_slashes
&& ! file_three_slashes;
URI_CHAR * const unescape_target = is_windows_network_with_authority
? (filename + 2)
: filename;
if (is_windows_network_with_authority) {
filename[0] = '\\';
filename[1] = '\\';
}
memcpy(unescape_target, uriString + charsToSkip, charsToCopy * sizeof(URI_CHAR));
URI_FUNC(UnescapeInPlaceEx)(filename, URI_FALSE, URI_BR_DONT_TOUCH);
}
/* Convert forward slashes to backslashes */
if (!toUnix) {
URI_CHAR * walker = filename;
while (walker[0] != _UT('\0')) {
if (walker[0] == _UT('/')) {
walker[0] = _UT('\\');
}
walker++;
}
}
return URI_SUCCESS;
}
static void dbg_dump_eflags(struct STREAM *stream, uint8_t flags)
{
if (!flags)
safe_unistrncpy(stream, _UT("none"));
else
{
if (flags & EFLAG_O)
safe_unistrncpy(stream, _UT("OF, "));
if (flags & EFLAG_D)
safe_unistrncpy(stream, _UT("DF, "));
if (flags & EFLAG_I)
safe_unistrncpy(stream, _UT("IF, "));
if (flags & EFLAG_S)
safe_unistrncpy(stream, _UT("SF, "));
if (flags & EFLAG_Z)
safe_unistrncpy(stream, _UT("ZF, "));
if (flags & EFLAG_A)
safe_unistrncpy(stream, _UT("AF, "));
if (flags & EFLAG_P)
safe_unistrncpy(stream, _UT("PF, "));
if (flags & EFLAG_C)
safe_unistrncpy(stream, _UT("CF, "));
stream ->bufflen += 2;
stream ->buff -= 2;
stream ->reallen -= 2;
}
}
static int internal_dump_prefixes(struct STREAM *stream, struct INSTRUCTION *instr)
{
if (instr ->prefixes & INSTR_PREFIX_LOCK)
safe_unistrncpy(stream, _UT("lock "));
if (instr ->prefixes & INSTR_PREFIX_REPZ)
safe_unistrncpy(stream, _UT("repz "));
if (instr ->prefixes & INSTR_PREFIX_REPNZ)
safe_unistrncpy(stream, _UT("repnz "));
return stream ->reallen;
}
int medi_dump(struct INSTRUCTION *instr, unichar_t *buff, int bufflen, int options)
{
struct STREAM stream;
stream.buff = buff;
stream.bufflen = bufflen;
stream.options = options;
stream.reallen = 0;
internal_dump_prefixes(&stream, instr);
internal_dump_mnemonic(&stream, instr);
if (instr ->ops[0].flags & OPERAND_FLAG_PRESENT)
{
unsigned int i;
safe_copy_unichar(&stream, ' ');
for (i = 0; i < 3; i++)
{
if (instr ->ops[i].flags & OPERAND_FLAG_PRESENT)
{
internal_dump_operand(&stream, instr, i);
safe_unistrncpy(&stream, _UT(", "));
}
}
stream.reallen -= 2;
stream.bufflen += 2;
stream.buff += 2;
}
return stream.reallen;
}
static int internal_dump_operand(struct STREAM *stream, struct INSTRUCTION *instr, int op_index)
{
struct OPERAND *op;
if (op_index > 3 || op_index < 0)
return -1;
op = instr ->ops + op_index;
if (op ->flags & OPERAND_FLAG_PRESENT)
{
switch (op ->flags & OPERAND_TYPE_MASK)
{
case OPERAND_TYPE_REG:
dump_reg(stream, op ->value.reg.type, op ->value.reg.code, op ->size);
break;
case OPERAND_TYPE_MEM:
dump_addr(stream, instr, op);
break;
case OPERAND_TYPE_IMM:
dump_imm(stream, op);
break;
case OPERAND_TYPE_DIR:
dump_dir(stream, op);
break;
default:
safe_unistrncpy(stream, _UT("internal error"));
break;
}
}
return stream ->reallen;
}
static void dump_reg(struct STREAM *stream, uint8_t type, uint8_t code, uint16_t size)
{
switch(type)
{
case REG_TYPE_GEN:
dump_reg_gen(stream, code, size);
break;
case REG_TYPE_SEG:
dump_reg_sreg(stream, code);
break;
case REG_TYPE_FPU:
dump_reg_freg(stream, code);
break;
case REG_TYPE_CR:
dump_reg_creg(stream, code);
break;
case REG_TYPE_DBG:
dump_reg_dreg(stream, code);
break;
case REG_TYPE_TR:
dump_reg_treg(stream, code);
break;
case REG_TYPE_MMX:
dump_reg_mreg(stream, code);
break;
case REG_TYPE_XMM:
dump_reg_xreg(stream, code);
break;
default:
safe_unistrncpy(stream, _UT("internal error"));
break;
}
}
/*
* [ipFourAddress]->[decOctet]<.>[decOctet]<.>[decOctet]<.>[decOctet]
*/
int URI_FUNC(ParseIpFourAddress)(unsigned char * octetOutput,
const URI_CHAR * first, const URI_CHAR * afterLast) {
const URI_CHAR * after;
UriIp4Parser parser;
/* Essential checks */
if ((octetOutput == NULL) || (first == NULL)
|| (afterLast <= first)) {
return URI_ERROR_SYNTAX;
}
/* Reset parser */
parser.stackCount = 0;
/* Octet #1 */
after = URI_FUNC(ParseDecOctet)(&parser, first, afterLast);
if ((after == NULL) || (after >= afterLast) || (*after != _UT('.'))) {
return URI_ERROR_SYNTAX;
}
uriStackToOctet(&parser, octetOutput);
/* Octet #2 */
after = URI_FUNC(ParseDecOctet)(&parser, after + 1, afterLast);
if ((after == NULL) || (after >= afterLast) || (*after != _UT('.'))) {
return URI_ERROR_SYNTAX;
}
uriStackToOctet(&parser, octetOutput + 1);
/* Octet #3 */
after = URI_FUNC(ParseDecOctet)(&parser, after + 1, afterLast);
if ((after == NULL) || (after >= afterLast) || (*after != _UT('.'))) {
return URI_ERROR_SYNTAX;
}
uriStackToOctet(&parser, octetOutput + 2);
/* Octet #4 */
after = URI_FUNC(ParseDecOctet)(&parser, after + 1, afterLast);
if (after != afterLast) {
return URI_ERROR_SYNTAX;
}
uriStackToOctet(&parser, octetOutput + 3);
return URI_SUCCESS;
}
static int __cdecl dprintf(int flags, LPCTSTR pszFormat, ...)
{
if (!(DebugFlags & flags))
return 0;
va_list va;
va_start(va, pszFormat);
int cch = bvprintf(g_bprint, pszFormat, va);
va_end(va);
// if this string ended in \n, flush the bprint buffer.
if (g_bprint.cch > 0 && g_bprint.psz[g_bprint.cch-1] == _UT('\n'))
bprint_Write();
return cch;
}
static void dump_dir(struct STREAM *stream, struct OPERAND *op)
{
switch (op ->size)
{
case OPERAND_SIZE_32:
itoa(stream, op ->value.far_addr.far_addr32.seg, 0x2, 0x0, 0x10);
safe_copy_unichar(stream, ':');
itoa(stream, op ->value.far_addr.far_addr32.offset, 0x2, 0x0, 0x10);
break;
case OPERAND_SIZE_48:
itoa(stream, op ->value.far_addr.far_addr48.seg, 0x2, 0x0, 0x10);
safe_copy_unichar(stream, ':');
itoa(stream, op ->value.far_addr.far_addr48.offset, 0x4, 0x0, 0x10);
break;
default:
safe_unistrncpy(stream, _UT("internal error"));
break;
}
}
static void itoa(struct STREAM *stream, uint64_t num, uint16_t size, int is_signed, int radix)
{
char dig;
uint64_t div;
uint64_t tmp;
div = 1;
if (is_signed)
{
uint8_t *ptr = (uint8_t *)#
ptr += size - 1;
if (*ptr & 0x80)
{
safe_copy_unichar(stream, '-');
num = ~num; //Just to shut up warning.
num++;
}
}
tmp = 0xFFFFFFFFFFFFFFFFL;
for(size = 8 - size + 1; size; size--)
{
num &= tmp;
tmp >>= 0x8;
}
if (radix == 0x10)
safe_unistrncpy(stream, _UT("0x"));
while(num / div >= radix)
div *= radix;
while(div)
{
dig = (uint8_t)((num / div) % radix);
if (dig >= 10)
dig += 'A' - 10;
else
dig += '0';
safe_copy_unichar(stream, dig);
div /= radix;
}
}
/*
* [decOctetFour]-><NULL>
* [decOctetFour]-><0>
* [decOctetFour]-><1>
* [decOctetFour]-><2>
* [decOctetFour]-><3>
* [decOctetFour]-><4>
* [decOctetFour]-><5>
*/
static URI_INLINE const URI_CHAR * URI_FUNC(ParseDecOctetFour)(UriIp4Parser * parser,
const URI_CHAR * first, const URI_CHAR * afterLast) {
if (first >= afterLast) {
return afterLast;
}
switch (*first) {
case _UT('0'):
case _UT('1'):
case _UT('2'):
case _UT('3'):
case _UT('4'):
case _UT('5'):
uriPushToStack(parser, (unsigned char)(9 + *first - _UT('9')));
return first + 1;
default:
return first;
}
}
#include <stdio.h>
#include "mediana.h"
struct STREAM
{
unichar_t *buff;
int bufflen;
unsigned int reallen;
unsigned int options;
};
#if defined(MEDIANA_CTRL_DUMP) || defined(MEDIANA_CTRL_DBG_DUMP)
unichar_t *regs8[] =
{
_UT("al"), _UT("cl"), _UT("dl"), _UT("bl"), _UT("ah"), _UT("ch"), _UT("dh"), _UT("bh"),
_UT("r8b"), _UT("r9b"), _UT("r10b"), _UT("r11b"), _UT("r12b"), _UT("r13b"), _UT("r14b"), _UT("r15b"),
_UT("spl"), _UT("bpl"), _UT("sil"), _UT("dil"), _UT("badreg8")
};
unichar_t *regs16[] =
{
_UT("ax"), _UT("cx"), _UT("dx"), _UT("bx"), _UT("sp"), _UT("bp"), _UT("si"), _UT("di"),
_UT("r8w"), _UT("r9w"), _UT("r10w"), _UT("r11w"), _UT("r12w"), _UT("r13w"), _UT("r14w"), _UT("r15w"),
_UT("badreg16_1"), _UT("badreg16_2"), _UT("badreg16_3"), _UT("badreg16_4"), _UT("badreg16_5"),
};
unichar_t *regs32[] =
{
_UT("eax"), _UT("ecx"), _UT("edx"), _UT("ebx"), _UT("esp"), _UT("ebp"), _UT("esi"), _UT("edi"),
_UT("r8d"), _UT("r9d"), _UT("r10d"), _UT("r11d"), _UT("r12d"), _UT("r13d"), _UT("r14d"), _UT("r15d"),
/*
* [decOctet]-><0>
* [decOctet]-><1>[decOctetOne]
* [decOctet]-><2>[decOctetTwo]
* [decOctet]-><3>[decOctetThree]
* [decOctet]-><4>[decOctetThree]
* [decOctet]-><5>[decOctetThree]
* [decOctet]-><6>[decOctetThree]
* [decOctet]-><7>[decOctetThree]
* [decOctet]-><8>[decOctetThree]
* [decOctet]-><9>[decOctetThree]
*/
static URI_INLINE const URI_CHAR * URI_FUNC(ParseDecOctet)(UriIp4Parser * parser,
const URI_CHAR * first, const URI_CHAR * afterLast) {
if (first >= afterLast) {
return NULL;
}
switch (*first) {
case _UT('0'):
uriPushToStack(parser, 0);
return first + 1;
case _UT('1'):
uriPushToStack(parser, 1);
return (const URI_CHAR *)URI_FUNC(ParseDecOctetOne)(parser, first + 1, afterLast);
case _UT('2'):
uriPushToStack(parser, 2);
return (const URI_CHAR *)URI_FUNC(ParseDecOctetTwo)(parser, first + 1, afterLast);
case _UT('3'):
case _UT('4'):
case _UT('5'):
case _UT('6'):
case _UT('7'):
case _UT('8'):
case _UT('9'):
uriPushToStack(parser, (unsigned char)(9 + *first - _UT('9')));
return (const URI_CHAR *)URI_FUNC(ParseDecOctetThree)(parser, first + 1, afterLast);
default:
return NULL;
}
}
static URI_INLINE int URI_FUNC(FilenameToUriString)(const URI_CHAR * filename,
URI_CHAR * uriString, UriBool fromUnix) {
const URI_CHAR * input = filename;
const URI_CHAR * lastSep = input - 1;
UriBool firstSegment = URI_TRUE;
URI_CHAR * output = uriString;
UriBool absolute;
UriBool is_windows_network;
if ((filename == NULL) || (uriString == NULL)) {
return URI_ERROR_NULL;
}
is_windows_network = (filename[0] == _UT('\\')) && (filename[1] == _UT('\\'));
absolute = fromUnix
? (filename[0] == _UT('/'))
: ((filename[0] != _UT('\0')) && (filename[1] == _UT(':'))
|| is_windows_network);
if (absolute) {
const URI_CHAR * const prefix = fromUnix
? _UT("file://")
: is_windows_network
? _UT("file:")
: _UT("file:///");
const int prefixLen = URI_STRLEN(prefix);
/* Copy prefix */
memcpy(uriString, prefix, prefixLen * sizeof(URI_CHAR));
output += prefixLen;
}
/* Copy and escape on the fly */
for (;;) {
if ((input[0] == _UT('\0'))
|| (fromUnix && input[0] == _UT('/'))
|| (!fromUnix && input[0] == _UT('\\'))) {
/* Copy text after last seperator */
if (lastSep + 1 < input) {
if (!fromUnix && absolute && (firstSegment == URI_TRUE)) {
/* Quick hack to not convert "C:" to "C%3A" */
const int charsToCopy = (int)(input - (lastSep + 1));
memcpy(output, lastSep + 1, charsToCopy * sizeof(URI_CHAR));
output += charsToCopy;
} else {
output = URI_FUNC(EscapeEx)(lastSep + 1, input, output,
URI_FALSE, URI_FALSE);
}
}
firstSegment = URI_FALSE;
}
if (input[0] == _UT('\0')) {
output[0] = _UT('\0');
break;
} else if (fromUnix && (input[0] == _UT('/'))) {
/* Copy separators unmodified */
output[0] = _UT('/');
output++;
lastSep = input;
} else if (!fromUnix && (input[0] == _UT('\\'))) {
/* Convert backslashes to forward slashes */
output[0] = _UT('/');
output++;
lastSep = input;
}
input++;
}
return URI_SUCCESS;
}
static void dump_ptr_size(struct STREAM *stream, struct OPERAND *op)
{
switch(op ->size)
{
case OPERAND_SIZE_8:
safe_unistrncpy(stream, _UT("byte ptr"));
break;
case OPERAND_SIZE_16:
safe_unistrncpy(stream, _UT("word ptr"));
break;
case OPERAND_SIZE_32:
safe_unistrncpy(stream, _UT("dword ptr"));
break;
case OPERAND_SIZE_48:
safe_unistrncpy(stream, _UT("fword ptr"));
break;
case OPERAND_SIZE_64:
safe_unistrncpy(stream, _UT("qword ptr"));
break;
case OPERAND_SIZE_80:
safe_unistrncpy(stream, _UT("tbyte ptr"));
break;
case OPERAND_SIZE_128:
safe_unistrncpy(stream, _UT("dqword ptr"));
break;
case OPERAND_SIZE_14:
safe_unistrncpy(stream, _UT("14bytes ptr"));
break;
case OPERAND_SIZE_28:
safe_unistrncpy(stream, _UT("28bytes ptr"));
break;
case OPERAND_SIZE_94:
safe_unistrncpy(stream, _UT("94bytes ptr"));
break;
case OPERAND_SIZE_108:
safe_unistrncpy(stream, _UT("108bytes ptr"));
break;
case OPERAND_SIZE_512:
safe_unistrncpy(stream, _UT("512bytes ptr"));
break;
default:
safe_unistrncpy(stream, _UT("strange ptr"));
break;
}
}
# include <uriparser/UriDefsAnsi.h>
# else
# include <uriparser/UriDefsUnicode.h>
# include <wchar.h>
# endif
#ifndef URI_DOXYGEN
# include <uriparser/Uri.h>
# include "UriCommon.h"
#endif
/*extern*/ const URI_CHAR * const URI_FUNC(SafeToPointTo) = _UT("X");
/*extern*/ const URI_CHAR * const URI_FUNC(ConstPwd) = _UT(".");
/*extern*/ const URI_CHAR * const URI_FUNC(ConstParent) = _UT("..");
void URI_FUNC(ResetUri)(URI_TYPE(Uri) * uri) {
memset(uri, 0, sizeof(URI_TYPE(Uri)));
}
/* Compares two text ranges for equal text content */
int URI_FUNC(CompareRange)(
const URI_TYPE(TextRange) * a,
const URI_TYPE(TextRange) * b) {
#define APP_CMD_SUBDIRS 11
#define APP_CMD_CONTINUE 12
#define APP_CMD_QUIET 13
#define APP_CMD_NODELETE 14
#define APP_CMD_BREAK_IN_DEBUG 666
// NOTE: do commands get translated???
//
static const CMDTABLE g_aAppCommands[] = {
// _UT("NOLOGO"), APP_CMD_NOLOGO, CMDF_GLOBAL, 0, NULL, NULL, _UT(""),
// _UT("LOGO"), APP_CMD_LOGO, CMDF_GLOBAL, 0, NULL, NULL, _UT(""),
_UT("HELP"), APP_CMD_USAGE, CMDF_GLOBAL, 0, NULL, NULL, _UT("Print usage"),
_UT("?"), APP_CMD_USAGE, CMDF_GLOBAL, 0, NULL, NULL, _UT("Print usage"),
_UT("VERBOSE"), APP_CMD_VERBOSE, CMDF_GLOBAL, 0, NULL, NULL, _UT("Print detailed output."),
_UT("DIAGNOSTIC"), APP_CMD_DIAGNOSTIC, CMDF_GLOBAL, 0, NULL, NULL, _UT("Print out internal flow of control information."),
_UT("PATH"), APP_CMD_PATH, CMDF_GLOBAL, 1, NULL, _UT("path"), _UT("delete <path>"),
_UT("S"), APP_CMD_SUBDIRS, CMDF_OPT, 0, NULL, NULL, _UT("include subdirectores"),
_UT("C"), APP_CMD_CONTINUE, CMDF_OPT, 0, NULL, NULL, _UT("continue on access denied"),
_UT("Q"), APP_CMD_QUIET, CMDF_OPT, 0, NULL, NULL, _UT("Quiet mode - Print error output only."),
_UT("NODEL"), APP_CMD_NODELETE, CMDF_OPT, 0, NULL, NULL, _UT("don't delete. (ACLs may still be changed)"),
#ifdef DEBUG
_UT("BREAK"), APP_CMD_BREAK_IN_DEBUG,CMDF_GLOBAL,0, NULL, NULL, _UT("INLINE_BREAK during command line parsing."),
#endif
NULL, 0, 0, 0, NULL, NULL, NULL, // end of table
};
int medi_dbg_dump(struct INSTRUCTION *instr, uint8_t *sf_prefixes, int sf_prefixes_len, unichar_t *buff, int len)
{
unsigned int i;
struct STREAM stream;
stream.buff = buff;
stream.bufflen = len;
stream.reallen = 0;
stream.options = (DUMP_OPTION_DISP_UHEX | DUMP_OPTION_IMM_UHEX);
safe_unistrncpy(&stream, _UT("Superfluous prefixes:\n\t"));
dbg_dump_sf_prefixes(&stream, sf_prefixes, sf_prefixes_len);
safe_copy_unichar(&stream, '\n');
safe_unistrncpy(&stream, _UT("Prefixes:\n\t"));
dbg_dump_prefixes(&stream, instr);
safe_copy_unichar(&stream, '\n');
safe_unistrncpy(&stream, _UT("Mnemonic:\n\t"));
safe_unistrncpy(&stream, _UT("************\n\t"));
internal_dump_mnemonic(&stream, instr);
safe_unistrncpy(&stream, _UT("\n\t************"));
safe_copy_unichar(&stream, '\n');
safe_unistrncpy(&stream, _UT("Instruction bytes offset:\n\t"));
itoa(&stream, instr ->opcode_offset, 0x1, 0x0, 0x10);
safe_copy_unichar(&stream, '\n');
if (instr ->opsize)
{
safe_unistrncpy(&stream, _UT("Opsize:\n\t"));
itoa(&stream, instr ->opsize, sizeof(i), 0, 0x10);
safe_copy_unichar(&stream, '\n');
}
safe_unistrncpy(&stream, _UT("Flags:\n\t"));
dbg_dump_flags(&stream, instr);
safe_copy_unichar(&stream, '\n');
for (i = 0; i < 3; i++)
{
safe_unistrncpy(&stream, _UT("OPERAND "));
itoa(&stream, i, sizeof(i), 0, 0x10);
safe_unistrncpy(&stream, _UT(":\n\t"));
if ( !(instr ->ops[i].flags & OPERAND_FLAG_PRESENT) )
{
safe_unistrncpy(&stream, _UT("not present"));
}
else
{
internal_dump_operand(&stream, instr, i);
if (instr ->ops[i].flags & OPERAND_TYPE_IMM)
{
safe_unistrncpy(&stream, _UT("; "));
safe_unistrncpy(&stream, _UT("Offset: "));
itoa(&stream, instr ->ops[i].value.imm.offset, 0x1, 0x0, 0x10);
safe_unistrncpy(&stream, _UT("; "));
safe_unistrncpy(&stream, _UT("Size in stream: "));
itoa(&stream, instr ->ops[i].value.imm.size, 0x1, 0x0, 0x10);
safe_unistrncpy(&stream, _UT("; "));
safe_unistrncpy(&stream, _UT("Size: "));
itoa(&stream, instr ->ops[i].size, 0x1, 0x0, 0x10);
}
if ( (instr ->ops[i].flags & OPERAND_TYPE_MEM) && (instr ->ops[i].value.addr.mod & ADDR_MOD_DISP) )
{
safe_unistrncpy(&stream, _UT("; "));
safe_unistrncpy(&stream, _UT("Offset: "));
itoa(&stream, instr ->disp.offset, 0x1, 0x0, 0x10);
safe_unistrncpy(&stream, _UT("; "));
safe_unistrncpy(&stream, _UT("Size in stream: "));
itoa(&stream, instr ->disp.size, 0x1, 0x0, 0x10);
}
}
safe_copy_unichar(&stream, '\n');
}
safe_unistrncpy(&stream, _UT("Tested flags:\n\t"));
dbg_dump_eflags(&stream, instr ->tested_flags);
safe_copy_unichar(&stream, '\n');
safe_unistrncpy(&stream, _UT("Modified flags:\n\t"));
dbg_dump_eflags(&stream, instr ->modified_flags);
safe_copy_unichar(&stream, '\n');
safe_unistrncpy(&stream, _UT("Set flags:\n\t"));
dbg_dump_eflags(&stream, instr ->set_flags);
safe_copy_unichar(&stream, '\n');
safe_unistrncpy(&stream, _UT("Cleared flags:\n\t"));
dbg_dump_eflags(&stream, instr ->cleared_flags);
safe_copy_unichar(&stream, '\n');
safe_unistrncpy(&stream, _UT("Undefined flags:\n\t"));
dbg_dump_eflags(&stream, instr ->undefined_flags);
safe_copy_unichar(&stream, '\n');
safe_unistrncpy(&stream, _UT("Groups:\n\t"));
dbg_dump_groups(&stream, instr);
return stream.reallen;
}
static void dbg_dump_groups(struct STREAM *stream, struct INSTRUCTION *instr)
{
if (!instr ->groups)
safe_unistrncpy(stream, _UT("none"));
else
{
if (instr ->groups & GRP_GEN)
safe_unistrncpy(stream, _UT("GEN, "));
if (instr ->groups & GRP_SSE1)
safe_unistrncpy(stream, _UT("SSE1, "));
if (instr ->groups & GRP_ARITH)
safe_unistrncpy(stream, _UT("ARITH, "));
if (instr ->groups & GRP_BINARY)
safe_unistrncpy(stream, _UT("BINARY, "));
if (instr ->groups & GRP_STACK)
safe_unistrncpy(stream, _UT("STACK, "));
if (instr ->groups & GRP_SEGREG)
safe_unistrncpy(stream, _UT("SEGREG, "));
if (instr ->groups & GRP_LOGICAL)
safe_unistrncpy(stream, _UT("LOGICAL, "));
if (instr ->groups & GRP_PREFIX)
safe_unistrncpy(stream, _UT("PREFIX, "));
if (instr ->groups & GRP_BRANCH)
safe_unistrncpy(stream, _UT("BRANCH, "));
if (instr ->groups & GRP_COND)
safe_unistrncpy(stream, _UT("COND, "));
if (instr ->groups & GRP_DECIMAL)
safe_unistrncpy(stream, _UT("DECIMAL, "));
if (instr ->groups & GRP_BREAK)
safe_unistrncpy(stream, _UT("BREAK, "));
if (instr ->groups & GRP_SYSTEM)
safe_unistrncpy(stream, _UT("SYSTEM, "));
if (instr ->groups & GRP_INOUT)
safe_unistrncpy(stream, _UT("INOUT, "));
if (instr ->groups & GRP_STRING)
safe_unistrncpy(stream, _UT("STRING, "));
if (instr ->groups & GRP_DATAMOV)
safe_unistrncpy(stream, _UT("DATAMOV, "));
if (instr ->groups & GRP_CONTROL)
safe_unistrncpy(stream, _UT("CONTROL, "));
if (instr ->groups & GRP_CONVER)
safe_unistrncpy(stream, _UT("CONVER, "));
if (instr ->groups & GRP_X87FPU)
safe_unistrncpy(stream, _UT("X87FPU, "));
if (instr ->groups & GRP_FLGCTRL)
safe_unistrncpy(stream, _UT("FLGCTRL, "));
if (instr ->groups & GRP_SHFTROT)
safe_unistrncpy(stream, _UT("SHFTROT, "));
if (instr ->groups & GRP_SIMDFP)
safe_unistrncpy(stream, _UT("SIMDFP, "));
if (instr ->groups & GRP_SHUNPCK)
safe_unistrncpy(stream, _UT("SHUNPCK, "));
if (instr ->groups & GRP_FETCH)
safe_unistrncpy(stream, _UT("FETCH, "));
if (instr ->groups & GRP_CACHECT)
safe_unistrncpy(stream, _UT("CACHECT, "));
if (instr ->groups & GRP_COMPAR)
safe_unistrncpy(stream, _UT("COMPAR, "));
if (instr ->groups & GRP_TRANS)
safe_unistrncpy(stream, _UT("TRANS, "));
if (instr ->groups & GRP_SIMDINT)
safe_unistrncpy(stream, _UT("SIMDINT, "));
if (instr ->groups & GRP_PCKSCLR)
safe_unistrncpy(stream, _UT("PCKSCLR, "));
if (instr ->groups & GRP_PCKSP)
safe_unistrncpy(stream, _UT("PCKSP, "));
if (instr ->groups & GRP_UNPACK)
safe_unistrncpy(stream, _UT("UNPACK, "));
if (instr ->groups & GRP_SHIFT)
safe_unistrncpy(stream, _UT("SHIFT, "));
if (instr ->groups & GRP_BIT)
safe_unistrncpy(stream, _UT("BIT, "));
if (instr ->groups & GRP_SM)
safe_unistrncpy(stream, _UT("SM, "));
if (instr ->groups & GRP_MXCSRSM)
safe_unistrncpy(stream, _UT("MXCSRSM, "));
if (instr ->groups & GRP_ORDER)
safe_unistrncpy(stream, _UT("ORDER, "));
if (instr ->groups & GRP_SSE2)
safe_unistrncpy(stream, _UT("SSE2, "));
if (instr ->groups & GRP_SSSE3)
safe_unistrncpy(stream, _UT("SSSE3, "));
if (instr ->groups & GRP_MMX)
safe_unistrncpy(stream, _UT("MMX, "));
if (instr ->groups & GRP_SSE3)
safe_unistrncpy(stream, _UT("SSE3, "));
if (instr ->groups & GRP_SMX)
safe_unistrncpy(stream, _UT("GRP_SMX, "));
if (instr ->groups & GRP_VMX)
safe_unistrncpy(stream, _UT("GRP_VMX, "));
if (instr ->groups & GRP_SSE41)
safe_unistrncpy(stream, _UT("GRP_SSE41, "));
if (instr ->groups & GRP_SSE42)
safe_unistrncpy(stream, _UT("GRP_SSE42, "));
if (instr ->groups & GRP_STRTXT)
safe_unistrncpy(stream, _UT("GRP_STRTXT, "));
stream ->bufflen += 2;
stream ->buff -= 2;
stream ->reallen -= 2;
}
}
static void dbg_dump_prefixes(struct STREAM *stream, struct INSTRUCTION *instr)
{
if (!instr ->prefixes)
safe_unistrncpy(stream, _UT("none"));
else
{
if (instr ->prefixes & INSTR_PREFIX_CS)
safe_unistrncpy(stream, _UT("CS, "));
if (instr ->prefixes & INSTR_PREFIX_DS)
safe_unistrncpy(stream, _UT("DS, "));
if (instr ->prefixes & INSTR_PREFIX_ES)
safe_unistrncpy(stream, _UT("ES, "));
if (instr ->prefixes & INSTR_PREFIX_SS)
safe_unistrncpy(stream, _UT("SS, "));
if (instr ->prefixes & INSTR_PREFIX_FS)
safe_unistrncpy(stream, _UT("FS, "));
if (instr ->prefixes & INSTR_PREFIX_GS)
safe_unistrncpy(stream, _UT("GS, "));
if (instr ->prefixes & INSTR_PREFIX_OPSIZE)
safe_unistrncpy(stream, _UT("OPSIZE, "));
if (instr ->prefixes & INSTR_PREFIX_ADDRSIZE)
safe_unistrncpy(stream, _UT("ADDRSIZE, "));
if (instr ->prefixes & INSTR_PREFIX_REX)
{
safe_unistrncpy(stream, _UT("REX ("));
itoa(stream, instr ->rex, 0x1, 0x0, 0x10);
safe_unistrncpy(stream, _UT("), "));
}
if (instr ->prefixes & INSTR_PREFIX_LOCK)
safe_unistrncpy(stream, _UT("LOCK, "));
stream ->bufflen += 2;
stream ->buff -= 2;
stream ->reallen -= 2;
}
}
