home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Elysian Archive
/
AmigaElysianArchive.iso
/
emulate
/
pcdump.lha
/
pcdump.c
< prev
next >
Wrap
C/C++ Source or Header
|
1989-08-26
|
8KB
|
211 lines
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <exec/types.h>
#include <janus/janus.h>
#include <proto/exec.h>
/********************************************************************/
/* PC (As in Bridgecard) Memory Dumper */
/* Fully Public Domain */
/* August 27th, 1989 */
/* (Written in Lattice C) */
/* */
/* This program is a simple experiment in trying to use the new */
/* Janus 2.x software to read/write the memory in a PC Bridgecard. */
/* The Janus kernel has the ability to do so, but such services are */
/* not provided at the CallService() level, so I have to go lower. */
/* I do not know the level of official support for this method nor */
/* do I know what collisions I may cause in a different environment.*/
/* It works for me. I hope to further expand the functionality and */
/* develop routines until I can do all of the following: */
/* */
/* a) Read/Write PC Memory - This is useful for being able to */
/* determine and alter various obscure PCDOS settings. */
/* */
/* b) Read/Write PC I/O Ports - This could be useful for low- */
/* bandwidth I/O, such as the parallel port. */
/* */
/* c) Invoke A BIOS Interrupt - I want this in order to use a */
/* public-domain serial interface module called FOSSIL. It */
/* provides interrupt-driven serial I/O in a standard fashion.*/
/* By being able to invoke an interrupt, I can stuff data */
/* shared Janus memory and invoke the FOSSIL driver, all in */
/* background of PCDOS. I also want to use it to provide low */
/* level disk I/O (INT13-style) to additional DOS drives so */
/* -someone- can write an Amiga filesystem that runs on 1.44 */
/* floppies plugged into the PC side of things. Properly */
/* done, the two machines should be able to use each other */
/* drives without the user noticing very much. */
/* */
/* All three of these basic services are available in the Janus */
/* kernel now. They require no additional code on the PC side. */
/* */
/* by Jeff Rush (jrush on BIX) */
/* Sysop of Rising Star BBS (214) 231-1372 */
/* */
/* P.S. I have not attempted to space-reduce this or to error-proof */
/* it. Its sole purpose in life is as a conceptual demo. */
/* */
/********************************************************************/
/************************/
/* Constants and Macros */
/************************/
#define TRUE 1
#define FALSE 0
#define BYTE_ALIGNMENT 0
#define WORD_ALIGNMENT 1
/***************************/
/* Structures and Typedefs */
/***************************/
/**************/
/* Prototypes */
/**************/
int GetPCdata(int segment, int offset, char *buffer, int buflen, int alignment);
void hexdump(char *buffer, int buflen);
/********************/
/* Global Variables */
/********************/
struct JanusBase *JanusBase = NULL;
char buffer[256];
unsigned short wbuffer[32];
/********************************************************************/
/* */
/********************************************************************/
void
main(int argc, char *argv[])
{
int i, seg, off;
/********************************/
/* Perform Basic Initialization */
/********************************/
if (argc < 2) {
printf("Usage: PCDUMP seg:off\n");
exit(10);
}
if ((JanusBase = (struct JanusBase *) OpenLibrary(JANUSNAME, 0)) == NULL) {
printf("Unable to Open Janus.Library\n");
exit(10);
}
/*******************/
/* Parse Arguments */
/*******************/
sscanf(argv[1], "%x:%x", &seg, &off);
printf("Dumping PC Memory %04X:%04X\n", seg, off);
/****************************************/
/* Obtain Data from PC Side and Dump It */
/****************************************/
if (GetPCdata(seg, off, buffer, sizeof(buffer), BYTE_ALIGNMENT))
hexdump(buffer, sizeof(buffer));
else
printf("Unable to Obtain Requested Data.\n");
/************************************/
/* Obtain Data and Dump It as Words */
/************************************/
if (GetPCdata(seg, off, (char *)wbuffer, sizeof(wbuffer), WORD_ALIGNMENT)) {
for(i=0; i<sizeof(wbuffer); i++)
printf(" %04X\n", wbuffer[i]);
} else
printf("Unable to Obtain Requested Data.\n");
CloseLibrary((struct Library *)JanusBase);
}
/********************************************************************/
/* */
/********************************************************************/
int
GetPCdata(int segment, int offset, char *buffer, int buflen, int alignment)
{
struct SetupSig *p;
struct MemReadWrite *q;
char *r;
long signal;
int xferamt;
int retcode = FALSE;
xferamt = (buflen > 512) ? 512 : buflen;
if ((signal = AllocSignal(-1)) != -1) { /* Allocate a Signal to Use */
p = SetupJanusSig(JSERV_READPC, (USHORT)signal,
sizeof(struct MemReadWrite), MEMF_PARAMETER | MEM_WORDACCESS);
if (p != NULL) {
q = (struct MemReadWrite *)JanusOffsetToMem(GetParamOffset(JSERV_READPC),
MEMF_PARAMETER | MEM_WORDACCESS);
r = (char *)AllocJanusMem(xferamt, MEMF_BUFFER |
((alignment == BYTE_ALIGNMENT) ? MEM_BYTEACCESS : MEM_WORDACCESS));
if (r != NULL) {
while (buflen) {
q->mrw_Command = MRWC_READ;
q->mrw_Count = (buflen < xferamt) ? buflen : xferamt;
q->mrw_Address = (long)offset << 16 | (long)segment;
q->mrw_Buffer = JanusMemToOffset((APTR)r);
SendJanusInt(JSERV_READPC);
do {
Wait(1L << signal);
} while (CheckJanusInt(JSERV_READPC) != 0x00);
memcpy(buffer, r, xferamt);
buffer += xferamt;
buflen -= xferamt;
offset += xferamt;
}
FreeJanusMem((APTR)r, xferamt);
retcode = TRUE;
}
CleanupJanusSig(p);
}
FreeSignal(signal);
}
return retcode;
}
/**********************************************************************/
/* */
/**********************************************************************/
void
hexdump(char *buffer, int buflen)
{
int i, j;
char text[17];
strcpy(text, " ");
for(i=0; i<buflen; i++) {
if (i % 16 == 0)
printf(" %04X:", i);
printf(" %02X", buffer[i]);
text[i % 16] = isprint(buffer[i]) ? buffer[i] : '.';
if (i % 16 == 15) {
printf(" %s\n", text);
strcpy(text, " ");
}
}
if (i % 16 != 0) {
for(j=0; j < (16 - (i % 16)); j++)
printf(" ");
printf(" %s\n", text);
}
}
/********************************************************************/
/* */
/********************************************************************/