trap_retval ReqFile_string_to_fullpath( void )
{
unsigned_16 len;
char *name;
char *fullname;
file_string_to_fullpath_req *acc;
file_string_to_fullpath_ret *ret;
int fd;
Elf32_Ehdr ehdr;
Elf32_Phdr *phdr;
acc = GetInPtr( 0 );
name = GetInPtr( sizeof( *acc ) );
ret = GetOutPtr( 0 );
fullname = GetOutPtr( sizeof( *ret ) );
fullname[0] = '\0';
len = 0;
if( acc->file_type != TF_TYPE_EXE ) {
len = FindFilePath( false, name, fullname );
} else if( Core.mapping_shared ) {
len = FindFilePath( true, name, fullname );
} else {
fd = load_elf_header( name, &ehdr, &phdr );
if( (fd != NO_FILE) && init_platform_driver( fd, &ehdr, phdr ) ) {
len = Core.plat->name( Core.ctx, fullname, MAX_FULLPATH_LEN );
if( !len ) {
strcpy( fullname, "unknown" );
len = strlen( fullname );
} else {
#if 0
struct stat chk;
name = "/foo/bar"; //Core.hdr.psdata.un.proc.name;
if( stat( name, &chk ) != 0 ) {
chk.st_mtime = 0;
}
if( Core.ignore_timestamp || chk.st_mtime == Core.hdr.cmdtime ) {
len = StrCopy( name, fullname ) - fullname;
} else {
/* Executable and core file timestaps don't match */
len = 0;
}
#endif
}
close( fd );
}
}
if( len == 0 ) {
ret->err = ENOENT; /* File not found */
} else {
ret->err = 0;
}
return( sizeof( *ret ) + len + 1 );
}
trap_retval ReqFile_string_to_fullpath( void )
{
unsigned_16 len;
char *name;
char *fullname;
unsigned save_handle;
file_string_to_fullpath_req *acc;
file_string_to_fullpath_ret *ret;
acc = GetInPtr( 0 );
name = GetInPtr( sizeof( *acc ) );
ret = GetOutPtr( 0 );
fullname = GetOutPtr( sizeof( *ret ) );
fullname[0] = '\0';
len = 0;
if( acc->file_type != TF_TYPE_EXE ) {
len = FindFilePath( FALSE, name, fullname );
} else if( core_info.mapping_shared ) {
len = FindFilePath( TRUE, name, fullname );
} else {
save_handle = core_info.fd;
if( load_core_header( name ) ) {
// TODO: this should figure out the name of the executable
// that caused the core dump.
name = "cdump";
strcpy( fullname, name );
len = strlen( fullname );
#if 0
struct stat chk;
name = "/foo/bar"; //core_info.hdr.psdata.un.proc.name;
if( stat( name, &chk ) != 0 ) {
/* try it without the node number */
name += 2;
while( *name != '/' ) ++name;
if( stat( name, &chk ) != 0 ) {
chk.st_mtime = 0;
}
}
if( core_info.ignore_timestamp || chk.st_mtime == core_info.hdr.cmdtime ) {
len = StrCopy( name, fullname ) - fullname;
}
#endif
close( core_info.fd );
}
core_info.fd = save_handle;
}
if( len == 0 ) {
ret->err = ENOENT; /* File not found */
} else {
ret->err = 0;
}
return( sizeof( *ret ) + len + 1 );
}
trap_retval ReqFile_string_to_fullpath( void )
{
char *name;
char *fullname;
char *ext_list;
file_string_to_fullpath_req *acc;
file_string_to_fullpath_ret *ret;
tiny_ret_t rc;
acc = GetInPtr( 0 );
name = GetInPtr( sizeof( *acc ) );
ret = GetOutPtr( 0 );
fullname = GetOutPtr( sizeof( *ret ) );
if( acc->file_type == TF_TYPE_EXE ) {
ext_list = GetExeExtensions();
} else {
ext_list = "";
}
rc = FindFilePath( name, fullname, ext_list );
if( TINY_OK( rc ) ) {
ret->err = 0;
} else {
ret->err = TINY_INFO( rc );
*fullname = '\0';
}
return( sizeof( *ret ) + 1 + strlen( fullname ) );
}
unsigned ReqFile_string_to_fullpath( void )
{
file_string_to_fullpath_req *acc;
file_string_to_fullpath_ret *ret;
char *name;
char *fullname;
char *ext_list;
acc = GetInPtr( 0 );
name = GetInPtr( sizeof( *acc ) );
ret = GetOutPtr( 0 );
fullname = GetOutPtr( sizeof( *ret ) );
if( GetMagicalFileHandle( name ) != NULL ) {
strcpy( fullname, name );
ret->err = 0;
} else {
if( acc->file_type != TF_TYPE_EXE ) {
ext_list = "";
} else {
ext_list = ExtensionList;
}
ret->err = FindFilePath( name, fullname, ext_list );
}
if( ret->err != 0 )
*fullname = '\0';
return( sizeof( *ret ) + strlen( fullname ) + 1 );
}
int main(int argc, char **argv){
DIR *d;
tree = malloc(sizeof(Node));
tree->left = NULL;
tree->right = NULL;
tree->path = NULL;
tree->name = NULL;
duplicates = malloc(sizeof(Duplicate));
duplicates->df = NULL;
duplicates->next = NULL;
d = opendir(".");
if(d != NULL){
FindFilePath(d, ".", 0);
}
else {
perror("Kluda direktorijas atversana: ");
return -1;
}
d = NULL;
PrintTreePreOrder(tree);
FreeTree(tree);
PrintDuplicates();
tree = NULL;
return 0;
}
unsigned ReqFile_string_to_fullpath( void )
{
file_string_to_fullpath_req *acc;
file_string_to_fullpath_ret *ret;
int exe;
int len;
char *name;
char *fullname;
pid_t pidd;
pidd = 0;
acc = GetInPtr( 0 );
name = GetInPtr( sizeof( *acc ) );
ret = GetOutPtr( 0 );
fullname = GetOutPtr( sizeof( *ret ) );
exe = ( acc->file_type == TF_TYPE_EXE ) ? TRUE : FALSE;
if( exe ) {
pidd = RunningProc( name, &name );
}
if( pidd != 0 ) {
len = GetExeNameFromPid( pidd, fullname, PATH_MAX );
} else {
len = FindFilePath( exe, name, fullname );
}
if( len == 0 ) {
ret->err = ENOENT; /* File not found */
} else {
ret->err = 0;
}
CONV_LE_32( ret->err );
return( sizeof( *ret ) + len + 1 );
}
bool FileMessageHandler::ReadFile(const list<Path>& lps, POVMS_Object& msg, POVMS_Object& result)
{
Path path(FindFilePath(lps, Path(msg.GetUCS2String(kPOVAttrib_ReadFile))));
if(path.Empty() == false)
result.SetUCS2String(kPOVAttrib_LocalFile, path().c_str());
return (path.Empty() == false);
}
void FindFilePath(DIR *d, char *prevPath, unsigned char tabCount){
struct dirent *de;
DIR *nextD;
char *dirName = malloc(256);
while((de = readdir(d)) != NULL){
PrintTabs(tabCount);
printf("Apskata: '%s' '%d'\n", de->d_name, de->d_type);
if(de->d_type == 8){
AddFileToRecord(prevPath, de->d_name, tabCount);
}
else if((strcmp(de->d_name, ".")) != 0 && (strcmp(de->d_name, "..")) != 0 && de->d_type == 4){
PrintTabs(tabCount);
printf("Atrada direktoriju '%s'\n", de->d_name);
strcat(dirName, prevPath);
strcat(dirName, "/");
strcat(dirName, de->d_name);
PrintTabs(tabCount);
printf("Ver vala '%s'\n", dirName);
nextD = opendir(dirName);
if(nextD != NULL){
FindFilePath(nextD, dirName, tabCount + 1);
}
else {
perror(dirName);
}
}
}
closedir(d);
free(dirName);
dirName = NULL;
de = NULL;
nextD = NULL;
return;
}
bool FileMessageHandler::FindFile(const list<Path>& lps, POVMS_Object& msg, POVMS_Object& result)
{
POVMS_List files;
Path path;
msg.Get(kPOVAttrib_ReadFile, files);
for(int i = 1; i <= files.GetListSize(); i++)
{
POVMS_Attribute attr;
files.GetNth(i, attr);
path = FindFilePath(lps, Path(attr.GetUCS2String()));
if(path.Empty() == false)
break;
}
result.SetUCS2String(kPOVAttrib_ReadFile, path().c_str());
return (path.Empty() == false);
}
/*
* AccLoadProg - create a new process for debugging
*/
trap_retval ReqProg_load( void )
{
char *parm;
char *src;
char *dst;
char *endsrc;
char exe_name[PATH_MAX];
char ch;
BOOL rc;
int len;
MYCONTEXT con;
thread_info *ti;
HANDLE handle;
prog_load_req *acc;
prog_load_ret *ret;
header_info hi;
WORD stack;
WORD version;
DWORD pid;
DWORD pid_started;
DWORD cr_flags;
char *buff = NULL;
size_t nBuffRequired = 0;
char *dll_name;
char *service_name;
char *dll_destination;
char *service_parm;
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
parm = GetInPtr( sizeof( *acc ) );
/*
* reset status variables
*/
LastExceptionCode = -1;
DebugString = NULL;
DebugeeEnded = FALSE;
RemoveAllThreads();
FreeLibList();
DidWaitForDebugEvent = FALSE;
DebugeePid = 0;
DebugeeTid = 0;
SupportingExactBreakpoints = 0;
/*
* check if pid is specified
*/
ParseServiceStuff( parm, &dll_name, &service_name, &dll_destination, &service_parm );
pid = 0;
src = parm;
/*
// Just to be really safe!
*/
nBuffRequired = GetTotalSize() + PATH_MAX + 16;
if( NULL == ( buff = malloc( nBuffRequired ) ) ) {
ret->err = ERROR_NOT_ENOUGH_MEMORY;
return( sizeof( *ret ) );
}
if( *src == '#' ) {
src++;
pid = strtoul( src, &endsrc, 16 );
if( pid == 0 ) {
pid = -1;
}
strcpy( buff, endsrc );
} else {
while( isdigit( *src ) ) {
src++;
}
if( *src == 0 && src != parm ) {
pid = atoi( parm );
}
}
/*
* get program to debug. If the user has specified a pid, then
* skip directly to doing a DebugActiveProcess
*/
IsWOW = FALSE;
#if !defined( MD_x64 )
IsDOS = FALSE;
#endif
if( pid == 0 ) {
if( FindFilePath( parm, exe_name, ExtensionList ) != 0 ) {
ret->err = ERROR_FILE_NOT_FOUND;
goto error_exit;
}
/*
* Get type of application
*/
handle = CreateFile( (LPTSTR)exe_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
if( handle == INVALID_HANDLE_VALUE ) {
ret->err = GetLastError();
goto error_exit;
}
GetFullPathName( exe_name, MAX_PATH, CurrEXEName, NULL );
/*
* get the parm list
*/
if( strchr( CurrEXEName, ' ' ) != NULL ) {
strcpy( buff, "\"" );
strcat( buff, CurrEXEName );
strcat( buff, "\"" );
} else {
strcpy( buff, CurrEXEName );
}
dst = &buff[strlen( buff )];
src = parm;
while( *src != 0 ) {
++src;
}
// parm layout
// <--parameters-->0<--program_name-->0<--arguments-->0
//
for( len = GetTotalSize() - sizeof( *acc ) - (src - parm) - 1; len > 0; --len ) {
ch = *src;
if( ch == 0 ) {
ch = ' ';
}
*dst = ch;
++dst;
++src;
}
*dst = 0;
cr_flags = DEBUG_ONLY_THIS_PROCESS;
if( !GetEXEHeader( handle, &hi, &stack ) ) {
ret->err = GetLastError();
CloseHandle( handle );
goto error_exit;
}
if( hi.sig == EXE_PE ) {
if( IS_PE64( hi.u.peh ) ) {
DebugeeSubsystem = PE64( hi.u.peh ).subsystem;
} else {
DebugeeSubsystem = PE32( hi.u.peh ).subsystem;
#if defined( MD_x64 )
IsWOW = TRUE;
#endif
}
if( DebugeeSubsystem == SS_WINDOWS_CHAR ) {
cr_flags |= CREATE_NEW_CONSOLE;
}
#if !defined( MD_x64 )
} else if( hi.sig == EXE_NE ) {
IsWOW = TRUE;
/*
* find out the pid of WOW, if it is already running.
*/
pVDMEnumProcessWOW( EnumWOWProcessFunc, (LPARAM)&pid );
if( pid != 0 ) {
version = LOWORD( GetVersion() );
if( LOBYTE( version ) == 3 && HIBYTE( version ) < 50 ) {
int kill = MessageBox( NULL, TRP_NT_wow_warning, TRP_The_WATCOM_Debugger, MB_APPLMODAL + MB_YESNO );
if( kill == IDYES ) {
DWORD axs = PROCESS_TERMINATE+STANDARD_RIGHTS_REQUIRED;
HANDLE hprocess = OpenProcess( axs, FALSE, pid );
if( hprocess != 0 && TerminateProcess( hprocess, 0 ) ) {
CloseHandle( hprocess );
pid = 0;
}
}
} else {
cr_flags |= CREATE_SEPARATE_WOW_VDM;
pid = 0; // always start a new VDM.
}
}
if( pid != 0 ) {
ret->err = GetLastError();
CloseHandle( handle );
goto error_exit;
}
} else {
IsDOS = TRUE;
#endif
}
CloseHandle( handle );
}
/*
* start the debugee
*/
pid_started = pid;
if( *dll_name ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_DLLNAME );
strcat( buff, dll_name );
}
if( *service_name ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_SERVICE );
strcat( buff, service_name );
}
if( *dll_destination ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_COPYDIR );
strcat( buff, dll_destination );
}
if( *service_parm ) {
strcat( buff, LOAD_PROG_STR_DELIM );
strcat( buff, LOAD_PROG_STR_SERVICEPARM );
strcat( buff, service_parm );
}
ret->err = StartControlThread( buff, &pid_started, cr_flags );
if( ret->err != 0 ) {
goto error_exit;
}
/*
* CREATE_PROCESS_DEBUG_EVENT will always be the first debug event.
* If it is not, then something is horribly wrong.
*/
rc = MyWaitForDebugEvent();
if( !rc || ( DebugEvent.dwDebugEventCode != CREATE_PROCESS_DEBUG_EVENT ) || ( DebugEvent.dwProcessId != pid_started ) ) {
ret->err = GetLastError();
goto error_exit;
}
ProcessInfo.pid = DebugEvent.dwProcessId;
ProcessInfo.process_handle = DebugEvent.u.CreateProcessInfo.hProcess;
ProcessInfo.base_addr = DebugEvent.u.CreateProcessInfo.lpBaseOfImage;
AddProcess( &hi );
AddThread( DebugEvent.dwThreadId, DebugEvent.u.CreateProcessInfo.hThread, DebugEvent.u.CreateProcessInfo.lpStartAddress );
DebugeePid = DebugEvent.dwProcessId;
DebugeeTid = DebugEvent.dwThreadId;
LastDebugEventTid = DebugEvent.dwThreadId;
#if defined( MD_x86 )
#ifdef WOW
if( IsWOW ) {
ret->flags = LD_FLAG_IS_PROT;
ret->err = 0;
ret->task_id = DebugeePid;
/*
* we use our own CS and DS as the Flat CS and DS, for lack
* of anything better
*/
FlatDS = GetDS();
FlatCS = GetCS();
if( !executeUntilVDMStart() ) {
ret->err = GetLastError();
goto error_exit;
}
if( pid ) {
addAllWOWModules();
} else {
addKERNEL();
}
/*
* we save the starting CS:IP of the WOW app, since we will use
* it to force execution of code later
*/
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
WOWAppInfo.segment = ( WORD ) con.SegCs;
WOWAppInfo.offset = ( WORD ) con.Eip;
con.SegSs = con.SegDs; // Wow lies about the stack segment. Reset it
con.Esp = stack;
MySetThreadContext( ti, &con );
} else if( IsDOS ) {
// TODO! Clean up this code
ret->flags = 0; //LD_FLAG_IS_PROT;
ret->err = 0;
ret->task_id = DebugeePid;
/*
* we use our own CS and DS as the Flat CS and DS, for lack
* of anything better
*/
FlatDS = GetDS();
FlatCS = GetCS();
if( !executeUntilVDMStart() ) {
ret->err = GetLastError();
goto error_exit;
}
#if 0
if( pid ) {
addAllWOWModules();
} else {
addKERNEL();
}
#endif
/*
* we save the starting CS:IP of the WOW app, since we will use
* it to force execution of code later
*/
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
WOWAppInfo.segment = ( WORD )con.SegCs;
WOWAppInfo.offset = ( WORD )con.Eip;
con.SegSs = con.SegDs; // Wow lies about the stack segment. Reset it
con.Esp = stack;
MySetThreadContext( ti, &con );
} else {
#else
{
#endif
#else
{
#endif
LPVOID base;
if( pid == 0 ) {
base = (LPVOID)DebugEvent.u.CreateProcessInfo.lpStartAddress;
} else {
base = 0;
}
ret->flags = LD_FLAG_IS_PROT;
ret->err = 0;
ret->task_id = DebugeePid;
if( executeUntilStart( pid != 0 ) ) {
LPVOID old;
/*
* make the application load our DLL, so that we can have it
* run code out of it. One small note: this will not work right
* if the app does not load our DLL at the same address the
* debugger loaded it at!!!
*/
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
old = (LPVOID)AdjustIP( &con, 0 );
if( base != 0 ) {
SetIP( &con, base );
}
MySetThreadContext( ti, &con );
SetIP( &con, old );
MySetThreadContext( ti, &con );
}
ti = FindThread( DebugeeTid );
MyGetThreadContext( ti, &con );
#if defined( MD_x86 )
FlatCS = con.SegCs;
FlatDS = con.SegDs;
#endif
ret->flags |= LD_FLAG_IS_BIG;
}
ret->flags |= LD_FLAG_HAVE_RUNTIME_DLLS;
if( pid != 0 ) {
ret->flags |= LD_FLAG_IS_STARTED;
}
ret->mod_handle = 0;
error_exit:
if( buff ) {
free( buff );
buff = NULL;
}
return( sizeof( *ret ) );
}
trap_retval ReqProg_kill( void )
{
prog_kill_ret *ret;
ret = GetOutPtr( 0 );
ret->err = 0;
DelProcess( TRUE );
StopControlThread();
return( sizeof( *ret ) );
}
trap_retval ReqProg_load( void )
{
addr_seg psp;
pblock parmblock;
tiny_ret_t rc;
char *parm;
char *name;
char __far *dst;
char exe_name[128];
char ch;
EXE_TYPE exe;
prog_load_ret *ret;
unsigned len;
ExceptNum = -1;
ret = GetOutPtr( 0 );
memset( &TaskRegs, 0, sizeof( TaskRegs ) );
TaskRegs.EFL = MyFlags() & ~USR_FLAGS;
/* build a DOS command line parameter in our PSP command area */
Flags.BoundApp = FALSE;
psp = DbgPSP();
parm = name = GetInPtr( sizeof( prog_load_req ) );
if( TINY_ERROR( FindFilePath( name, exe_name, DosExtList ) ) ) {
exe_name[0] = '\0';
}
while( *parm++ != '\0' ) {} // skip program name
len = GetTotalSize() - ( parm - name ) - sizeof( prog_load_req );
if( len > 126 )
len = 126;
dst = MK_FP( psp, CMD_OFFSET + 1 );
for( ; len > 0; --len ) {
ch = *parm++;
if( ch == '\0' ) {
if( len == 1 )
break;
ch = ' ';
}
*dst++ = ch;
}
*dst = '\r';
*(byte __far *)MK_FP( psp, CMD_OFFSET ) = FP_OFF( dst ) - ( CMD_OFFSET + 1 );
parmblock.envstring = 0;
parmblock.commandln.segment = psp;
parmblock.commandln.offset = CMD_OFFSET;
parmblock.fcb01.segment = psp;
parmblock.fcb02.segment = psp;
parmblock.fcb01.offset = 0x5C;
parmblock.fcb02.offset = 0x6C;
exe = CheckEXEType( exe_name );
if( EXEhandle != 0 ) {
TinyClose( EXEhandle );
EXEhandle = 0;
}
switch( exe ) {
case EXE_RATIONAL_386:
ret->err = ERR_RATIONAL_EXE;
return( sizeof( *ret ) );
case EXE_PHARLAP_SIMPLE:
ret->err = ERR_PHARLAP_EXE;
return( sizeof( *ret ) );
}
SegmentChain = 0;
BoundAppLoading = FALSE;
rc = DOSLoadProg( exe_name, &parmblock );
if( TINY_OK( rc ) ) {
TaskRegs.SS = parmblock.startsssp.segment;
/* for some insane reason DOS returns a starting SP two less then
normal */
TaskRegs.ESP = parmblock.startsssp.offset + 2;
TaskRegs.CS = parmblock.startcsip.segment;
TaskRegs.EIP = parmblock.startcsip.offset;
psp = DOSTaskPSP();
} else {
psp = TinyAllocBlock( TinyAllocBlock( 0xffff ) );
TinyFreeBlock( psp );
TaskRegs.SS = psp + 0x10;
TaskRegs.ESP = 0xfffe;
TaskRegs.CS = psp + 0x10;
TaskRegs.EIP = 0x100;
}
TaskRegs.DS = psp;
TaskRegs.ES = psp;
if( TINY_OK( rc ) ) {
if( Flags.NoOvlMgr || !CheckOvl( parmblock.startcsip ) ) {
if( exe == EXE_OS2 ) {
opcode_type __far *loc_brk_opcode;
BoundAppLoading = TRUE;
RunProg( &TaskRegs, &TaskRegs );
loc_brk_opcode = MK_FP(TaskRegs.CS, TaskRegs.EIP);
if( *loc_brk_opcode == BRKPOINT ) {
*loc_brk_opcode = saved_opcode;
}
BoundAppLoading = FALSE;
rc = TinyOpen( exe_name, TIO_READ_WRITE );
if( TINY_OK( rc ) ) {
EXEhandle = TINY_INFO( rc );
SeekEXEset( StartByte );
WriteEXE( saved_opcode );
TinySetFileStamp( EXEhandle, EXETime, EXEDate );
TinyClose( EXEhandle );
EXEhandle = 0;
Flags.BoundApp = TRUE;
}
}
}
}
ret->err = TINY_ERROR( rc ) ? TINY_INFO( rc ) : 0;
ret->task_id = psp;
ret->flags = 0;
ret->mod_handle = 0;
return( sizeof( *ret ) );
}
/*
* AccLoadProg
*
* To load a app, we do the following:
*
* Case 1: debugging an existing task
* - Find its current CS:IP.
* - Plant a breakpoint at the current CS:IP
*
* Case 2: starting a task from scratch
* - Look up the start address from the .EXE
* - WinExec the app
* - Wait for the STARTASK notification for the app
* - Plant a breakpoint at its start address
*
* - Wait for the app to hit the breakpoint
* - Check if the app is a 32-bit app (look for "DEADBEEF" in code seg).
* If it is a 32-bit app:
* - Flip the "DEADBEEF" to "BEEFDEAD". If the extender see's the
* "BEEFDEAD", it executes a breakpoint right before it jumps to
* the 32-bit code
* - Let the app run until a breakpoint is hit
* - Trace one instruction. This leaves you at the first instruction
* of the 32-bit code
*/
unsigned ReqProg_load( void )
{
char exe_name[_MAX_PATH];
char drive[_MAX_DRIVE],directory[_MAX_DIR];
char buff[256];
lm_parms loadp;
word_struct cmdshow;
char *parm;
char *src;
char *dst;
char ch;
unsigned a,b;
private_msg pmsg;
char sig[sizeof(DWORD)];
HTASK tid;
DWORD csip;
prog_load_req *acc;
prog_load_ret *ret;
char *end;
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
ret->flags = LD_FLAG_IS_PROT | LD_FLAG_HAVE_RUNTIME_DLLS;
parm = GetInPtr( sizeof( *acc ) );
/*
* reset flags
*/
OutPos = 0;
WasStarted = FALSE;
LoadingDebugee = TRUE;
Debugging32BitApp = FALSE;
AddAllCurrentModules();
/*
* check for task id
*/
tid = 0;
src = parm;
if( *src == '#' ) {
src++;
tid = (HTASK)strtol( src, NULL, 16 );
} else {
while( *src != 0 ) {
if( !isdigit( *src ) ) {
break;
}
src++;
}
if( *src == 0 && src != parm ) {
tid = (HTASK)atoi( parm );
}
}
if( tid != 0 ) {
csip = GetRealCSIP( tid, &DebugeeModule );
if( csip == 0 ) {
tid = 0;
} else {
DebugeeTask = tid;
StopNewTask.loc.segment = FP_SEG( (LPVOID) csip );
StopNewTask.loc.offset = FP_OFF( (LPVOID) csip );
ReadMem( StopNewTask.loc.segment, StopNewTask.loc.offset,
&StopNewTask.value, 1 );
ch = 0xcc;
WriteMem( StopNewTask.loc.segment, StopNewTask.loc.offset, &ch, 1 );
}
} else {
tid = 0;
}
/*
* get the file to execute
*/
if( tid == 0 ) {
if( TINY_ERROR( FindFilePath( parm, exe_name, ExtensionList ) ) ) {
exe_name[0] = 0;
} else {
_splitpath( exe_name, drive, directory, NULL, NULL );
a = tolower( drive[0] ) - 'a' + 1;
_dos_setdrive( a, &b );
directory[ strlen( directory ) - 1 ] = 0;
chdir( directory );
}
/*
* get the parm list
*/
src = parm;
while( *src != 0 )
++src;
++src;
end = GetInPtr( GetTotalSize() - 1 );
dst = &buff[1];
for( ;; ) {
if( src > end )
break;
ch = *src;
if( ch == 0 )
ch = ' ';
*dst = ch;
++dst;
++src;
}
if( dst > &buff[1] )
--dst;
*dst = '\0';
buff[0] = dst-buff-1;
/*
* get starting point in task
*/
if( !GetStartAddress( exe_name, &StopNewTask.loc ) ) {
Out((OUT_ERR,"Could not get starting address"));
ret->err = WINERR_NOSTART;
LoadingDebugee = FALSE;
return( sizeof( *ret ) );
}
StopNewTask.segment_number = StopNewTask.loc.segment;
Out((OUT_LOAD,"Loading %s, cs:ip = %04x:%04lx", exe_name, StopNewTask.loc.segment,
StopNewTask.loc.offset ));
/*
* load the task
*/
loadp.cmdshow = &cmdshow;
loadp.wEnvSeg = 0;
loadp.lpCmdLine = (LPSTR) buff;
loadp.cmdshow->mustbe2 = 2;
loadp.cmdshow->cmdshow = SW_NORMAL;
loadp.reserved = 0L;
DebuggerState = LOADING_DEBUGEE;
DebugeeInstance = LoadModule( exe_name, (LPVOID) &loadp );
if( (UINT)DebugeeInstance < 32 ) {
Out((OUT_ERR,"Debugee did not load %d", DebugeeInstance));
ret->err = WINERR_NOLOAD;
LoadingDebugee = FALSE;
return( sizeof( *ret ) );
}
DebuggerWaitForMessage( WAITING_FOR_TASK_LOAD, NULL, RESTART_APP );
}
AddDebugeeModule();
pmsg = DebuggerWaitForMessage( WAITING_FOR_BREAKPOINT, DebugeeTask, RESTART_APP );
if( pmsg == START_BP_HIT ) {
ret->err = 0;
ret->task_id = (unsigned_32)DebugeeTask;
/*
* look for 32-bit windows application
*/
ReadMem( IntResult.CS, SIG_OFF, sig, sizeof( DWORD ) );
if( !StopOnExtender && (!memcmp( sig, win386sig, 4 ) ||
!memcmp( sig, win386sig2, 4 )) ) {
Out((OUT_LOAD,"Is Win32App" ));
Debugging32BitApp = TRUE;
/*
* make sure that WDEBUG.386 is installed
*/
if( !WDebug386 ) {
ret->err = WINERR_NODEBUG32; /* Can't debug 32 bit app */
LoadingDebugee = FALSE;
return( sizeof( *ret ) );
}
ret->flags |= LD_FLAG_IS_32;
if( tid == 0 ) {
WriteMem( IntResult.CS, SIG_OFF, win386sig2, sizeof( DWORD ) );
pmsg = DebuggerWaitForMessage( GOING_TO_32BIT_START,
DebugeeTask, RESTART_APP );
if( pmsg == FAULT_HIT && IntResult.InterruptNumber == INT_3 ) {
IntResult.EIP++;
SingleStepMode();
pmsg = DebuggerWaitForMessage( GOING_TO_32BIT_START,
DebugeeTask, RESTART_APP );
if( pmsg != FAULT_HIT || IntResult.InterruptNumber != INT_1 ) {
Out((OUT_ERR,"Expected INT_1 not found"));
ret->err = WINERR_NOINT1;
}
} else {
Out((OUT_ERR,"Expected INT_3 not found"));
ret->err = WINERR_NOINT3;
}
}
}
if( tid != 0 ) {
ret->flags |= LD_FLAG_IS_STARTED;
WasStarted = TRUE;
}
} else {
Out((OUT_ERR,"Starting breakpoint not found, pmsg=%d", pmsg ));
ret->err = WINERR_STARTNOTFOUND;
}
#if 0
if( DebugeeTask != NULL ) {
InitASynchHook();
}
#endif
LoadingDebugee = FALSE;
CurrentModule = 1;
ret->mod_handle = 0;
return( sizeof( *ret ) );
}
int main(int argc, char* argv[]) {
if (argc < 2) {
doHelp(argv[0]);
return 1;
}
OperationMode mode = kModeUpdate;
std::list<plString> addPaths;
std::list<plString> delPaths;
std::list<plString> sumFiles;
for (int i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
if (strcmp(argv[i], "-L") == 0) {
mode = kModeList;
} else if (strcmp(argv[i], "-i") == 0) {
mode = kModeManual;
if (++i >= argc) {
fprintf(stderr, "Error: Expected filename\n");
return 1;
}
addPaths.push_back(argv[i]);
} else if (strcmp(argv[i], "-d") == 0) {
mode = kModeManual;
if (++i >= argc) {
fprintf(stderr, "Error: Expected filename\n");
return 1;
}
delPaths.push_back(argv[i]);
} else if (strcmp(argv[i], "-c") == 0) {
s_createFile = true;
} else if (strcmp(argv[i], "-y") == 0) {
s_autoYes = true;
} else if (strcmp(argv[i], "-old") == 0) {
s_oldFormat = true;
} else if (strcmp(argv[i], "--help") == 0) {
doHelp(argv[0]);
return 0;
} else {
fprintf(stderr, "Error: Unrecognized option %s\n", argv[i]);
return 1;
}
} else {
sumFiles.push_back(argv[i]);
}
}
if (sumFiles.empty()) {
fprintf(stderr, "Error: No sum files specified\n");
return 1;
}
if (s_createFile && mode == kModeList) {
fprintf(stderr, "Error: -c and -L options cannot be combined\n");
return 1;
}
switch (mode) {
case kModeUpdate:
for (std::list<plString>::iterator fn = sumFiles.begin(); fn != sumFiles.end(); fn++) {
if (UpdateSums(*fn))
printf("Successfully updated %s\n", fn->cstr());
}
break;
case kModeList:
for (std::list<plString>::iterator fn = sumFiles.begin(); fn != sumFiles.end(); fn++) {
printf("%s:\n", fn->cstr());
try {
plEncryptedStream S;
if (!S.open(*fn, fmRead, plEncryptedStream::kEncAuto)) {
fprintf(stderr, "Could not open file %s\n", fn->cstr());
continue;
}
SumFile sum;
sum.read(&S);
S.close();
std::vector<SumEntry>::iterator it;
for (it = sum.fEntries.begin(); it != sum.fEntries.end(); it++)
PrintFile(*it, ' ');
printf("\n");
} catch (hsException& e) {
fprintf(stderr, "%s:%ld: %s\n", e.File(), e.Line(), e.what());
return 1;
} catch (...) {
fprintf(stderr, "An unknown error occured\n");
return 1;
}
}
break;
case kModeManual:
if (sumFiles.size() != 1) {
fprintf(stderr, "Error: You must specify exactly ONE sumfile for\n");
fprintf(stderr, "-i and -d operations\n");
return 1;
}
try {
bool isUpdated = false;
SumFile sum;
plEncryptedStream S;
plEncryptedStream::EncryptionType eType = plEncryptedStream::kEncXtea;
if (!s_createFile) {
if (!S.open(sumFiles.front(), fmRead, plEncryptedStream::kEncAuto)) {
fprintf(stderr, "Could not open file %s\n", sumFiles.front().cstr());
return 1;
}
eType = S.getEncType();
sum.read(&S);
S.close();
} else {
isUpdated = true;
}
std::list<plString>::iterator pi;
std::vector<SumEntry>::iterator it;
for (pi = delPaths.begin(); pi != delPaths.end(); pi++) {
bool found = false;
it = sum.fEntries.begin();
while (it != sum.fEntries.end()) {
if (it->fPath == *pi) {
PrintFile(*it, '-');
it = sum.fEntries.erase(it);
found = true;
isUpdated = true;
} else {
++it;
}
}
if (!found)
fprintf(stderr, "Warning: path '%s' not found\n", pi->cstr());
}
for (pi = addPaths.begin(); pi != addPaths.end(); pi++) {
hsFileStream* IS = FindFilePath(*pi, "");
if (IS == NULL) {
fprintf(stderr, "Warning: path '%s' not found\n", pi->cstr());
continue;
}
SumEntry ent;
ent.fPath = GetInternalName(*pi);
ent.fHash = plMD5::hashStream(IS);
ent.fTimestamp = IS->getModTime();
bool found = false;
it = sum.fEntries.begin();
while (it != sum.fEntries.end()) {
if (it->fPath == *pi) {
found = true;
if (it->fHash != ent.fHash) {
PrintFile(*it, '*');
it->fHash = ent.fHash;
it->fTimestamp = ent.fTimestamp;
isUpdated = true;
} else {
PrintFile(*it, ' ');
}
}
++it;
}
if (!found) {
PrintFile(ent, '+');
sum.fEntries.push_back(ent);
if (IS != NULL)
delete IS;
isUpdated = true;
}
}
if (isUpdated) {
if (!S.open(sumFiles.front(), fmWrite, eType)) {
fprintf(stderr, "Error: Could not open %s for writing!\n",
sumFiles.front().cstr());
return 1;
}
sum.write(&S);
S.close();
printf("Successfully %s %s\n",
s_createFile ? "created" : "updated",
sumFiles.front().cstr());
}
} catch (hsException& e) {
fprintf(stderr, "%s:%ld: %s\n", e.File(), e.Line(), e.what());
return 1;
} catch (...) {
fprintf(stderr, "An unknown error occured\n");
return 1;
}
break;
}
return 0;
}
bool UpdateSums(const plString& filename) {
bool isUpdated = false;
printf("%s:\n", filename.cstr());
try {
SumFile sum;
plEncryptedStream S;
plEncryptedStream::EncryptionType eType = plEncryptedStream::kEncXtea;
if (!s_createFile) {
if (!S.open(filename, fmRead, plEncryptedStream::kEncAuto)) {
fprintf(stderr, "Could not open file %s\n", filename.cstr());
return false;
}
eType = S.getEncType();
sum.read(&S);
S.close();
}
std::vector<SumEntry>::iterator it = sum.fEntries.begin();
while (it != sum.fEntries.end()) {
hsFileStream* IS = FindFilePath(it->fPath, cdUp(filename));
if (IS == NULL) {
if (s_autoYes) {
PrintFile(*it, '-');
it = sum.fEntries.erase(it);
isUpdated = true;
} else {
fprintf(stderr, "File %s not found. Remove it? [y/N] ",
it->fPath.cstr());
char buf[256];
fgets(buf, 256, stdin);
if (strcmp(buf, "y\n") == 0 || strcmp(buf, "Y\n") == 0) {
PrintFile(*it, '-');
it = sum.fEntries.erase(it);
isUpdated = true;
} else {
PrintFile(*it, '!');
++it;
}
}
continue;
}
plMD5Hash hash = plMD5::hashStream(IS);
it->fTimestamp = IS->getModTime();
if (it->fHash != hash) {
it->fHash = hash;
PrintFile(*it, '*');
isUpdated = true;
} else {
PrintFile(*it, ' ');
}
if (IS != NULL)
delete IS;
++it;
}
if (isUpdated) {
if (!S.open(filename, fmCreate, eType)) {
fprintf(stderr, "Error: Could not open %s for writing!\n", filename.cstr());
return false;
}
sum.write(&S);
S.close();
}
printf("\n");
} catch (hsException& e) {
fprintf(stderr, "%s:%ld: %s\n", e.File(), e.Line(), e.what());
} catch (...) {
fprintf(stderr, "An unknown error occured\n");
}
return isUpdated;
}
unsigned ReqProg_load( void )
{
char buffer[160];
char *src;
char *dst;
char *name;
char *endparm;
char *err;
tiny_ret_t rc;
prog_load_ret *ret;
unsigned_16 len;
SaveVectors( OrigVectors );
_DBG_EnterFunc( "AccLoadProg()" );
ret = GetOutPtr( 0 );
src = name = GetInPtr( sizeof( prog_load_req ) );
rc = FindFilePath( src, buffer, DosXExtList );
endparm = LinkParm;
while( *endparm++ != '\0' ) {} // skip program name
strcpy( endparm, buffer );
err = RemoteLink( LinkParm, 0 );
if( err != NULL ) {
_DBG_Writeln( "Can't RemoteLink" );
TinyWrite( TINY_ERR, err, strlen( err ) );
LoadError = err;
ret->err = 1;
len = 0;
} else {
if( TINY_OK( rc ) ) {
while( *src++ != '\0' ) {}
len = GetTotalSize() - ( src - name ) - sizeof( prog_load_req );
dst = (char *)buffer;
while( *dst++ != '\0' ) {};
memcpy( dst, src, len );
dst += len;
_DBG_Writeln( "StartPacket" );
StartPacket();
_DBG_Writeln( "AddPacket" );
AddPacket( sizeof( prog_load_req ), In_Mx_Ptr[0].ptr );
_DBG_Writeln( "AddPacket" );
AddPacket( dst - buffer, buffer );
_DBG_Writeln( "PutPacket" );
PutPacket();
_DBG_Writeln( "GetPacket" );
len = GetPacket();
_DBG_Writeln( "RemovePacket" );
RemovePacket( sizeof( *ret ), ret );
} else {
len = DoAccess();
}
_DBG_Writeln( "Linked --" );
if( ret->err != 0 ) {
get_err_text_req erracc;
prog_kill_req killacc;
int msg_len;
_DBG_Writeln( "loadret->errcode != 0" );
if( LoadError == NULL ) {
_DBG_Writeln( "making a REQ_GET_ERR_TEXT request" );
erracc.req = REQ_GET_ERR_TEXT;
erracc.err = ret->err;
_DBG_Writeln( "StartPacket" );
StartPacket();
_DBG_Writeln( "AddPacket" );
AddPacket( sizeof( erracc ), &erracc );
_DBG_Writeln( "PutPacket" );
PutPacket();
_DBG_Writeln( "GetPacket" );
msg_len = GetPacket();
_DBG_Writeln( "RemovePacket" );
RemovePacket( msg_len, FailMsg );
_DBG_Write( "FailMsg : " );
_DBG_NoTabWriteln( FailMsg );
LoadError = FailMsg;
}
_DBG_Writeln( "making a REQ_PROG_KILL request" );
killacc.req = REQ_PROG_KILL;
_DBG_Writeln( "StartPacket" );
StartPacket();
_DBG_Writeln( "AddPacket" );
AddPacket( sizeof( killacc ), &killacc );
_DBG_Writeln( "PutPacket" );
PutPacket();
_DBG_Writeln( "GetPacket" );
GetPacket();
//RemovePacket( msg_len, &erracc );
RemoteUnLink();
TaskLoaded = FALSE;
}
}
if( ret->err == 0 ) {
_DBG_Writeln( "loadret->error_code == 0" );
TaskLoaded = TRUE;
}
SaveVectors( LoadVectors );
SaveVectors( CurrVectors );
_DBG_ExitFunc( "AccLoadProg()" );
return( len );
}
unsigned ReqProg_load( void )
{
char **args;
char *parms;
char *parm_start;
int i;
char exe_name[PATH_MAX];
char *name;
pid_t save_pgrp;
prog_load_req *acc;
prog_load_ret *ret;
unsigned len;
int status;
acc = GetInPtr( 0 );
ret = GetOutPtr( 0 );
last_sig = -1;
have_rdebug = FALSE;
dbg_dyn = NULL;
at_end = FALSE;
parms = (char *)GetInPtr( sizeof( *acc ) );
parm_start = parms;
len = GetTotalSize() - sizeof( *acc );
if( acc->true_argv ) {
i = 1;
for( ;; ) {
if( len == 0 ) break;
if( *parms == '\0' ) {
i++;
}
++parms;
--len;
}
args = alloca( i * sizeof( *args ) );
parms = parm_start;
len = GetTotalSize() - sizeof( *acc );
i = 1;
for( ;; ) {
if( len == 0 ) break;
if( *parms == '\0' ) {
args[i++] = parms + 1;
}
++parms;
--len;
}
args[i - 1] = NULL;
} else {
while( *parms != '\0' ) {
++parms;
--len;
}
++parms;
--len;
i = SplitParms( parms, NULL, len );
args = alloca( (i + 2) * sizeof( *args ) );
args[SplitParms( parms, &args[1], len ) + 1] = NULL;
}
args[0] = parm_start;
attached = TRUE;
pid = RunningProc( args[0], &name );
if( pid == 0 || ptrace( PTRACE_ATTACH, pid, NULL, NULL ) == -1 ) {
attached = FALSE;
args[0] = name;
if( FindFilePath( TRUE, args[0], exe_name ) == 0 ) {
exe_name[0] = '\0';
}
save_pgrp = getpgrp();
setpgid( 0, OrigPGrp );
pid = fork();
if( pid == -1 )
return( 0 );
if( pid == 0 ) {
if( ptrace( PTRACE_TRACEME, 0, NULL, NULL ) < 0 ) {
exit( 1 );
}
execve( exe_name, (const char **)args, (const char **)dbg_environ );
exit( 1 ); /* failsafe */
}
setpgid( 0, save_pgrp );
} else if( pid ) {
GetExeNameFromPid( pid, exe_name, PATH_MAX );
}
ret->flags = 0;
ret->mod_handle = 0;
if( (pid != -1) && (pid != 0) ) {
int status;
ret->task_id = pid;
ret->flags |= LD_FLAG_IS_PROT | LD_FLAG_IS_32;
/* wait until it hits _start (upon execve) or
gives us a SIGSTOP (if attached) */
if( waitpid( pid, &status, 0 ) < 0 )
goto fail;
if( !WIFSTOPPED( status ) )
goto fail;
if( attached ) {
ret->flags |= LD_FLAG_IS_STARTED;
if( WSTOPSIG( status ) != SIGSTOP )
goto fail;
} else {
if( WSTOPSIG( status ) != SIGTRAP )
goto fail;
}
#if defined( MD_x86 )
if( !GetFlatSegs( &flatCS, &flatDS ) )
goto fail;
#endif
dbg_dyn = GetDebuggeeDynSection( exe_name );
AddProcess();
errno = 0;
}
ret->err = errno;
if( ret->err != 0 ) {
pid = 0;
}
CONV_LE_32( ret->err );
CONV_LE_32( ret->task_id );
CONV_LE_32( ret->mod_handle );
return( sizeof( *ret ) );
fail:
if( pid != 0 && pid != -1 ) {
if( attached ) {
ptrace( PTRACE_DETACH, pid, NULL, NULL );
attached = FALSE;
} else {
ptrace( PTRACE_KILL, pid, NULL, NULL );
waitpid( pid, &status, 0 );
}
}
pid = 0;
CONV_LE_32( ret->err );
CONV_LE_32( ret->task_id );
CONV_LE_32( ret->mod_handle );
return( 0 );
}
