home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The Fred Fish Collection 1.5
/
ffcollection-1-5-1992-11.iso
/
ff_disks
/
300-399
/
ff388.lzh
/
SnoopDos
/
snoopdos.c
< prev
next >
Wrap
C/C++ Source or Header
|
1990-10-23
|
32KB
|
1,147 lines
/*
* SNOOPDOS.C
*
* (C) Copyright Eddy Carroll, May 1990. Freely distributable.
*
* Snoopdos patches into dos.library and outputs a message to a
* debugging window or file whenever a process calls certain DOS
* functions.
*
* Type snoopdos -h for a list of available options. See the
* documentation for further details.
*
* Compiles under Lattice C V5.04. I use flags: -cusq -j88i -ms -v
*/
#ifndef LATTICE_50
#include "system.h"
#endif
/*
* Assorted strings
*/
#define TITLE \
"SnoopDos V1.0 (C) Copyright Eddy Carroll, Sept 1990. Freely distributable."
char *HEADER =
"Process name Func Filename Mode Res."
"\r\n"
"------------ ---- -------- ---- ----"
"\r\n";
#define PORTNAME "SnoopDos Port"
#define DEFWINDOW "CON:0/0/640/120/"
/*
* The following message array contains both colour and non-colour
* versions of the various short message strings displayed.
*/
char *msgs[][2] = {
/* Monochrome Colour */
/* ---------- ------ */
"OLD ", "OLD ",
"NEW ", "\033[33mNEW\033[0m ",
"R/W ", "\033[32mR/W\033[0m ",
"??? ", "??? ",
"SHAR", "SHAR",
"EXCL", "\033[33mEXCL\033[0m",
"????", "????",
"Okay\r\n", "Okay\r\n",
"Fail\r\n", "\033[33mFail\033[0m\r\n",
">", "\033[33m>\033[0m",
"> (Done)", "> (Done)",
"Warning: Missed", "\033[33mWarning:\033[0m Missed",
">>>>\r\n", ">>>>\r\n",
"Open", "Open",
"Lock", "\033[33mLock\033[0m",
"Load", "\033[32mLoad\033[0m",
"Exec", "\033[32mExec\033[0m",
"CD ", "CD ",
"Del ", "\033[33mDel\033[0m "
};
#define TXT_OLD msgs[ 0][colour]
#define TXT_NEW msgs[ 1][colour]
#define TXT_R_W msgs[ 2][colour]
#define TXT_QM3 msgs[ 3][colour]
#define TXT_SHAR msgs[ 4][colour]
#define TXT_EXCL msgs[ 5][colour]
#define TXT_QM4 msgs[ 6][colour]
#define TXT_OKAY msgs[ 7][colour]
#define TXT_FAIL msgs[ 8][colour]
#define TXT_POINT msgs[ 9][colour]
#define TXT_DONE msgs[10][colour]
#define TXT_WARN msgs[11][colour]
#define TXT_NEST msgs[12][colour]
#define TXT_OPEN msgs[13][colour]
#define TXT_LOCK msgs[14][colour]
#define TXT_LOAD msgs[15][colour]
#define TXT_EXEC msgs[16][colour]
#define TXT_CURDIR msgs[17][colour]
#define TXT_DELETE msgs[18][colour]
#define POINT(x) ((x) ? TXT_POINT : " ")
/*
* Now some standard system-type macros
*/
#define reg_d0 register __d0
#define reg_d1 register __d1
#define reg_d2 register __d2
#define reg_d3 register __d3
#define reg_a0 register __a0
#define BTOC(x) (void *)(((ULONG)x) << 2)
#define D_S(name, type) char c_##name[sizeof(type)+3];\
type *name = (type *)((long)(c_##name+3) & ~3)
extern __asm BPTR CallOpen(reg_d1 UBYTE *, reg_d2 int);
extern __asm BPTR CallLock(reg_d1 UBYTE *, reg_d2 int);
extern __asm BPTR CallLoadSeg(reg_d1 UBYTE *);
extern __asm LONG CallExecute(reg_d1 UBYTE *, reg_d2 BPTR, reg_d3 BPTR);
extern __asm BPTR CallCurrentDir(reg_d1 BPTR);
extern __asm LONG CallDeleteFile(reg_d1 UBYTE *);
/*
* Structure used to pass messages back and fro
*/
typedef struct {
struct Message msg; /* Standard message header */
struct Process *process; /* Sending process id */
int msgtype; /* Message type, see below */
int data1; /* Data field 1 */
void *data2; /* Data field 2 */
} MYMSG;
/*
* Now the various settings that can be set to affect the monitoring
*/
typedef struct {
int set_doopen; /* If true, monitor Open() */
int set_dolock; /* If true, monitor Lock() */
int set_doloadseg; /* If true, monitor LoadSeg() */
int set_doexecute; /* If true, monitor Execute() */
int set_docurdir; /* If true, monitor CurrentDir() */
int set_dodelete; /* If true, monitor DeleteFile() */
int set_showfullpath; /* If true, display full paths */
int set_sleepwait; /* If true, sleep if necessary */
int set_snoopactive; /* If true, monitoring is active */
int set_colour; /* If true, use ANSI colour codes */
} SETTINGS;
/*
* Default settings
*/
SETTINGS settings = { 1, 0, 1, 1, 1, 1, 0, 0, 1, 1 };
/*
* These defines allow the various settings to be accessed as
* normal variables rather than structure members; this is purely
* for convenience.
*/
#define doopen settings.set_doopen
#define dolock settings.set_dolock
#define doloadseg settings.set_doloadseg
#define doexecute settings.set_doexecute
#define docurdir settings.set_docurdir
#define dodelete settings.set_dodelete
#define showfullpath settings.set_showfullpath
#define sleepwait settings.set_sleepwait
#define snoopactive settings.set_snoopactive
#define colour settings.set_colour
/*
* Now the various message types that can be sent
*/
typedef enum {
MSG_QUIT, /* Quit */
MSG_GETOPTIONS, /* Read options */
MSG_SETOPTIONS, /* Update options */
MSG_OPEN, /* Open file */
MSG_OPEN_DONE, /* Open file completed */
MSG_LOCK, /* Lock file */
MSG_LOCK_DONE, /* Lock file completed */
MSG_LOADSEG, /* LoadSeg file */
MSG_LOADSEG_DONE, /* LoadSeg file completed */
MSG_EXECUTE, /* Execute command */
MSG_CURDIR, /* CurrentDir */
MSG_DELETE, /* DeleteFile */
MSG_DELETE_DONE, /* DeleteFile completed */
} MSGTYPES;
struct SignalSemaphore sem[1];
struct MsgPort *myport; /* Pointer to background SnoopDos msg port */
struct MsgPort *inport; /* Pointer to our own message port */
struct Task *snooptask; /* Pointer to our own task */
BPTR debugwin; /* Output file or window */
BPTR stderr; /* Standard CLI console */
int extfile; /* True if output directed to external file */
char extfilename[100]; /* Name of window/file to open if specified */
char outbuf[800]; /* Output buffer used by myprintf() etc. */
int missed_open_sig; /* Signal to indicate Open() missed */
int missed_lock_sig; /* Signal to indicate Lock() missed */
int missed_loadseg_sig; /* Signal to indicate LoadSeg() missed */
int missed_execute_sig; /* Signal to indicate Execute() missed */
int missed_curdir_sig; /* Signal to indicate CurrentDir() missed */
int missed_delete_sig; /* Signal to indicate DeleteFile() missed */
int portsig; /* Signal used by our public port */
/**************************** Start of Functions ****************************/
/*
* cleanup()
* ---------
* Cleans up all active resources and exits. If err is -1, then
* returns instead of exiting.
*/
void cleanup(int err)
{
static int called = 0;
if (called++) /* Make sure not called twice by accident */
return;
if (inport)
DeletePort(inport);
if (debugwin)
Close(debugwin);
if (stderr)
Close(stderr);
if (err != -1)
exit(err);
}
/*
* myprintf(), myfprintf()
* -----------------------
* Two low cost alternatives to printf that go directly to AmigaDOS
* Note we deliberately use the pre-ANSI declaration, to avoid Lattice
* kicking up a fuss about the wrong number of parameters.
*/
void myprintf(format, p1, p2, p3, p4, p5, p6)
UBYTE *format;
ULONG p1, p2, p3, p4, p5, p6;
{
sprintf(outbuf, format, p1, p2, p3, p4, p5, p6);
Write(Output(), outbuf, strlen(outbuf));
}
void myfprintf(file, format, p1, p2, p3, p4, p5, p6)
BPTR file;
char *format;
ULONG p1, p2, p3, p4, p5, p6;
{
sprintf(outbuf, format, p1, p2, p3, p4, p5, p6);
Write(file, outbuf, strlen(outbuf));
}
#define printf myprintf
#define fprintf myfprintf
/*
* sendmsg()
* ---------
* Sends a message to myport, and waits for a reply to arrive.
* A message type and some message data are all that need be provided
* by the caller; the callee will provide the rest. Doesn't return
* until a reply has been received.
*/
void sendmsg(int type, int data1, void *data2)
{
MYMSG msg;
struct Process *me = (struct Process *)FindTask(0);
struct MsgPort *replyport = &me->pr_MsgPort;
msg.msg.mn_Node.ln_Type = NT_MESSAGE;
msg.msg.mn_Length = sizeof(MYMSG);
msg.msg.mn_ReplyPort = replyport;
msg.process = me;
msg.msgtype = type;
msg.data1 = data1;
msg.data2 = data2;
PutMsg(myport, &msg);
WaitPort(replyport);
GetMsg(replyport);
}
/*
* getlockpath()
* -------------
* Returns a pointer to a string containing the full path for the
* specified lock. You must copy the string before calling this
* routine again.
*/
char *getlockpath(BPTR lock)
{
struct Process *p = (struct Process *)FindTask(0L);
APTR oldwin = p->pr_WindowPtr;
static char path[300];
int pos = 299;
BPTR mylock;
char *name;
D_S(fib, struct FileInfoBlock);
int err = 0;
p->pr_WindowPtr = (APTR)-1; /* Disable error requesters */
mylock = DupLock(lock);
path[pos] = '\0';
do {
int len;
BPTR newlock;
if (!Examine(mylock, fib))
err++;
name = fib->fib_FileName;
if (*name == '\0')
name = "RAM"; /* Workaround for old RAM: disk bug */
len = strlen(name);
pos = pos - len - 1;
newlock = ParentDir(mylock);
UnLock(mylock);
mylock = newlock;
strncpy(path + pos, name, len);
if (mylock)
path[pos + len] = '/';
else
path[pos + len] = ':';
} while (mylock);
p->pr_WindowPtr = oldwin; /* Enable error requesters again */
if (err) {
/*
* Volume not present so have to be happy with just
* returning the volume node instead.
*/
struct FileLock *fl = BTOC(lock);
struct DeviceList *dl = BTOC(fl->fl_Volume);
UBYTE *name = BTOC(dl->dl_Name);
strncpy(path, name + 1, *name);
path[*name] = '\0';
strcat(path, ":.../");
return (path);
} else
return (path + pos);
}
/*
* makepath()
* ----------
* Builds a full path string given a process ptr and a filename.
* If the filename includes relative references (// or :)
* these are handled also. The point of this is to resolve relative
* directory references.
*
* Returns TRUE if a new string was generated, FALSE if the existing
* string didn't depend on the current directory (this doesn't affect
* the output stored in buf though).
*/
int makepath(char *buf, BPTR curdir, char *filename)
{
char *origfilename = filename;
int pos;
int doneroot = 0;
/*
* Special check for the 'current process console' file '*'
*/
if (strcmp(filename, "*") == 0) {
strcpy(buf, filename);
return (FALSE);
}
strcpy(buf, getlockpath(curdir));
pos = strlen(buf);
for (;;) {
if (!doneroot && *filename == ':') {
/*
* Path is relative to root
*/
doneroot = 1;
for (pos = 0; buf[pos] && buf[pos] != ':'; pos++)
;
if (buf[pos] == ':')
pos++;
} else if (*filename == '/') {
/*
* Path is relative to parent directory; if none, then
* remains the same.
*/
int newpos = pos - 2;
while (newpos >= 0 && buf[newpos] != '/' && buf[newpos] != ':')
newpos--;
if (newpos >= 0)
pos = newpos + 1;
} else {
/*
* No more special characters; just append what's left of
* the filename.
*/
if (!doneroot) {
/*
* If the filename wasn't relative to the root
* directory, then make sure there are no device/volume
* references contained within it. We copy the original
* filename rather than the currently modified version
* since a volume name of /A: is legal and the / would
* be stripped off the modified name.
*/
char *p;
for (p = filename; *p; p++) {
if (*p == ':') {
strcpy(buf, origfilename);
return (0);
}
}
}
strcpy(buf + pos, filename);
return (1);
}
filename++;
}
}
/*
* OutputLine()
* ------------
* Outputs a line of text in the main window, according to the
* truncation mechanism used.
*/
/*
* mainloop()
* ----------
* This is the main event loop for SnoopDOS, where everything happens.
* Control is passed here when SnoopDOS first starts up. When this
* function returns, it terminates the background process.
*/
void mainloop(void)
{
static char fullname[300];
int done = 0; /* True if finished processing */
int col0 = 1; /* True if cursor in column 0 */
int nested = 0; /* True if nested DOS calls */
#define MISSED_NONE 0 /* Haven't missed anything */
#define MISSED_OPEN (1 << 0) /* Missed Open() call */
#define MISSED_LOCK (1 << 1) /* Missed Lock() call */
#define MISSED_LOADSEG (1 << 2) /* Missed LoadSeg() call */
#define MISSED_EXECUTE (1 << 3) /* Missed Execute() call */
#define MISSED_CURDIR (1 << 4) /* Missed CurrentDir() call */
#define MISSED_DELETE (1 << 5) /* Missed DeleteFile() call */
int missed = MISSED_NONE; /* Was a DOS function missed? See above */
inport = CreatePort(PORTNAME, 0);
if (!inport) {
fprintf(stderr, "SnoopDos: Can't allocate message port.\n");
cleanup(-1);
return;
}
myport = inport;
portsig = 1 << myport->mp_SigBit;
/*
* Allocate signals
*/
missed_open_sig = 1 << AllocSignal(-1);
missed_lock_sig = 1 << AllocSignal(-1);
missed_loadseg_sig = 1 << AllocSignal(-1);
missed_execute_sig = 1 << AllocSignal(-1);
missed_curdir_sig = 1 << AllocSignal(-1);
missed_delete_sig = 1 << AllocSignal(-1);
if ( missed_open_sig == -1 || missed_lock_sig == -1 ||
missed_loadseg_sig == -1 || missed_execute_sig == -1 ||
missed_curdir_sig == -1 || missed_delete_sig == -1) {
fprintf(stderr, "SnoopDos: Can't allocate enough signals.\n");
cleanup(-1);
return;
}
if (extfile) {
debugwin = Open(extfilename, MODE_NEWFILE);
if (!debugwin) {
fprintf(stderr, "SnoopDos: Can't open file %s for output.\n",
extfilename);
cleanup(-1);
return;
}
fprintf(debugwin, "\r\n" TITLE "\r\n\r\n");
} else {
debugwin = Open(DEFWINDOW TITLE, MODE_NEWFILE);
if (!debugwin) {
fprintf(stderr, "SnoopDos: Can't open display window.\n");
cleanup(-1);
return;
}
}
Close(stderr); stderr = NULL;
if (!extfile) {
fprintf(debugwin, "\n"
"Type CTRL-E/CTRL-D to enable/disable snooping. Type CTRL-C to exit.\n\n");
};
fprintf(debugwin, HEADER);
InitSemaphore(sem);
snooptask = FindTask(0L);
installdospatch();
/*
* Now just sit processing messages
*/
while (!done) {
int mask;
#define SIGMASK (portsig | missed_open_sig | missed_lock_sig | \
missed_loadseg_sig | missed_execute_sig | \
missed_curdir_sig | missed_delete_sig | \
SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E)
mask = Wait(SIGMASK);
if (mask & SIGBREAKF_CTRL_C)
done = 1;
if (mask & SIGBREAKF_CTRL_D) {
if (snoopactive) {
fprintf(debugwin,
"\nSnooping now disabled; type CTRL-E to enable it again.\r\n\r\n");
snoopactive = 0;
}
}
if (mask & SIGBREAKF_CTRL_E) {
if (!snoopactive) {
fprintf(debugwin,
"Snooping now enabled; type CTRL-D to disable it again.\r\n\r\n%s", HEADER);
snoopactive = 1;
}
}
if (mask & missed_open_sig)
missed |= MISSED_OPEN;
if (mask & missed_lock_sig)
missed |= MISSED_LOCK;
if (mask & missed_loadseg_sig)
missed |= MISSED_LOADSEG;
if (mask & missed_execute_sig)
missed |= MISSED_EXECUTE;
if (mask & missed_curdir_sig)
missed |= MISSED_CURDIR;
if (mask & missed_delete_sig)
missed |= MISSED_DELETE;
if (mask & portsig) {
MYMSG *msg;
/*
* Note in the following, there is some slightly tricky
* stuff to handle the case where a DOS function calls
* another DOS function internally. Under 1.3, this doesn't
* happen, but it may under WB 2.0 and in addition, Jim
* Goodnow's handy Rez utility patches LoadSeg() so that
* it calls Open(). `nested' is true when a nested call
* like this happens, and in this case, process names are
* printed out prefixed by `> ' to indicate the nesting.
*
* The nesting is detected because an incoming Open/Lock/
* LoadSeg message will arrive when the cursor is positioned
* to print a Fail/Okay result from a previous call (i.e.
* col0 is false; the cursor is not in column 0). When a
* result arrives in and the cursor IS in column 0, then
* this must be the result from an earlier call so the
* nesting is ended. Note that the semaphores used ensures
* that this situation can only ever occur as a result of
* nesting; other tasks will always wait until they are
* properly in sync before sending messages to the main
* Snoopdos process.
*
* The more alert among you are probably saying something
* like "Ah, but what if SnoopDos is configured to display
* all DOS calls, even if it means forcing some tasks to
* sleep until SnoopDos can process them? Then, when a
* task calls LoadSeg() (say) and LoadSeg() calls Open(),
* Open() will sleep forever waiting for the semaphore
* Obtain()ed by LoadSeg() to become free again." Well,
* in fact, it won't, since exec's ObtainSemaphore() call
* will suceed even when the semaphore is in use, IF the
* caller is the task that owns the semaphore -- and in such
* a case, the caller will be the same task. (It took me a
* while to figure out exactly what things were working --
* it looked like I should get a serious lockup in certain
* circumstances).
*
*/
while ((msg = (MYMSG *)GetMsg(myport)) != NULL) {
/*
* Get the name of the process/command for
* printing out if necessary.
*/
static char namebuf[256];
UBYTE *procname = msg->process->pr_Task.tc_Node.ln_Name;
struct CommandLineInterface *cli = BTOC(msg->process->pr_CLI);
BPTR curdir = msg->process->pr_CurrentDir;
UBYTE *s;
UBYTE *filename;
int newname; /* If true, a new name was generated */
if (!col0 && (msg->msgtype == MSG_OPEN ||
msg->msgtype == MSG_LOCK ||
msg->msgtype == MSG_LOADSEG ||
msg->msgtype == MSG_CURDIR ||
msg->msgtype == MSG_DELETE)) {
nested = 1;
fprintf(debugwin, TXT_NEST);
}
if (cli && cli->cli_Module) {
UBYTE *cliname = BTOC(cli->cli_CommandName);
if (*cliname > 0) {
/* Only use CLI name if it's not null */
strncpy(namebuf+2, cliname + 1, *cliname);
namebuf[*cliname+2] = '\0';
procname = namebuf + 2;
if (nested) {
/*
* If we're not at column 0, then we're
* calling this DOS function from within
* another DOS function so indent display
*/
procname = namebuf;
procname[0] = '>';
procname[1] = ' ';
}
}
} else {
if (nested) {
sprintf(namebuf, "> %s", procname);
procname = namebuf;
}
}
/*
* Now handle the message
*/
filename = msg->data2; /* Standard file name */
newname = 0; /* No problems expanding it */
switch (msg->msgtype) {
case MSG_QUIT:
done = 1;
break;
case MSG_GETOPTIONS:
memcpy(msg->data2, &settings, sizeof(SETTINGS));
break;
case MSG_SETOPTIONS:
memcpy(&settings, msg->data2, sizeof(SETTINGS));
break;
case MSG_OPEN:
if (msg->data1 == MODE_OLDFILE)
s = TXT_OLD;
else if (msg->data1 == MODE_NEWFILE)
s = TXT_NEW;
else if (msg->data1 == MODE_READWRITE)
s = TXT_R_W;
else
s = TXT_QM3;
if (showfullpath) {
newname = makepath(fullname, curdir, msg->data2);
filename = fullname;
}
fprintf(debugwin, "%-21s %s %s%-39s %s ", procname,
TXT_OPEN, POINT(newname), filename, s);
col0 = 0;
break;
case MSG_LOCK:
if (msg->data1 == ACCESS_READ)
s = TXT_SHAR;
else if (msg->data1 == ACCESS_WRITE)
s = TXT_EXCL;
else
s = TXT_QM4;
if (showfullpath) {
newname = makepath(fullname, curdir, msg->data2);
filename = fullname;
}
fprintf(debugwin, "%-21s %s %s%-39s %s ", procname,
TXT_LOCK, POINT(newname), filename, s);
col0 = 0;
break;
case MSG_LOADSEG:
if (showfullpath) {
newname = makepath(fullname, curdir, msg->data2);
filename = fullname;
}
fprintf(debugwin, "%-21s %s %s%-44s ", procname,
TXT_LOAD, POINT(newname), filename);
col0 = 0;
break;
case MSG_EXECUTE:
fprintf(debugwin, "%-21s %s %s\r\n", procname,
TXT_EXEC, filename);
col0 = 1;
break;
case MSG_CURDIR:
{
char *dirname = getlockpath(msg->data1);
int i = strlen(dirname);
if (dirname[i-1] == '/')
dirname[i-1] = '\0';
fprintf(debugwin, "%-21s %s %s\r\n", procname,
TXT_CURDIR, dirname);
col0 = 1;
}
break;
case MSG_DELETE:
if (showfullpath) {
newname = makepath(fullname, curdir, msg->data2);
filename = fullname;
}
fprintf(debugwin, "%-21s %s %s%-44s ", procname,
TXT_DELETE, POINT(newname), filename);
col0 = 0;
break;
case MSG_LOCK_DONE:
case MSG_OPEN_DONE:
case MSG_LOADSEG_DONE:
case MSG_DELETE_DONE:
if (col0 && nested) {
fprintf(debugwin, "%-73s", TXT_DONE);
nested = 0;
}
if (msg->data1)
fprintf(debugwin, TXT_OKAY);
else
fprintf(debugwin, TXT_FAIL);
col0 = 1;
break;
}
ReplyMsg(msg);
}
}
/*
* Finally, check if we missed a DOS function. If we did,
* AND we are in column 0, print out an appropriate message.
* Otherwise, wait until next time. This stops the display
* getting messed up when waiting to print a 'Fail' or 'Okay'.
*/
if (missed) {
if (col0) {
if (missed & MISSED_OPEN)
fprintf(debugwin, "%s an Open()\r\n", TXT_WARN);
if (missed & MISSED_LOCK)
fprintf(debugwin, "%s a Lock()\r\n", TXT_WARN);
if (missed & MISSED_LOADSEG)
fprintf(debugwin, "%s a LoadSeg()\r\n", TXT_WARN);
if (missed & MISSED_EXECUTE)
fprintf(debugwin, "%s an Execute()\r\n", TXT_WARN);
if (missed & MISSED_CURDIR)
fprintf(debugwin, "%s a CurrentDir()\r\n", TXT_WARN);
if (missed & MISSED_DELETE)
fprintf(debugwin, "%s a DeleteFile()\r\n", TXT_WARN);
missed = MISSED_NONE;
}
}
}
/*
* Remove the port from the public ports list; this stops any
* SnoopDos processes started up elsewhere from trying to
* communicate with us (which may happen if this process can't
* exit immediately).
*/
RemPort(myport);
myport->mp_Node.ln_Name = NULL;
/*
* Now remove the dospatch, reply to all messages currently
* pending and cleanup.
*/
if (!uninstalldospatch()) {
/*
* Someone else has patched DOSbase so print a message for
* the user and keep trying every 5 seconds until we succeed.
*/
int count = 0;
fprintf(debugwin,
"\r\n"
"Someone else has patched dos.library so I'll have to wait until they quit."
"\r\n");
if (!extfile) {
fprintf(debugwin,
"This window will close shortly though to stop it from annoying you.\r\n");
}
do {
Delay(250); /* Wait 5 seconds */
if (debugwin) {
count++;
if (count > 2) {
Close(debugwin);
debugwin = NULL;
}
}
} while (!uninstalldospatch());
}
if (debugwin)
fprintf(debugwin, "\r\nSnoopDos terminated.\r\n");
/*
* To make sure there is no code still executing in our task
* before we exit, we allocate the semaphore used to ensure
* exclusive access to the code, then wait a small time to allow
* the other task a chance to execute the final instruction or two
* left in our code after it releases the semaphore. This is not
* foolproof :-( but it's better than nothing.
*/
{
MYMSG *msg;
while (msg = (MYMSG *)GetMsg(myport))
ReplyMsg(msg);
}
ObtainSemaphore(sem);
Delay(10); /* Wait 0.2 seconds */
cleanup(-1);
}
/*
* main()
* ------
* Mainline. Parses the command line and, if necessary, kicks off the
* background task to do the real work.
*/
void main(int argc, char **argv)
{
int error = 0; /* True if error detected in cmd line */
int quit = 0; /* True if we want to quit */
int colsel = 0; /* True if colour option was specified */
/*
* See if we are already active elsewhere; if yes, then read in
* the default settings used by that process.
*/
myport = FindPort(PORTNAME);
if (myport)
sendmsg(MSG_GETOPTIONS, 0, &settings);
while (argc > 1 && argv[1][0] == '-') {
int val;
/* Make -X == -x0 and -x == -x1 */
if (argv[1][1] >= 'a' && argv[1][2] != '0')
val = 1;
else
val = 0;
switch (tolower(argv[1][1])) {
case 'a': colour = val;
colsel = 1; break; /* Display ANSI colour */
case 'c': docurdir = val; break; /* Monitor CurrentDir() */
case 'd': dodelete = val; break; /* Monitor DeleteFile() */
case 'f': showfullpath = val; break; /* Show full filepath */
case 'g': doloadseg = val; break; /* Monitor LoadSeg() */
case 'h': error = 1; break; /* Just print help msg */
case 'l': dolock = val; break; /* Monitor Lock() */
case 'm': snoopactive = val; break; /* Actively monitoring */
case 'o': doopen = val; break; /* Monitor Open() */
case 'q': quit = 1; break; /* Ask SnoopDos to quit */
case 'r': error = 2; break; /* Report settings */
case 'w': sleepwait = val; break; /* Wait when necessary */
case 'x': doexecute = val; break; /* Monitor Execute() */
case 'z':
if (argv[1][2]) {
strcpy(extfilename, &argv[1][2]);
extfile = 1;
} else {
argv++;
argc--;
if (argc > 1) {
strcpy(extfile, argv[1]);
extfile = 1;
}
}
if (!extfile) {
printf(
"-z must be followed by a filename. Type SnoopDos -h for help.\n");
exit(5);
}
/*
* If outputting to a file, make colour off
* by default, rather than on.
*/
if (colsel == 0)
colour = 0;
break;
default:
printf("Unrecognised option %s. Type Snoopdos -h for help.\n",
argv[1]);
exit(5);
}
argv++; argc--;
}
if (argc > 1)
error = 1;
if (error) {
if (error == 1) {
printf(TITLE "\n\n"
"SnoopDos monitors calls made to various AmigaDOS functions by all processes\n"
"on the system. The following options are available. Use -x1 or just -x to\n"
"enable an option, -X or -x0 to disable that option. Current settings in (-)."
"\n\n");
} else
printf("Current SnoopDos settings:\n\n");
#define O(x,y) printf(x, y ? "(on)" : "(off)")
O(" -a Use ANSI colour sequences %s\n", colour);
O(" -c Monitor CurrentDir() calls %s\n", docurdir);
O(" -d Monitor DeleteFile() calls %s\n", dodelete);
O(" -f Display full filename paths %s\n", showfullpath);
O(" -g Monitor LoadSeg() calls %s\n", doloadseg);
O(" -l Monitor Lock() calls %s\n", dolock);
O(" -m Globally enable/disable monitoring %s\n", snoopactive);
O(" -o Monitor Open() calls %s\n", doopen);
O(" -w Display all activity, sleeping if necessary %s\n", sleepwait);
O(" -x Monitor Execute() calls %s\n", doexecute);
if (error == 1) {
printf("\n"
" -h Print out this help message\n"
" -q Tell SnoopDos to quit\n"
" -r Report current SnoopDos settings\n"
" -z% Output to file % (e.g. -zCON:0/0/640/100/SnoopDos or -zSER:)\n"
"\n");
}
cleanup(5);
}
/*
* First see are we already installed. If so, send a copy of the
* updated settings to the background process, or send a QUIT
* message if the user wanted to quit.
*/
if (myport) {
if (quit)
sendmsg(MSG_QUIT, 0, 0);
else
sendmsg(MSG_SETOPTIONS, 0, &settings);
cleanup(0);
}
/*
* If user wanted to quit and we weren't already running, just
* quit without doing anything.
*/
if (quit) {
printf("There is no background SnoopDos process to tell to quit!\n");
cleanup(0);
}
/*
* Not installed, so install ourselves. First of all though, we
* kick ourselves into the background and return control to the
* calling CLI. We need to do this before we start creating ports
* and opening files, to prevent Exec and AmigaDOS getting
* confused about which task we are.
*
* Also open stderr channel for the new task to output fatal
* error messages to; the new task takes responsibility for closing
* this channel.
*/
stderr = Open("*", MODE_NEWFILE);
if (!res("SnoopDos", 5, mainloop, 4000)) {
printf("Couldn't spawn background SnoopDos task.\n");
cleanup(10);
}
}
/*
* NewOpen()
* ---------
* This is the new Open() code. It checks to see if the calling task
* is actually the SnoopDos task; if it is, then it essentially does
* nothing (this stops any possible deadlock occurring). Otherwise,
* it sends a message to the task with the pertinent info.
*
* If sleeping is disabled then if the semaphore isn't immediately
* available, a signal is sent to the Snoopdos task telling it that
* it's missed trapping a function.
*/
__asm BPTR NewOpen(reg_d1 char *filename, reg_d2 int mode)
{
BPTR filehandle;
geta4();
if (snoopactive && doopen && FindTask(0) != snooptask) {
if (sleepwait)
ObtainSemaphore(sem);
else if (!AttemptSemaphore(sem)) {
Signal(snooptask, missed_open_sig);
return (CallOpen(filename, mode));
}
sendmsg(MSG_OPEN, mode, filename);
filehandle = CallOpen(filename, mode);
sendmsg(MSG_OPEN_DONE, filehandle, 0);
ReleaseSemaphore(sem);
return (filehandle);
} else {
return (CallOpen(filename, mode));
}
}
/*
* NewLock()
* ---------
* Replacement for Lock(), all the comments for NewOpen() apply
* equally here.
*/
__asm BPTR NewLock(reg_d1 char *filename, reg_d2 int mode)
{
BPTR lock;
geta4();
if (snoopactive && dolock && FindTask(0) != snooptask) {
if (sleepwait)
ObtainSemaphore(sem);
else if (!AttemptSemaphore(sem)) {
Signal(snooptask, missed_lock_sig);
return (CallLock(filename, mode));
}
sendmsg(MSG_LOCK, mode, filename);
lock = CallLock(filename, mode);
sendmsg(MSG_LOCK_DONE, lock, 0);
ReleaseSemaphore(sem);
return (lock);
} else {
return (CallLock(filename, mode));
}
}
/*
* NewLoadSeg()
* ------------
* Replacement for Lock(), all the comments for NewOpen() apply
* equally here.
*/
__asm BPTR NewLoadSeg(reg_d1 char *filename)
{
BPTR seglist;
geta4();
if (snoopactive && doloadseg && FindTask(0) != snooptask) {
if (sleepwait)
ObtainSemaphore(sem);
else if (!AttemptSemaphore(sem)) {
Signal(snooptask, missed_loadseg_sig);
return (CallLoadSeg(filename));
}
sendmsg(MSG_LOADSEG, 0, filename);
seglist = CallLoadSeg(filename);
sendmsg(MSG_LOADSEG_DONE, seglist, 0);
ReleaseSemaphore(sem);
return (seglist);
} else {
return (CallLoadSeg(filename));
}
}
/*
* NewExecute()
* ------------
* Replacement for Execute()
*/
__asm LONG NewExecute(reg_d1 char *command, reg_d2 BPTR in, reg_d3 BPTR out)
{
geta4();
if (snoopactive && doexecute && FindTask(0) != snooptask) {
if (sleepwait)
ObtainSemaphore(sem);
else if (!AttemptSemaphore(sem)) {
Signal(snooptask, missed_execute_sig);
return(CallExecute(command, in, out));
}
sendmsg(MSG_EXECUTE, 0, command);
ReleaseSemaphore(sem);
}
return(CallExecute(command, in, out));
}
/*
* NewCurrentDir()
* ---------------
* Replacement for CurrentDir()
*/
__asm BPTR NewCurrentDir(reg_d1 BPTR newlock)
{
geta4();
if (snoopactive && docurdir && FindTask(0) != snooptask) {
if (sleepwait)
ObtainSemaphore(sem);
else if (!AttemptSemaphore(sem)) {
Signal(snooptask, missed_curdir_sig);
return(CallCurrentDir(newlock));
}
sendmsg(MSG_CURDIR, newlock, 0);
ReleaseSemaphore(sem);
}
return(CallCurrentDir(newlock));
}
/*
* NewDeleteFile()
* ---------------
* Replacement for DeleteFile()
*/
__asm LONG NewDeleteFile(reg_d1 char *filename)
{
LONG success;
geta4();
if (snoopactive && dodelete && FindTask(0) != snooptask) {
if (sleepwait)
ObtainSemaphore(sem);
else if (!AttemptSemaphore(sem)) {
Signal(snooptask, missed_delete_sig);
return(CallDeleteFile(filename));
}
sendmsg(MSG_DELETE, 0, filename);
success = CallDeleteFile(filename);
sendmsg(MSG_DELETE_DONE, success, 0);
ReleaseSemaphore(sem);
} else
return(CallDeleteFile(filename));
}