///////////////////////////////////////////////////////////////////////
// Function: SetExistingTimesSet
//
// Author: $author$
// Date: 7/29/2009
///////////////////////////////////////////////////////////////////////
virtual EvError SetExistingTimesSet
(const char* chars, LONG length=-1)
{
EvError error = EV_ERROR_FAILED;
#if defined(WIN32)
// Windows
EvError error2;
DBF("() in...\n");
if ((m_findChars = GetFindName(chars, length)))
if (!(error2 = m_win32File.
Open(m_findChars, GENERIC_WRITE)))
{
error = SetFileTimesSet();
Close();
}
#else // defined(WIN32)
// Unix
int err;
DBF("() in...\n");
if (!(m_findChars = GetFindName(chars, length)))
DBE("() failed on GetFindName\n");
else if ((err = stat(m_findChars, &m_st)))
DBE("() failed to stat \"%s\"\n", m_findChars);
else error = SetFileTimesSet();
#endif // defined(WIN32)
DBF("() ...out\n");
return error;
}
static int
reg2str(unsigned val, int tag, int size, bool rex_used, char *buf, int buflen)
{
char *ptr = buf, *end = buf + buflen;
if (size == 1) {
if (val < 8) {
DBE(INSN, dprintk("%%%s", tag?vregs8[val]:regs8[val]));
ptr += snprintf(ptr, end - ptr, "%%%s", tag?vregs8[val]:regs8[val]);
} else {
ASSERT((val - 8) < sizeof tregs8/sizeof tregs8[0]);
DBE(INSN, dprintk(ptr, end - ptr, "%%%s", tregs8[val - 8]));
ptr += snprintf(ptr, end - ptr, "%%%s", tregs8[val - 8]);
}
} else if (size == 2) {
if (val < 8) {
DBE(INSN, dprintk("%%%s", tag?vregs16[val]:regs16[val]));
ptr += snprintf(ptr, end - ptr, "%%%s", tag?vregs16[val]:regs16[val]);
} else {
ASSERT(tag);
ASSERT((val - 8) < sizeof tregs16/sizeof tregs16[0]);
ptr += snprintf(ptr, end - ptr, "%%%s", tregs16[val - 8]);
}
} else if (size == 4) {
if (val < 8) {
ptr += snprintf(ptr, end - ptr, "%%%s", tag?vregs32[val]:regs32[val]);
} else {
ASSERT(tag);
ASSERT((val - 8) < sizeof tregs32/sizeof tregs32[0]);
ptr += snprintf(ptr, end - ptr, "%%%s", tregs32[val - 8]);
}
} else ASSERT(0);
return (ptr - buf);
}
///////////////////////////////////////////////////////////////////////
// Function: SetFileTimesSet
//
// Author: $author$
// Date: 7/29/2009
///////////////////////////////////////////////////////////////////////
virtual EvError SetFileTimesSet()
{
EvError error = EV_ERROR_FAILED;
DBTFileTimesSet();
#if defined(WIN32)
// Windows
HANDLE win32Handle;
DBF("() in...\n");
if (!(win32Handle = m_win32File.Attached()))
return EV_ERROR_NOT_ATTACHED;
if (SetFileTime
(win32Handle, &m_createdOSFileTime,
&m_accessedOSFileTime, &m_modifiedOSFileTime))
error = EV_ERROR_NONE;
#else // defined(WIN32)
// Unix
EvError error2;
DBF("() in...\n");
if (!(m_findChars = m_findName.Chars
(m_findLength)) || (0 >= m_findLength))
DBE("() failed on m_findName.Chars\n");
else if ((error2 = m_unixFileSystem.SetFileTime
(m_findChars, &m_changedOSFileTime,
&m_accessedOSFileTime, &m_modifiedOSFileTime)))
DBE("() failed on m_unixFileSystem.SetFileTime\n");
else error = EV_ERROR_NONE;
#endif // defined(WIN32)
DBF("() ...out\n");
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: Run
//
// Author: $author$
// Date: 7/24/2009
///////////////////////////////////////////////////////////////////////
virtual int Run
(int argc, const char** argv, const char** env)
{
int err = 0;
EvError error;
UID uid;
GID gid;
const char* chars;
LONG length;
if ((error = m_gid.GetCurrentGid(gid)))
DBE("() failed to get current gid\n");
else printf("GID: %d\n", gid);
if ((error = m_uid.GetCurrentUid(uid)))
DBE("() failed to get current uid\n");
else
{
printf("UID: %d\n", uid);
if (!(error = m_passwd.FindUser(uid)))
{
if ((chars = m_passwd.GetUserName(length)))
printf("User: %s\n", chars);
if ((chars = m_passwd.GetUserHome(length)))
printf("Home: %s\n", chars);
}
}
return err;
}
///////////////////////////////////////////////////////////////////////
// Function: Close
//
// Author: $author$
// Date: 4/11/2009
///////////////////////////////////////////////////////////////////////
virtual EvError Close()
{
DF(Close)
EvError error = EV_ERROR_FAILED;
if (INVALID_DLL == m_attached)
return EV_ERROR_NOT_ATTACHED;
#if defined(WIN32)
// Windows
if (!FreeLibrary(m_attached))
DBE("() FreeLibrary() failed\n");
#else // defined(WIN32)
// Unix
int err;
if ((err = dlclose(m_attached)))
DBE("() dlclose() failed\n");
#endif // defined(WIN32)
else
{
error = EV_ERROR_NONE;
m_attached = INVALID_DLL;
}
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: GetCurrentDateTime
//
// Author: $author$
// Date: 8/12/2009
///////////////////////////////////////////////////////////////////////
virtual EvError GetCurrentDateTime
(bool isLocal=false,
const EvTimezone* timezone=0)
{
EvError error = EV_ERROR_FAILED;
struct tm* tm = 0;
time_t t;
DBF("() ...in\n");
if (INVALID_TIME == (t = time(&t)))
DBE("() failed on time\n");
{
if (isLocal)
{
if (timezone)
{
DBE("() use of timezone not implemented\n");
return EV_ERROR_NOT_IMPLEMENTED;
}
if (!(tm = localtime_r(&t, &m_tm)))
DBE("() failed on localtime_r\n");
else error = EV_ERROR_NONE;
}
else if (!(tm = gmtime_r(&t, &m_tm)))
DBE("() failed on gmtime_r\n");
else error = EV_ERROR_NONE;
}
DBF("() ...out\n");
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: MainArg
//
// Author: $author$
// Date: 4/4/2009
///////////////////////////////////////////////////////////////////////
virtual int MainArg
(int args, int argn, const char *arg,
int argc, const char** argv, const char** env)
{
const char* name;
LONG length;
int level;
if ((arg = MainArgParam(argn, arg, argc, argv)))
{
if ((0 > (level = atoi(arg)))
|| ((int)(sizeof(EvDebugLevels)*8) < level))
{
SET_EV_DEBUG_LEVELS(DEFAULT_EV_DEBUG_LEVELS);
DBE("() invalid debug level %d\n", level);
}
else SET_EV_DEBUG_LEVELS(level);
}
else
{
if ((name = GetLongName(length)))
printf("%s: %x\n", name, GET_EV_DEBUG_LEVELS());
}
return argn;
}
///////////////////////////////////////////////////////////////////////
// Function: GetCurrentDateTime
//
// Author: $author$
// Date: 7/13/2009
///////////////////////////////////////////////////////////////////////
virtual EvError GetCurrentDateTime
(bool isLocal=false,
const EvTimezone* timezone=0)
{
EvError error = EV_ERROR_FAILED;
EvError error2;
bool isPM;
DBF("() in...\n");
if ((error2 = m_systemTime.
GetCurrentDateTime(isLocal, timezone)))
{
DBE("() failed on GetCurrentDateTime\n");
return error;
}
m_year = m_systemTime.GetYear();
m_month = m_systemTime.GetMonth();
m_day = m_systemTime.GetDay();
m_hour = m_systemTime.GetHour(isPM);
m_minute = m_systemTime.GetMinute();
m_second = m_systemTime.GetSecond();
m_millisecond = m_systemTime.GetMillisecond();
error = EV_ERROR_NONE;
DBF("() ...out\n");
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: Bind
//
// Author: $author$
// Date: 4/6/2009
///////////////////////////////////////////////////////////////////////
virtual EvError Bind
(USHORT port, const char* host=0)
{
EvError error = EV_ERROR_FAILED;
SOCKADDR_IN sockAddrIn;
int err;
if (host)
return EV_ERROR_NOT_IMPLEMENTED;
if (INVALID_SOCKET == m_attached)
return EV_ERROR_NOT_ATTACHED;
if (INVALID_SOCKET_PORT == port)
port = m_port;
sockAddrIn.sin_family = m_family;
sockAddrIn.sin_port = htons(port);
sockAddrIn.sin_addr.s_addr = htonl(m_addr);
if ((err = bind(m_attached, (SOCKADDR*)(&sockAddrIn), sizeof(sockAddrIn))))
DBE("() failed to bind socket error = %d\n", GET_SOCKET_ERROR(err));
else error = EV_ERROR_NONE;
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: Open
//
// Author: $author$
// Date: 4/11/2009
///////////////////////////////////////////////////////////////////////
virtual EvError Open
(const char* filename,
bool resolve=true,
bool global=false)
{
DF(Open)
EvError error = EV_ERROR_FAILED;
if (!filename || !filename[0])
return EV_ERROR_NULL_PARAMETER;
#if defined(WIN32)
// Windows
char c;
LONG length;
TCHAR tChar;
const char* chars;
const TCHAR* tChars;
CEvTString tFilename;
for (chars = filename; (c = *chars); chars++)
{
if ('/' == c)
tChar = (TCHAR)('\\');
else tChar = (TCHAR)(c);
tFilename.Append(&tChar, 1);
}
if ((tChars = tFilename.Chars(length)))
if (0 < length)
if (INVALID_DLL != (m_attached = LoadLibrary(tChars)))
error = EV_ERROR_NONE;
else DBE("() LoadLibrary(\"%s\") error %lu", filename, GetLastError());
#else // defined(WIN32)
// Unix
int flag = (resolve?RTLD_NOW:RTLD_LAZY)
|(global?RTLD_GLOBAL:0);
if (INVALID_DLL != (m_attached = dlopen(filename, flag)))
error = EV_ERROR_NONE;
else DBE("() dlopen(\"%s\") error \"%s\"\n", filename, dlerror());
#endif // defined(WIN32)
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: Create
//
// Author: $author$
// Date: 4/6/2009
///////////////////////////////////////////////////////////////////////
virtual EvError Create()
{
EvError error = EV_ERROR_FAILED;
if (INVALID_SOCKET != m_attached)
return EV_ERROR_ALREADY_ATTACHED;
#if defined(WIN32)
// Windows
if ((error = EvWsa::Startup()))
{
DBE("() failed on wsa startup\n");
return error;
}
#endif // defined(WIN32)
if (INVALID_SOCKET != (m_attached = socket
(m_family, m_type, m_protocol)))
{
#if defined(WIN32)
// Windows
int optval = 1;
int err;
if ((err = setsockopt
(m_attached, IPPROTO_TCP, TCP_NODELAY,
(char*)&optval, sizeof(optval))))
{
DBE("() failed on setsockopt\n");
closesocket(m_attached);
m_attached = INVALID_SOCKET;
return error;
}
#endif // defined(WIN32)
return EV_ERROR_NONE;
}
DBE("() failed error = %d\n", GET_SOCKET_ERROR(0));
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: Accept
//
// Author: $author$
// Date: 4/6/2009
///////////////////////////////////////////////////////////////////////
virtual EvError Accept
#if defined(WIN32)
// Windows
(CEvSocket& connection, bool updateAcceptContext=false)
#else // defined(WIN32)
// Unix
(CEvSocket& connection)
#endif // defined(WIN32)
{
EvError error = EV_ERROR_FAILED;
SOCKADDR_IN sockAddrIn;
socklen_t sockAddrInLen = sizeof(sockAddrIn);
if (INVALID_SOCKET == m_attached)
return EV_ERROR_NOT_ATTACHED;
if (INVALID_SOCKET != connection.m_attached)
return EV_ERROR_ALREADY_ATTACHED;
if (INVALID_SOCKET != (connection.m_attached = accept
(m_attached, (SOCKADDR*)(&sockAddrIn), &sockAddrInLen)))
error = EV_ERROR_NONE;
else
{
DBE("() failed to accept error = %d\n", GET_SOCKET_ERROR(-1));
return error;
}
#if defined(WIN32)
// Windows
if (updateAcceptContext)
if ((error = connection.
UpdateAcceptContext(m_attached)))
{
DBE("() failed to update accept context\n");
connection.Close();
}
#endif // defined(WIN32)
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: Read
//
// Author: $author$
// Date: 4/16/2009
///////////////////////////////////////////////////////////////////////
virtual LONG Read
(void* buffer, ULONG size)
{
char* chars = (char*)(buffer);
LONG recved;
if (0 > (recved = recv(m_attached, chars, size, 0)))
{
DBE("() failed error = %d\n", GET_SOCKET_ERROR(recved));
return -EV_ERROR_READ;
}
return recved;
}
///////////////////////////////////////////////////////////////////////
// Function: Write
//
// Author: $author$
// Date: 4/16/2009
///////////////////////////////////////////////////////////////////////
virtual LONG Write
(const void* buffer, LONG length)
{
const char* chars = (const char*)(buffer);
LONG sent;
if (0 > (sent = send(m_attached, chars, length, 0)))
{
DBE("() failed error = %d\n", GET_SOCKET_ERROR(sent));
return -EV_ERROR_WRITE;
}
return sent;
}
///////////////////////////////////////////////////////////////////////
// Function: Connect
//
// Author: $author$
// Date: 4/6/2009
///////////////////////////////////////////////////////////////////////
virtual EvError Connect
(USHORT port, const char* host=0)
{
EvError error = EV_ERROR_FAILED;
SOCKADDR_IN sockAddrIn;
HOSTENT *hostEnt;
UINT32 addr;
int err;
if (INVALID_SOCKET == m_attached)
return EV_ERROR_NOT_ATTACHED;
if (INVALID_SOCKET_PORT == (SOCKET_PORT)(port))
port = m_port;
if (!(hostEnt = gethostbyname(host)))
{
DBE("() Failed to gethostbyname \"%s\"\n", host);
return error;
}
addr = ntohl(*(UINT32*)(hostEnt->h_addr));
sockAddrIn.sin_addr.s_addr = htonl(addr);
sockAddrIn.sin_family = m_family;
sockAddrIn.sin_port = htons(port);
if ((err = connect(m_attached, (SOCKADDR*)(&sockAddrIn), sizeof(sockAddrIn))))
{
DBE("() failed to connect error = %d\n", GET_SOCKET_ERROR(err));
return error;
}
m_addr = addr;
m_port = port;
error = EV_ERROR_NONE;
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: Listen
//
// Author: $author$
// Date: 4/6/2009
///////////////////////////////////////////////////////////////////////
virtual EvError Listen(int backlog=UNDEFINED)
{
EvError error = EV_ERROR_FAILED;
int err;
if (INVALID_SOCKET == m_attached)
return EV_ERROR_NOT_ATTACHED;
if (UNDEFINED == backlog)
backlog = m_backlog;
if ((err = listen(m_attached, backlog)))
DBE("() failed to listen error = %d\n", GET_SOCKET_ERROR(err));
else error = EV_ERROR_NONE;
return error;
}
int
insn2str(btmod *bt, insn_t const *insn, char *buf, size_t size)
{
int i;
char *ptr = buf, *end = buf + size;
ptr += snprintf(ptr, end - ptr, "%s", opctable_name(bt, insn->opc));
*ptr++ = ' ';
for (i = 0; i < 3; i++) {
DBE(INSN, dprintk(" %d:", i));
ptr += operand2str(&insn->op[i], ptr, end - ptr);
if (insn->op[i].type != invalid && i != 2 && insn->op[i+1].type!= invalid) {
ptr += snprintf(ptr, end - ptr, ",");
}
}
ASSERT(ptr < end);
return (ptr - buf);
}
///////////////////////////////////////////////////////////////////////
// Function: ShutDown
//
// Author: $author$
// Date: 5/12/2009
///////////////////////////////////////////////////////////////////////
virtual EvError ShutDown
(int how=SD_BOTH, bool onlyIfOpen=false)
{
EvError error = EV_ERROR_FAILED;
int err;
if (INVALID_SOCKET == m_attached)
if (onlyIfOpen)
return EV_ERROR_NOT_ATTACHED;
else return EV_ERROR_NONE;
if ((err = shutdown(m_attached, how)))
{
DBE("() failed to shutdown socket error = %d\n", GET_SOCKET_ERROR(err));
return error;
}
else error = EV_ERROR_NONE;
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: GetOpt
//
// Author: $author$
// Date: 5/14/2009
///////////////////////////////////////////////////////////////////////
virtual EvError GetOpt
(SOCKET_OPT_LEVEL level,
SOCKET_OPT_NAME name,
SOCKET_OPT_VALUE* value,
SOCKET_OPT_LENGTH& length) const
{
EvError error = EV_ERROR_FAILED;
int err;
if (INVALID_SOCKET == m_attached)
return EV_ERROR_NOT_ATTACHED;
if ((err = getsockopt
(m_attached, level, name,
(char*)value, &length)))
DBE("() failed to getsockopt error = %d\n", GET_SOCKET_ERROR(err));
else error = EV_ERROR_NONE;
return error;
}
///////////////////////////////////////////////////////////////////////
// Function: Close
//
// Author: $author$
// Date: 4/6/2009
///////////////////////////////////////////////////////////////////////
virtual EvError Close
(bool onlyIfOpen=false)
{
EvError error = EV_ERROR_FAILED;
int err;
if (INVALID_SOCKET == m_attached)
if (onlyIfOpen)
return EV_ERROR_NOT_ATTACHED;
else return EV_ERROR_NONE;
if ((err = closesocket(m_attached)))
{
DBE("() failed to close socket error = %d\n", GET_SOCKET_ERROR(err));
return error;
}
else error = EV_ERROR_NONE;
m_attached = INVALID_SOCKET;
return error;
}
int
operand2str(operand_t const *op, char *buf, size_t size)
{
char *ptr = buf, *end = buf + size;
switch (op->type) {
case invalid:
DBE(INSN, dprintk("(inval)"));
break;
case op_reg:
ptr += reg2str(op->val.reg, op->tag.reg, op->size, op->rex_used,
ptr, end - ptr);
DBE(INSN, dprintk("(reg) %s", buf));
break;
case op_seg:
ptr += seg2str(op->val.seg, op->tag.seg, ptr, end - ptr);
DBE(INSN, dprintk("(seg) %s", buf));
break;
case op_mem:
ptr += mem2str(&op->val.mem, &op->tag.mem, op->size, op->rex_used, ptr,
end - ptr);
DBE(INSN, dprintk("(mem) %s", buf));
break;
case op_imm:
ptr += imm2str(op->val.imm, op->tag.imm, ptr, end - ptr);
DBE(INSN, dprintk("(imm) %s", buf));
break;
case op_pcrel:
ptr += pcrel2str(op->val.pcrel, op->tag.pcrel, ptr, end - ptr);
DBE(INSN, dprintk("(pcrel) %s", buf));
break;
case op_cr:
ptr += cr2str(op->val.cr, op->tag.cr, ptr, end - ptr);
DBE(INSN, dprintk("(cr) %s", buf));
break;
case op_db:
ptr += db2str(op->val.db, op->tag.db, ptr, end - ptr);
DBE(INSN, dprintk("(db) %s", buf));
break;
case op_tr:
ptr += tr2str(op->val.tr, op->tag.tr, ptr, end - ptr);
DBE(INSN, dprintk("(tr) %s", buf));
break;
case op_mmx:
ptr += mmx2str(op->val.mmx, op->tag.mmx, ptr, end - ptr);
DBE(INSN, dprintk("(mm) %s", buf));
break;
case op_xmm:
ptr += xmm2str(op->val.xmm, op->tag.xmm, ptr, end - ptr);
DBE(INSN, dprintk("(xmm) %s", buf));
break;
case op_3dnow:
ptr += op3dnow2str(op->val.d3now, op->tag.d3now, ptr, end - ptr);
DBE(INSN, dprintk("(3dnow) %s", buf));
break;
case op_prefix:
ptr += prefix2str(op->val.prefix, op->tag.prefix, ptr, end - ptr);
break;
case op_st:
ptr += st2str(op->val.st, op->tag.st, ptr, end - ptr);
break;
default:
dprintk("Invalid op->type[%d]\n", op->type);
ASSERT(0);
}
return ptr - buf;
}
