void CloseConsole(void)
{
if(!(CheckIO((struct IORequest *)conreadreq))) {
AbortIO((struct IORequest *)conreadreq);
WaitIO((struct IORequest *)conreadreq);
}
if(!(CheckIO((struct IORequest *)conwritereq))) {
AbortIO((struct IORequest *)conwritereq);
WaitIO((struct IORequest *)conwritereq);
}
CloseDevice((struct IORequest *)conwritereq);
}
/* Waits for a signal or a timeout */
ULONG ata_WaitTO(struct IORequest* tmr, ULONG secs, ULONG micro, ULONG sigs)
{
ULONG sig = 1 << tmr->io_Message.mn_ReplyPort->mp_SigBit;
D(struct Node *t = (struct Node *)FindTask(NULL));
D(bug("[ATA ] Timed wait %lds %ldu (task='%s')\n", secs, micro,
t->ln_Name));
tmr->io_Command = TR_ADDREQUEST;
((struct timerequest*)tmr)->tr_time.tv_secs = secs;
((struct timerequest*)tmr)->tr_time.tv_micro = micro;
SendIO(tmr);
D(bug("[ATA ] Preset signals: %lx ('%s')\n", SetSignal(0, 0), t->ln_Name));
D(bug("[ATA ] Signals requested: %lx ('%s')\n", sigs, t->ln_Name));
D(bug("[ATA ] Timer signal: %lx ('%s')\n", sig, t->ln_Name));
sigs = Wait(sigs | sig);
D(bug("[ATA ] Signals received: %lx ('%s')\n", sigs, t->ln_Name));
if (0 == (sigs & sig))
{
if (!CheckIO(tmr))
AbortIO(tmr);
}
WaitIO(tmr);
SetSignal(0, sig);
return sigs & ~sig;
}
void CloseTimer(struct timerequest *treq) {
if(!(CheckIO((struct IORequest *)timerreq))) {
AbortIO((struct IORequest *)timerreq);
WaitIO((struct IORequest *)timerreq);
}
CloseDevice((struct IORequest *)treq);
}
int lib_exec_f_CheckIO_2(emumsg_syscall_t *msg)
{
/* Make real syscall */
msg->arg[0]._aptr = CheckIO((struct IORequest *)msg->arg[0]._aptr);
return HOOK_DONE;
}
void
ti_Cleanup(Global_T *g)
{
#ifndef DISABLED
SyncTimer *st = &g->g_SyncTimer;
if(st->st_Pkt)
{
if(st->st_Req)
{
if(st->st_Flags & STF_TIMER_USED)
{
if(!CheckIO(&st->st_Req->Request))
AbortIO(&st->st_Req->Request);
WaitIO(&st->st_Req->Request);
}
if(st->st_Flags & STF_DEVICE_OPEN)
CloseDevice(&st->st_Req->Request);
}
}
if(st->st_Pkt)
FreeVec(st->st_Pkt);
if(st->st_Req)
DeleteIORequest(st->st_Req);
memset(st, 0, sizeof(*st));
#endif
}
void static AHI_WaitAudio(_THIS)
{
if(!CheckIO((struct IORequest *)audio_req[current_buffer]))
{
WaitIO((struct IORequest *)audio_req[current_buffer]);
// AbortIO((struct IORequest *)audio_req[current_buffer]);
}
}
long __saveds __regargs nik_sread(char *databuffer,long size,long timeout) {
ULONG signals,sersig=1L << serreadport->mp_SigBit,
timersig=1L << timerport->mp_SigBit;
if(timeout) {
serreadreq->IOSer.io_Command=CMD_READ;
serreadreq->IOSer.io_Length=size;
serreadreq->IOSer.io_Data=(APTR)databuffer;
SendIO((struct IORequest *)serreadreq);
timerreq->tr_node.io_Command=TR_ADDREQUEST;
timerreq->tr_time.tv_secs=timeout/1000000;
timerreq->tr_time.tv_micro=timeout%1000000;
timerreq->tr_node.io_Message.mn_ReplyPort=timerport;
SendIO((struct IORequest *)timerreq);
for(;;) {
signals=Wait(sersig | timersig);
if((signals & sersig) && CheckIO((struct IORequest *)serreadreq)) {
WaitIO((struct IORequest *)serreadreq);
AbortIO((struct IORequest *)timerreq);
WaitIO((struct IORequest *)timerreq);
if(serreadreq->IOSer.io_Error || carrierdropped()) return(-1L);
return((long)serreadreq->IOSer.io_Actual);
}
if((signals & timersig) && CheckIO((struct IORequest *)timerreq)) {
WaitIO((struct IORequest *)timerreq);
AbortIO((struct IORequest *)serreadreq);
WaitIO((struct IORequest *)serreadreq);
/* printf("Timeout! Size=%d Timeout=%d Actual=%d",size,timeout,serreadreq->IOSer.io_Actual); */
return((long)serreadreq->IOSer.io_Actual);
}
}
} else {
serreadreq->IOSer.io_Command=SDCMD_QUERY;
DoIO((struct IORequest *)serreadreq);
serreadreq->IOSer.io_Command=CMD_READ;
if(serreadreq->IOSer.io_Actual > size) serreadreq->IOSer.io_Length=size;
else serreadreq->IOSer.io_Length=serreadreq->IOSer.io_Actual;
serreadreq->IOSer.io_Data=(APTR)databuffer;
DoIO((struct IORequest *)serreadreq);
return((long)serreadreq->IOSer.io_Actual);
}
}
void ami_remove_timer_event(struct nscallback *nscb)
{
if(!nscb) return;
if(nscb->treq)
{
if(CheckIO((struct IORequest *)nscb->treq)==NULL)
AbortIO((struct IORequest *)nscb->treq);
WaitIO((struct IORequest *)nscb->treq);
FreeVec(nscb->treq);
}
}
void closetimer()
{
if (TimerIO)
{
/* Delete any pending timer requests */
if (!(CheckIO((struct IORequest *)TimerIO))) AbortIO((struct IORequest *)TimerIO);
CloseDevice((struct IORequest *) TimerIO);
DeleteExtIO((struct IORequest *) TimerIO);
}
if (TimerMP)
{
DeletePort(TimerMP);
}
}
ULONG sdcard_WaitTO(struct IORequest* tmr, ULONG secs, ULONG micro, ULONG sigs)
{
ULONG sig = 1 << tmr->io_Message.mn_ReplyPort->mp_SigBit;
tmr->io_Command = TR_ADDREQUEST;
((struct timerequest*)tmr)->tr_time.tv_secs = secs;
((struct timerequest*)tmr)->tr_time.tv_micro = micro;
SendIO(tmr);
sigs = Wait(sigs | sig);
if (0 == (sigs & sig))
{
if (!CheckIO(tmr))
AbortIO(tmr);
}
WaitIO(tmr);
SetSignal(0, sig);
return sigs &~ sig;
}
int getfifoevent(struct MsgPort *fifoport, char *puthere)
{
struct IntuiMessage *mymess;
struct NiKMess *nikmess;
ULONG signals,conreadsig=1L << conreadport->mp_SigBit,windsig=1L << NiKwind->UserPort->mp_SigBit,
fifosig=1L << fifoport->mp_SigBit, nikomnodesig = 1L << nikomnodeport->mp_SigBit;
int event=0;
while(!event) {
signals = Wait(conreadsig | windsig | fifosig | nikomnodesig | SIGBREAKF_CTRL_C);
if((signals & conreadsig) && CheckIO((struct IORequest *)conreadreq)) {
*puthere=congettkn();
event|=FIFOEVENT_FROMUSER;
}
if(signals & windsig) {
mymess=(struct IntuiMessage *)GetMsg(NiKwind->UserPort);
ReplyMsg((struct Message *)mymess);
AbortIO((struct IORequest *)conreadreq);
WaitIO((struct IORequest *)conreadreq);
event|=FIFOEVENT_CLOSEW;
}
if(signals & SIGBREAKF_CTRL_C) {
AbortIO((struct IORequest *)conreadreq);
WaitIO((struct IORequest *)conreadreq);
event|=FIFOEVENT_CLOSEW;
}
if(signals & fifosig) {
event|=FIFOEVENT_FROMFIFO;
}
if(signals & nikomnodesig) {
while(nikmess = (struct NiKMess *) GetMsg(nikomnodeport)) {
handleservermess(nikmess);
ReplyMsg((struct Message *)nikmess);
}
if(carrierdropped()) event |= FIFOEVENT_NOCARRIER;
}
}
return(event);
}
/*
*******************************************************************
* Function: CKERROR BGWrapperCB(const CKBehaviorContext& behContext)
*
* Description : The Behavior Callback function is called by Virtools
* when various events happen in the life of a BuildingBlock.
*
* Parameters :
* behaviourContext Behavior context reference, which gives access to
* frequently used global objects ( context, level, manager, etc... )
*
* Returns : CKERROR
*
*******************************************************************
*/
CKERROR GBLCOBGWrapper::BGWrapperCB(const CKBehaviorContext& behContext)
{
CKERROR result = CKBR_GENERICERROR;
// Initialize common pointers.
CKBehavior *behaviour = behContext.Behavior;
CKContext *context = behContext.Context;
CKLevel *level = behContext.CurrentLevel;
CKBeObject *owner = behContext.Behavior->GetOwner();
char*name = behaviour->GetName();
if ( behaviour == NULL || context == NULL || level == NULL /*|| owner == NULL*/ )
return CKBR_OK;
//Get The BG Script Object if exists
CKBehavior* newBG = NULL;
CKBehavior* curBG = (CKBehavior*)behaviour->GetLocalParameterObject(EGBLCOBGWRAPPERPARAM_PARAMETER_SCRIPT);
// Get the BG nms file path. GetStringValue doesn't work with setting...
char fileName[_MAX_PATH+1];
memset(fileName,0,_MAX_PATH+1);
CKParameter* scriptPath = behaviour->GetLocalParameter(EGBLCOBGWRAPPERPARAM_PARAMETER_NAME);
if ( scriptPath == NULL )
return CKBR_OK;
int lenPath = scriptPath->GetDataSize();
if ( lenPath >= _MAX_PATH )
return CKBR_OK;
void*ptrPath = scriptPath->GetReadDataPtr(TRUE);
if ( ptrPath == NULL )
return CKBR_OK;
memcpy(fileName,ptrPath,lenPath);
CKDWORD message = behContext.CallbackMessage;
switch (message)
{
case CKM_BEHAVIORLOAD : // when the behavior is loaded
case CKM_BEHAVIORRESET: // when the behavior is reseted
case CKM_BEHAVIORSETTINGSEDITED : // when the settings are edited
{
if ( curBG != NULL )
{
DestroyCurrentBG(level,behaviour,curBG);
curBG = NULL;
}
newBG = BGLoader( fileName, behContext );
if ( newBG == NULL )
return CKBR_OK;
if ( message == CKM_BEHAVIORLOAD || message == CKM_BEHAVIORRESET )
{
//context->OutputToConsoleExBeep("%s : LOADED %s",behaviour->GetName(), fileName);
if ( CheckIO(behaviour, newBG) == TRUE )
result = CKBR_OK;
else
context->OutputToConsoleExBeep("%s : Too many inputs/outputs changes in %s\r\nPlease reconstruct the wrapper.",behaviour->GetName(), fileName);
}
else if ( message == CKM_BEHAVIORSETTINGSEDITED )
{
if ( CheckIO(behaviour, newBG) == TRUE )
{
result = CKBR_OK;
}
else if (DeleteIO(behaviour) == TRUE)
{
if ( CreateIO(behaviour, newBG ) == TRUE )
result = CKBR_OK;
else
context->OutputToConsoleExBeep("%s : Cannot Create Inputs/Outputs %s",behaviour->GetName(), fileName);
}
else
context->OutputToConsoleExBeep("%s : Cannot Delete Inputs/Outputs %s",behaviour->GetName(), fileName);
}
if ( result == CKBR_OK && newBG != NULL )
SetNewBG(behaviour,newBG);
}
break;
case CKM_BEHAVIORDEACTIVATESCRIPT:
{
if ( curBG != NULL )
DesactivateSubBB(curBG);
result = CKBR_OK;
}
break;
case CKM_BEHAVIORDETACH : // when the behavior is deleted
{
if (curBG != NULL)
{
DestroyCurrentBG(level,behaviour,curBG);
curBG = NULL;
}
result = CKBR_OK;
}
break;
default:
{
result = CKBR_OK;
}
break;
}
if (result != CKBR_OK)
context->OutputToConsoleExBeep("%s : Problem while manipulating",behaviour->GetName());
return result;
}
long HandleServerMsg(void)
{
unsigned long PubScreenModes;
BlankMsg *CurMsg;
while(CurMsg = (BlankMsg *)GetMsg(ServerPort))
{
long Type = CurMsg->bm_Type;
long Flags = CurMsg->bm_Flags;
if(Flags & BF_REPLY)
{
if(!(Flags & BF_INTERNAL))
FreeVec(CurMsg);
}
else
{
CurMsg->bm_Flags |= BF_REPLY;
ReplyMsg((struct Message *)CurMsg);
}
switch(Type)
{
case BM_DOBLANK:
if(Flags & BF_REPLY)
{
if(!CheckIO((struct IORequest *)TimeOutIO))
{
AbortIO((struct IORequest *)TimeOutIO);
WaitIO((struct IORequest *)TimeOutIO);
SetSignal(0L, SIG_TIMER);
}
if(ServerScr)
{
UnblankMousePointer(Wnd);
CloseScreen(ServerScr);
ServerScr = 0L;
}
if(!PingTask)
PingTask = CreateTask("GarshnePing", -5, PingFunc, 4096);
Blanking = TRUE;
}
break;
case BM_DOTESTBLANK:
if(Flags & BF_REPLY)
{
if(!PingTask)
PingTask = CreateTask("GarshnePing", -5, PingFunc, 4096);
Blanking = TRUE;
}
break;
case BM_INITMSG:
if(BlankAfterInit)
{
BlankAfterInit = FALSE;
MessageModule("GarshneClient", BM_DOBLANK);
}
break;
case BM_FAILED:
if(PingTask)
{
Signal(PingTask, SIGBREAKF_CTRL_C);
PingTask = 0L;
}
InternalBlank();
break;
case BM_SENDBLANK:
if((Flags & BF_REPLY)|| BlankingDisabled)
break;
if(ServerScr &&(UsagePercent() > 40))
break;
PubScreenModes = SetPubScreenModes(0L);
if(Stricmp(Prefs->bp_Blanker, "Random"))
{
if(!Blanking || ServerScr)
MessageModule("GarshneClient", BM_DOBLANK);
}
else
{
if(!Blanking || Prefs->bp_Flags & BF_REPLACE)
{
MessageModule("GarshneClient", BM_DELAYEDQUIT);
BlankAfterInit = TRUE;
LoadModule(Prefs->bp_Dir, Prefs->bp_Blanker);
}
else if(ServerScr)
MessageModule("GarshneClient", BM_DOBLANK);
}
SetPubScreenModes(PubScreenModes);
break;
case BM_SENDTEST:
if((Flags & BF_REPLY)|| BlankingDisabled)
break;
PubScreenModes = SetPubScreenModes(0L);
MessageModule("GarshneClient", BM_DOTESTBLANK);
SetPubScreenModes(PubScreenModes);
break;
case BM_SENDUNBLANK:
if(Flags & BF_REPLY)
break;
if(ServerScr)
{
UnblankMousePointer(Wnd);
CloseScreen(ServerScr);
ServerScr = 0L;
}
Blanking = FALSE;
MessageModule("GarshneClient", BM_UNBLANK);
if(PingTask)
{
Signal(PingTask, SIGBREAKF_CTRL_C);
PingTask = 0L;
}
break;
default:
break;
}
}
return OK;
}
static __saveds void net_func(void)
{
const char *str;
BYTE od_error;
struct MsgPort *write_port = NULL, *control_port = NULL;
struct IOSana2Req *write_io = NULL, *control_io = NULL;
bool opened = false;
ULONG read_mask = 0, write_mask = 0, proc_port_mask = 0;
struct Sana2DeviceQuery query_data = {sizeof(Sana2DeviceQuery)};
ULONG buffer_tags[] = {
S2_CopyToBuff, (uint32)copy_to_buff,
S2_CopyFromBuff, (uint32)copy_from_buff,
TAG_END
};
// Default: error occured
proc_error = true;
// Create message port for communication with main task
proc_port = CreateMsgPort();
if (proc_port == NULL)
goto quit;
proc_port_mask = 1 << proc_port->mp_SigBit;
// Create message ports for device I/O
read_port = CreateMsgPort();
if (read_port == NULL)
goto quit;
read_mask = 1 << read_port->mp_SigBit;
write_port = CreateMsgPort();
if (write_port == NULL)
goto quit;
write_mask = 1 << write_port->mp_SigBit;
control_port = CreateMsgPort();
if (control_port == NULL)
goto quit;
// Create control IORequest
control_io = (struct IOSana2Req *)CreateIORequest(control_port, sizeof(struct IOSana2Req));
if (control_io == NULL)
goto quit;
control_io->ios2_Req.io_Message.mn_Node.ln_Type = 0; // Avoid CheckIO() bug
// Parse device name
char dev_name[256];
ULONG dev_unit;
str = PrefsFindString("ether");
if (str) {
const char *FirstSlash = strchr(str, '/');
const char *LastSlash = strrchr(str, '/');
if (FirstSlash && FirstSlash && FirstSlash != LastSlash) {
// Device name contains path, i.e. "Networks/xyzzy.device"
const char *lp = str;
char *dp = dev_name;
while (lp != LastSlash)
*dp++ = *lp++;
*dp = '\0';
if (strlen(dev_name) < 1)
goto quit;
if (sscanf(LastSlash, "/%ld", &dev_unit) != 1)
goto quit;
} else {
if (sscanf(str, "%[^/]/%ld", dev_name, &dev_unit) != 2)
goto quit;
}
} else
goto quit;
// Open device
control_io->ios2_BufferManagement = buffer_tags;
od_error = OpenDevice((UBYTE *) dev_name, dev_unit, (struct IORequest *)control_io, 0);
if (od_error != 0 || control_io->ios2_Req.io_Device == 0) {
printf("WARNING: OpenDevice(<%s>, unit=%d) returned error %d)\n", (UBYTE *)dev_name, dev_unit, od_error);
goto quit;
}
opened = true;
// Is it Ethernet?
control_io->ios2_Req.io_Command = S2_DEVICEQUERY;
control_io->ios2_StatData = (void *)&query_data;
DoIO((struct IORequest *)control_io);
if (control_io->ios2_Req.io_Error)
goto quit;
if (query_data.HardwareType != S2WireType_Ethernet) {
WarningAlert(GetString(STR_NOT_ETHERNET_WARN));
goto quit;
}
// Yes, create IORequest for writing
write_io = (struct IOSana2Req *)CreateIORequest(write_port, sizeof(struct IOSana2Req));
if (write_io == NULL)
goto quit;
memcpy(write_io, control_io, sizeof(struct IOSana2Req));
write_io->ios2_Req.io_Message.mn_Node.ln_Type = 0; // Avoid CheckIO() bug
write_io->ios2_Req.io_Message.mn_ReplyPort = write_port;
// Configure Ethernet
control_io->ios2_Req.io_Command = S2_GETSTATIONADDRESS;
DoIO((struct IORequest *)control_io);
memcpy(ether_addr, control_io->ios2_DstAddr, 6);
memcpy(control_io->ios2_SrcAddr, control_io->ios2_DstAddr, 6);
control_io->ios2_Req.io_Command = S2_CONFIGINTERFACE;
DoIO((struct IORequest *)control_io);
D(bug("Ethernet address %08lx %08lx\n", *(uint32 *)ether_addr, *(uint16 *)(ether_addr + 4)));
// Initialization went well, inform main task
proc_error = false;
Signal(MainTask, SIGF_SINGLE);
// Main loop
for (;;) {
// Wait for I/O and messages (CTRL_C is used for quitting the task)
ULONG sig = Wait(proc_port_mask | read_mask | write_mask | SIGBREAKF_CTRL_C);
// Main task wants to quit us
if (sig & SIGBREAKF_CTRL_C)
break;
// Main task sent a command to us
if (sig & proc_port_mask) {
struct NetMessage *msg;
while (msg = (NetMessage *)GetMsg(proc_port)) {
D(bug("net_proc received %08lx\n", msg->what));
switch (msg->what) {
case MSG_CLEANUP:
remove_all_protocols();
break;
case MSG_ADD_MULTI:
control_io->ios2_Req.io_Command = S2_ADDMULTICASTADDRESS;
Mac2Host_memcpy(control_io->ios2_SrcAddr, msg->pointer + eMultiAddr, 6);
DoIO((struct IORequest *)control_io);
if (control_io->ios2_Req.io_Error == S2ERR_NOT_SUPPORTED) {
WarningAlert(GetString(STR_NO_MULTICAST_WARN));
msg->result = noErr;
} else if (control_io->ios2_Req.io_Error)
msg->result = eMultiErr;
else
msg->result = noErr;
break;
case MSG_DEL_MULTI:
control_io->ios2_Req.io_Command = S2_DELMULTICASTADDRESS;
Mac2Host_memcpy(control_io->ios2_SrcAddr, msg->pointer + eMultiAddr, 6);
DoIO((struct IORequest *)control_io);
if (control_io->ios2_Req.io_Error)
msg->result = eMultiErr;
else
msg->result = noErr;
break;
case MSG_ATTACH_PH: {
uint16 type = msg->type;
uint32 handler = msg->pointer;
// Protocol of that type already installed?
NetProtocol *p = (NetProtocol *)prot_list.lh_Head, *next;
while ((next = (NetProtocol *)p->ln_Succ) != NULL) {
if (p->type == type) {
msg->result = lapProtErr;
goto reply;
}
p = next;
}
// Allocate NetProtocol, set type and handler
p = (NetProtocol *)AllocMem(sizeof(NetProtocol), MEMF_PUBLIC);
if (p == NULL) {
msg->result = lapProtErr;
goto reply;
}
p->type = type;
p->handler = handler;
// Set up and submit read requests
for (int i=0; i<NUM_READ_REQUESTS; i++) {
memcpy(p->read_io + i, control_io, sizeof(struct IOSana2Req));
p->read_io[i].ios2_Req.io_Message.mn_Node.ln_Name = (char *)p; // Hide pointer to NetProtocol in node name
p->read_io[i].ios2_Req.io_Message.mn_Node.ln_Type = 0; // Avoid CheckIO() bug
p->read_io[i].ios2_Req.io_Message.mn_ReplyPort = read_port;
p->read_io[i].ios2_Req.io_Command = CMD_READ;
p->read_io[i].ios2_PacketType = type;
p->read_io[i].ios2_Data = p->read_buf[i];
p->read_io[i].ios2_Req.io_Flags = SANA2IOF_RAW;
BeginIO((struct IORequest *)(p->read_io + i));
}
// Add protocol to list
AddTail(&prot_list, p);
// Everything OK
msg->result = noErr;
break;
}
case MSG_DETACH_PH: {
uint16 type = msg->type;
msg->result = lapProtErr;
NetProtocol *p = (NetProtocol *)prot_list.lh_Head, *next;
while ((next = (NetProtocol *)p->ln_Succ) != NULL) {
if (p->type == type) {
remove_protocol(p);
msg->result = noErr;
break;
}
p = next;
}
break;
}
case MSG_WRITE: {
// Get pointer to Write Data Structure
uint32 wds = msg->pointer;
write_io->ios2_Data = (void *)wds;
// Calculate total packet length
long len = 0;
uint32 tmp = wds;
for (;;) {
int16 w = ReadMacInt16(tmp);
if (w == 0)
break;
len += w;
tmp += 6;
}
write_io->ios2_DataLength = len;
// Get destination address
uint32 hdr = ReadMacInt32(wds + 2);
Mac2Host_memcpy(write_io->ios2_DstAddr, hdr, 6);
// Get packet type
uint32 type = ReadMacInt16(hdr + 12);
if (type <= 1500)
type = 0; // 802.3 packet
write_io->ios2_PacketType = type;
// Multicast/broadcard packet?
if (write_io->ios2_DstAddr[0] & 1) {
if (*(uint32 *)(write_io->ios2_DstAddr) == 0xffffffff && *(uint16 *)(write_io->ios2_DstAddr + 4) == 0xffff)
write_io->ios2_Req.io_Command = S2_BROADCAST;
else
write_io->ios2_Req.io_Command = S2_MULTICAST;
} else
write_io->ios2_Req.io_Command = CMD_WRITE;
// Send packet
write_done = false;
write_io->ios2_Req.io_Flags = SANA2IOF_RAW;
BeginIO((IORequest *)write_io);
break;
}
}
reply: D(bug(" net_proc replying\n"));
ReplyMsg(msg);
}
}
// Packet received
if (sig & read_mask) {
D(bug(" packet received, triggering Ethernet interrupt\n"));
SetInterruptFlag(INTFLAG_ETHER);
TriggerInterrupt();
}
// Packet write completed
if (sig & write_mask) {
GetMsg(write_port);
WriteMacInt32(ether_data + ed_Result, write_io->ios2_Req.io_Error ? excessCollsns : 0);
write_done = true;
D(bug(" packet write done, triggering Ethernet interrupt\n"));
SetInterruptFlag(INTFLAG_ETHER);
TriggerInterrupt();
}
}
quit:
// Close everything
remove_all_protocols();
if (opened) {
if (CheckIO((struct IORequest *)write_io) == 0) {
AbortIO((struct IORequest *)write_io);
WaitIO((struct IORequest *)write_io);
}
CloseDevice((struct IORequest *)control_io);
}
if (write_io)
DeleteIORequest(write_io);
if (control_io)
DeleteIORequest(control_io);
if (control_port)
DeleteMsgPort(control_port);
if (write_port)
DeleteMsgPort(write_port);
if (read_port)
DeleteMsgPort(read_port);
// Send signal to main task to confirm termination
Forbid();
Signal(MainTask, SIGF_SINGLE);
}
int sendbinfile(void) {
struct TransferFiles *tf;
int xprreturkod,cnt=0;
if(!(XProtocolBase=(struct Library *)OpenLibrary("xprzmodem.library",0L)))
{
puttekn("\r\n\nKunde inte öppna xprzmodem.library!\r\n",-1);
return(2);
}
if(!(xio=(struct XPR_IO *)AllocMem(sizeof(struct XPR_IO),MEMF_PUBLIC | MEMF_CLEAR))) {
puttekn("\r\n\nKunde inte allokera en io-struktur\r\n",-1);
CloseLibrary(XProtocolBase);
return(2);
}
puttekn("\r\nDu kan börja ta emot med Zmodem.\r\n",-1);
puttekn("Tryck Ctrl-X några gånger för att avbryta.\r\n",-1);
AbortIO((struct IORequest *)serreadreq);
WaitIO((struct IORequest *)serreadreq);
if(!CheckIO((struct IORequest *)inactivereq)) {
AbortIO((struct IORequest *)inactivereq);
WaitIO((struct IORequest *)inactivereq);
}
xpr_setup(xio);
xio->xpr_filename=zinitstring;
XProtocolSetup(xio);
xio->xpr_filename="Hejhopp";
xprreturkod=XProtocolSend(xio);
Delay(30);
XProtocolCleanup(xio);
CloseLibrary(XProtocolBase);
if(!CheckIO((struct IORequest *)serreadreq)) {
AbortIO((struct IORequest *)serreadreq);
WaitIO((struct IORequest *)serreadreq);
printf("Serreadreq avbruten!!\n");
}
if(!CheckIO((struct IORequest *)timerreq)) {
AbortIO((struct IORequest *)timerreq);
WaitIO((struct IORequest *)timerreq);
printf("Timerreq avbruten!!\n");
}
FreeMem(xio,sizeof(struct XPR_IO));
Delay(100);
serchangereq->IOSer.io_Command=CMD_CLEAR;
DoIO((struct IORequest *)serchangereq);
serchangereq->IOSer.io_Command=CMD_FLUSH;
DoIO((struct IORequest *)serchangereq);
serreqtkn();
updateinactive();
if(Servermem->cfg.logmask & LOG_SENDFILE) {
for(tf=(struct TransferFiles *)tf_list.mlh_Head; tf->node.mln_Succ; tf=(struct TransferFiles *)tf->node.mln_Succ)
if(tf->sucess) {
LogEvent(USAGE_LOG, INFO, "Skickar filen %s till %s",
tf->path, getusername(inloggad));
}
}
for(tf=(struct TransferFiles *)tf_list.mlh_Head; tf->node.mln_Succ; tf=(struct TransferFiles *)tf->node.mln_Succ)
if(tf->sucess) cnt++;
if(cnt==1) strcpy(outbuffer,"\n\n\rFörde över 1 fil.\n\n\r");
else sprintf(outbuffer,"\n\n\rFörde över %d filer.\n\n\r",cnt);
puttekn(outbuffer,-1);
return(0);
}
int recbinfile(char *dir) {
int xprreturkod;
char zmodeminit[100];
ulfiles = 0;
if(access(dir,0)) {
puttekn("\r\nDirectoryt finns inte!\r\n",-1);
return 2;
}
if(Servermem->cfg.diskfree != 0
&& !HasPartitionEnoughFreeSpace(dir, Servermem->cfg.diskfree)) {
puttekn("\r\nTyvärr, gränsen för hur full disken får bli har överskridits!\r\n",-1);
return 2;
}
if(Servermem->cfg.ar.preup2) {
sendautorexx(Servermem->cfg.ar.preup2);
}
sprintf(zmodeminit,"%s%s",zinitstring,dir);
if(!(XProtocolBase = (struct Library *) OpenLibrary("xprzmodem.library", 0L))) {
puttekn("\r\n\nKunde inte öppna xprzmodem.library!\r\n",-1);
return 2;
}
if(!(xio = (struct XPR_IO *)
AllocMem(sizeof(struct XPR_IO), MEMF_PUBLIC | MEMF_CLEAR))) {
puttekn("\r\n\nKunde inte allokera en io-struktur\r\n",-1);
CloseLibrary(XProtocolBase);
return 2;
}
NewList((struct List *)&tf_list);
puttekn("\r\nDu kan börja sända med Zmodem. Du kan nu skicka fler filer!",-1);
puttekn("\r\nTryck Ctrl-X några gånger för att avbryta.\r\n",-1);
AbortIO((struct IORequest *)serreadreq);
WaitIO((struct IORequest *)serreadreq);
if(!CheckIO((struct IORequest *)inactivereq)) {
AbortIO((struct IORequest *)inactivereq);
WaitIO((struct IORequest *)inactivereq);
}
xpr_setup(xio);
xio->xpr_filename = zmodeminit;
XProtocolSetup(xio);
xprreturkod = XProtocolReceive(xio);
Delay(30);
XProtocolCleanup(xio);
CloseLibrary(XProtocolBase);
if(!CheckIO((struct IORequest *)serreadreq)) {
AbortIO((struct IORequest *)serreadreq);
WaitIO((struct IORequest *)serreadreq);
printf("Serreadreq avbruten!!\n");
}
if(!CheckIO((struct IORequest *)timerreq)) {
AbortIO((struct IORequest *)timerreq);
WaitIO((struct IORequest *)timerreq);
printf("Timerreq avbruten!!\n");
}
FreeMem(xio,sizeof(struct XPR_IO));
Delay(100);
serchangereq->IOSer.io_Command=CMD_CLEAR;
DoIO((struct IORequest *)serchangereq);
serchangereq->IOSer.io_Command=CMD_FLUSH;
DoIO((struct IORequest *)serchangereq);
serreqtkn();
updateinactive();
if(Servermem->cfg.ar.postup2) {
sendautorexx(Servermem->cfg.ar.postup2);
}
if(ulfiles > 0) {
puttekn("\r\n\nÖverföringen lyckades.\r\n",-1);
return 0;
}
else {
puttekn("\r\n\nÖverföringen misslyckades.\r\n",-1);
return 2;
}
}
int SerialPort::ReadPort()
{
return CheckIO(portfd, 0, 0, buf, &bytesRead);
}
int recbinfile(char *dir) {
int xprreturkod,bytesfree;
char zmodeminit[100];
struct InfoData *id;
BPTR lock;
ulfiles = 0;
if(access(dir,0)) {
puttekn("\r\nDirectoryt finns inte!\r\n",-1);
return(2);
}
if(!(id=AllocMem(sizeof(struct InfoData),MEMF_CLEAR))) {
puttekn("\r\nKunde inte allokera en InfoData-struktur!\r\n",-1);
return(2);
}
if(!(lock=Lock(dir,ACCESS_READ))) {
puttekn("\r\nKunde inte få ett Lock för directoryt!\r\n",-1);
FreeMem(id,sizeof(struct InfoData));
return(2);
}
if(!Info(lock,id)) {
puttekn("\r\nKunde inte få info om devicet!\r\n",-1);
UnLock(lock);
FreeMem(id,sizeof(struct InfoData));
return(2);
}
bytesfree=(id->id_NumBlocks - id->id_NumBlocksUsed)*id->id_BytesPerBlock;
UnLock(lock);
FreeMem(id,sizeof(struct InfoData));
if(bytesfree < Servermem->cfg.diskfree) {
puttekn("\r\nTyvärr, gränsen för hur full disken får bli har överskridits!\r\n",-1);
return(2);
}
if(Servermem->cfg.ar.preup2) sendrexx(Servermem->cfg.ar.preup2);
sprintf(zmodeminit,"%s%s",zinitstring,dir);
if(!(XProtocolBase=(struct Library *)OpenLibrary("xprzmodem.library",0L))) {
puttekn("\r\n\nKunde inte öppna xprzmodem.library!\r\n",-1);
return(2);
}
if(!(xio=(struct XPR_IO *)AllocMem(sizeof(struct XPR_IO),MEMF_PUBLIC | MEMF_CLEAR))) {
puttekn("\r\n\nKunde inte allokera en io-struktur\r\n",-1);
CloseLibrary(XProtocolBase);
return(2);
}
NewList((struct List *)&tf_list);
puttekn("\r\nDu kan börja sända med Zmodem. Du kan nu skicka fler filer!",-1);
puttekn("\r\nTryck Ctrl-X några gånger för att avbryta.\r\n",-1);
AbortIO((struct IORequest *)serreadreq);
WaitIO((struct IORequest *)serreadreq);
if(!CheckIO((struct IORequest *)inactivereq)) {
AbortIO((struct IORequest *)inactivereq);
WaitIO((struct IORequest *)inactivereq);
}
xpr_setup(xio);
xio->xpr_filename=zmodeminit;
XProtocolSetup(xio);
xprreturkod=XProtocolReceive(xio);
Delay(30);
XProtocolCleanup(xio);
CloseLibrary(XProtocolBase);
if(!CheckIO((struct IORequest *)serreadreq)) {
AbortIO((struct IORequest *)serreadreq);
WaitIO((struct IORequest *)serreadreq);
printf("Serreadreq avbruten!!\n");
}
if(!CheckIO((struct IORequest *)timerreq)) {
AbortIO((struct IORequest *)timerreq);
WaitIO((struct IORequest *)timerreq);
printf("Timerreq avbruten!!\n");
}
FreeMem(xio,sizeof(struct XPR_IO));
Delay(100);
serchangereq->IOSer.io_Command=CMD_CLEAR;
DoIO((struct IORequest *)serchangereq);
serchangereq->IOSer.io_Command=CMD_FLUSH;
DoIO((struct IORequest *)serchangereq);
serreqtkn();
updateinactive();
if(Servermem->cfg.ar.postup2) sendrexx(Servermem->cfg.ar.postup2);
/* if(Servermem->cfg.logmask & LOG_RECFILE) {
sprintf(outbuffer,"Tar emot filen %s från %s",xprfilnamn,getusername(inloggad));
logevent(outbuffer);
}
if(xprreturkod) {
puttekn("\r\n\nÖverföringen lyckades.\r\n",-1);
sprintf(outbuffer,"Hastighet: %d cps\n\r",cps);
puttekn(outbuffer,-1);
return(0);
} else {
puttekn("\r\n\nÖverföringen misslyckades.\r\n",-1);
return(2);
} Removed by Tomas Kärki 22/1 1996 */
if(ulfiles > 0) {
puttekn("\r\n\nÖverföringen lyckades.\r\n",-1);
return(0);
}
else {
puttekn("\r\n\nÖverföringen misslyckades.\r\n",-1);
return(2);
}
}
void checkinterrupt(void)
{
CheckIO();
interruptcount = interruptfreq;
if(interrupted) systemerror(1);
}
__saveds void ASERDPort::serial_func(void)
{
struct ASERDPort *obj = (ASERDPort *)proc_arg;
struct MsgPort *proc_port = NULL, *io_port = NULL, *control_port = NULL;
struct IOExtSer *read_io = NULL, *write_io = NULL, *control_io = NULL;
uint8 orig_params[sizeof(struct IOExtSer)];
bool opened = false;
ULONG io_mask = 0, proc_port_mask = 0;
// Default: error occured
obj->proc_error = true;
// Create message port for communication with main task
proc_port = CreateMsgPort();
if (proc_port == NULL)
goto quit;
proc_port_mask = 1 << proc_port->mp_SigBit;
// Create message ports for serial.device I/O
io_port = CreateMsgPort();
if (io_port == NULL)
goto quit;
io_mask = 1 << io_port->mp_SigBit;
control_port = CreateMsgPort();
if (control_port == NULL)
goto quit;
// Create IORequests
read_io = (struct IOExtSer *)CreateIORequest(io_port, sizeof(struct IOExtSer));
write_io = (struct IOExtSer *)CreateIORequest(io_port, sizeof(struct IOExtSer));
control_io = (struct IOExtSer *)CreateIORequest(control_port, sizeof(struct IOExtSer));
if (read_io == NULL || write_io == NULL || control_io == NULL)
goto quit;
read_io->IOSer.io_Message.mn_Node.ln_Type = 0; // Avoid CheckIO() bug
write_io->IOSer.io_Message.mn_Node.ln_Type = 0;
control_io->IOSer.io_Message.mn_Node.ln_Type = 0;
// Parse device name
char dev_name[256];
ULONG dev_unit;
if (sscanf(obj->device_name, "%[^/]/%ld", dev_name, &dev_unit) < 2)
goto quit;
// Open device
if (obj->is_parallel)
((IOExtPar *)read_io)->io_ParFlags = PARF_SHARED;
else
read_io->io_SerFlags = SERF_SHARED | SERF_7WIRE;
if (OpenDevice((UBYTE *) dev_name, dev_unit, (struct IORequest *)read_io, 0) || read_io->IOSer.io_Device == NULL)
goto quit;
opened = true;
// Copy IORequests
memcpy(write_io, read_io, sizeof(struct IOExtSer));
memcpy(control_io, read_io, sizeof(struct IOExtSer));
// Attach control_io to control_port and set default values
control_io->IOSer.io_Message.mn_ReplyPort = control_port;
if (!obj->is_parallel) {
control_io->io_CtlChar = SER_DEFAULT_CTLCHAR;
control_io->io_RBufLen = 64;
control_io->io_ExtFlags = 0;
control_io->io_Baud = 9600;
control_io->io_BrkTime = 250000;
control_io->io_ReadLen = control_io->io_WriteLen = 8;
control_io->io_StopBits = 1;
control_io->io_SerFlags = SERF_SHARED;
control_io->IOSer.io_Command = SDCMD_SETPARAMS;
DoIO((struct IORequest *)control_io);
memcpy(orig_params, &(control_io->io_CtlChar), (uint8 *)&(control_io->io_Status) - (uint8 *)&(control_io->io_CtlChar));
}
// Initialization went well, inform main task
obj->proc_port = proc_port;
obj->control_io = control_io;
obj->proc_error = false;
Signal(MainTask, SIGF_SINGLE);
// Main loop
for (;;) {
// Wait for I/O and messages (CTRL_C is used for quitting the task)
ULONG sig = Wait(proc_port_mask | io_mask | SIGBREAKF_CTRL_C);
// Main task wants to quit us
if (sig & SIGBREAKF_CTRL_C)
break;
// Main task sent a command to us
if (sig & proc_port_mask) {
struct SerMessage *msg;
while (msg = (SerMessage *)GetMsg(proc_port)) {
D(bug("serial_proc received %08lx\n", msg->what));
switch (msg->what) {
case MSG_QUERY:
control_io->IOSer.io_Command = SDCMD_QUERY;
DoIO((struct IORequest *)control_io);
D(bug(" query returned %08lx, actual %08lx\n", control_io->IOSer.io_Error, control_io->IOSer.io_Actual));
break;
case MSG_SET_PARAMS:
// Only send SDCMD_SETPARAMS when configuration has changed
if (memcmp(orig_params, &(control_io->io_CtlChar), (uint8 *)&(control_io->io_Status) - (uint8 *)&(control_io->io_CtlChar))) {
memcpy(orig_params, &(control_io->io_CtlChar), (uint8 *)&(control_io->io_Status) - (uint8 *)&(control_io->io_CtlChar));
memcpy(&(read_io->io_CtlChar), &(control_io->io_CtlChar), (uint8 *)&(control_io->io_Status) - (uint8 *)&(control_io->io_CtlChar));
memcpy(&(write_io->io_CtlChar), &(control_io->io_CtlChar), (uint8 *)&(control_io->io_Status) - (uint8 *)&(control_io->io_CtlChar));
control_io->IOSer.io_Command = SDCMD_SETPARAMS;
D(bug(" params %08lx %08lx %08lx %08lx %08lx %08lx\n", control_io->io_CtlChar, control_io->io_RBufLen, control_io->io_ExtFlags, control_io->io_Baud, control_io->io_BrkTime, *(uint32 *)((uint8 *)control_io + 76)));
DoIO((struct IORequest *)control_io);
D(bug(" set_parms returned %08lx\n", control_io->IOSer.io_Error));
}
break;
case MSG_SET_PAR_PARAMS:
control_io->IOSer.io_Command = PDCMD_SETPARAMS;
DoIO((struct IORequest *)control_io);
D(bug(" set_par_parms returned %08lx\n", control_io->IOSer.io_Error));
break;
case MSG_BREAK:
control_io->IOSer.io_Command = SDCMD_BREAK;
DoIO((struct IORequest *)control_io);
D(bug(" break returned %08lx\n", control_io->IOSer.io_Error));
break;
case MSG_RESET:
control_io->IOSer.io_Command = CMD_RESET;
DoIO((struct IORequest *)control_io);
D(bug(" reset returned %08lx\n", control_io->IOSer.io_Error));
break;
case MSG_KILL_IO:
AbortIO((struct IORequest *)read_io);
AbortIO((struct IORequest *)write_io);
WaitIO((struct IORequest *)read_io);
WaitIO((struct IORequest *)write_io);
obj->read_pending = obj->write_pending = false;
obj->read_done = obj->write_done = false;
break;
case MSG_PRIME_IN:
read_io->IOSer.io_Message.mn_Node.ln_Name = (char *)msg->pb;
read_io->IOSer.io_Data = Mac2HostAddr(ReadMacInt32(msg->pb + ioBuffer));
read_io->IOSer.io_Length = ReadMacInt32(msg->pb + ioReqCount);
read_io->IOSer.io_Actual = 0;
read_io->IOSer.io_Command = CMD_READ;
D(bug("serial_proc receiving %ld bytes from %08lx\n", read_io->IOSer.io_Length, read_io->IOSer.io_Data));
SendIO((struct IORequest *)read_io);
break;
case MSG_PRIME_OUT: {
write_io->IOSer.io_Message.mn_Node.ln_Name = (char *)msg->pb;
write_io->IOSer.io_Data = Mac2HostAddr(ReadMacInt32(msg->pb + ioBuffer));
write_io->IOSer.io_Length = ReadMacInt32(msg->pb + ioReqCount);
write_io->IOSer.io_Actual = 0;
write_io->IOSer.io_Command = CMD_WRITE;
D(bug("serial_proc transmitting %ld bytes from %08lx\n", write_io->IOSer.io_Length, write_io->IOSer.io_Data));
#if MONITOR
bug("Sending serial data:\n");
uint8 *adr = Mac2HostAddr(ReadMacInt32(msg->pb + ioBuffer));
for (int i=0; i<len; i++) {
bug("%02lx ", adr[i]);
}
bug("\n");
#endif
SendIO((struct IORequest *)write_io);
break;
}
}
D(bug(" serial_proc replying\n"));
ReplyMsg(msg);
}
}
// I/O operation completed
if (sig & io_mask) {
struct IOExtSer *io;
while (io = (struct IOExtSer *)GetMsg(io_port)) {
if (io == read_io) {
D(bug("read_io complete, %ld bytes received, error %ld\n", read_io->IOSer.io_Actual, read_io->IOSer.io_Error));
uint32 pb = (uint32)read_io->IOSer.io_Message.mn_Node.ln_Name;
#if MONITOR
bug("Receiving serial data:\n");
uint8 *adr = Mac2HostAddr(ReadMacInt32(msg->pb + ioBuffer));
for (int i=0; i<read_io->IOSer.io_Actual; i++) {
bug("%02lx ", adr[i]);
}
bug("\n");
#endif
WriteMacInt32(pb + ioActCount, read_io->IOSer.io_Actual);
obj->conv_error(read_io, obj->input_dt);
obj->read_done = true;
SetInterruptFlag(INTFLAG_SERIAL);
TriggerInterrupt();
} else if (io == write_io) {
D(bug("write_io complete, %ld bytes sent, error %ld\n", write_io->IOSer.io_Actual, write_io->IOSer.io_Error));
uint32 pb = (uint32)write_io->IOSer.io_Message.mn_Node.ln_Name;
WriteMacInt32(pb + ioActCount, write_io->IOSer.io_Actual);
obj->conv_error(write_io, obj->output_dt);
obj->write_done = true;
SetInterruptFlag(INTFLAG_SERIAL);
TriggerInterrupt();
}
}
}
}
quit:
// Close everything
if (opened) {
if (CheckIO((struct IORequest *)write_io) == 0) {
AbortIO((struct IORequest *)write_io);
WaitIO((struct IORequest *)write_io);
}
if (CheckIO((struct IORequest *)read_io) == 0) {
AbortIO((struct IORequest *)read_io);
WaitIO((struct IORequest *)read_io);
}
CloseDevice((struct IORequest *)read_io);
}
if (control_io)
DeleteIORequest(control_io);
if (write_io)
DeleteIORequest(write_io);
if (read_io)
DeleteIORequest(read_io);
if (control_port)
DeleteMsgPort(control_port);
if (io_port)
DeleteMsgPort(io_port);
// Send signal to main task to confirm termination
Forbid();
Signal(MainTask, SIGF_SINGLE);
}
int main(int argc, const char ** argv)
{
struct IntuiMessage *winmsg;
ULONG signals, conreadsig, windowsig;
LONG lch;
WORD InControl = 0;
BOOL Done = FALSE;
UBYTE ch, ibuf;
UBYTE obuf[200];
BYTE error;
FromWb = (argc==0L) ? TRUE : FALSE;
if(!(IntuitionBase=OpenLibrary("intuition.library",0)))
cleanexit("Can't open intuition\n",RETURN_FAIL);
/* Create reply port and io block for writing to console */
if(!(writePort = CreatePort("RKM.console.write",0)))
cleanexit("Can't create write port\n",RETURN_FAIL);
if(!(writeReq = (struct IOStdReq *)
CreateExtIO(writePort,(LONG)sizeof(struct IOStdReq))))
cleanexit("Can't create write request\n",RETURN_FAIL);
/* Create reply port and io block for reading from console */
if(!(readPort = CreatePort("RKM.console.read",0)))
cleanexit("Can't create read port\n",RETURN_FAIL);
if(!(readReq = (struct IOStdReq *)
CreateExtIO(readPort,(LONG)sizeof(struct IOStdReq))))
cleanexit("Can't create read request\n",RETURN_FAIL);
/* Open a window */
if(!(win = OpenWindow(&nw)))
cleanexit("Can't open window\n",RETURN_FAIL);
/* Now, attach a console to the window */
if(error = OpenConsole(writeReq,readReq,win))
cleanexit("Can't open console.device\n",RETURN_FAIL);
else OpenedConsole = TRUE;
/* Demonstrate some console escape sequences */
ConPuts(writeReq,"Here's some normal text\n");
sprintf(obuf,"%s%sHere's text in color 3 & italics\n",COLOR03,ITALICS);
ConPuts(writeReq,obuf);
ConPuts(writeReq,NORMAL);
Delay(50); /* Delay for dramatic demo effect */
ConPuts(writeReq,"We will now delete this asterisk =*=");
Delay(50);
ConPuts(writeReq,"\b\b"); /* backspace twice */
Delay(50);
ConPuts(writeReq,DELCHAR); /* delete the character */
Delay(50);
QueueRead(readReq,&ibuf); /* send the first console read request */
ConPuts(writeReq,"\n\nNow reading console\n");
ConPuts(writeReq,"Type some keys. Close window when done.\n\n");
conreadsig = 1 << readPort->mp_SigBit;
windowsig = 1 << win->UserPort->mp_SigBit;
while(!Done)
{
/* A character, or an IDCMP msg, or both could wake us up */
signals = Wait(conreadsig|windowsig);
/* If a console signal was received, get the character */
if (signals & conreadsig)
{
if((lch = ConMayGetChar(readPort,&ibuf)) != -1)
{
ch = lch;
/* Show hex and ascii (if printable) for char we got.
* If you want to parse received control sequences, such as
* function or Help keys,you would buffer control sequences
* as you receive them, starting to buffer whenever you
* receive 0x9B (or 0x1B[ for user-typed sequences) and
* ending when you receive a valid terminating character
* for the type of control sequence you are receiving.
* For CSI sequences, valid terminating characters
* are generally 0x40 through 0x7E.
* In our example, InControl has the following values:
* 0 = no, 1 = have 0x1B, 2 = have 0x9B OR 0x1B and [,
* 3 = now inside control sequence, -1 = normal end esc,
* -2 = non-CSI(no [) 0x1B end esc
* NOTE - a more complex parser is required to recognize
* other types of control sequences.
*/
/* 0x1B ESC not followed by '[', is not CSI seq */
if (InControl==1)
{
if(ch=='[') InControl = 2;
else InControl = -2;
}
if ((ch==0x9B)||(ch==0x1B)) /* Control seq starting */
{
InControl = (ch==0x1B) ? 1 : 2;
ConPuts(writeReq,"=== Control Seq ===\n");
}
/* We'll show value of this char we received */
if (((ch >= 0x1F)&&(ch <= 0x7E))||(ch >= 0xA0))
sprintf(obuf,"Received: hex %02x = %c\n",ch,ch);
else sprintf(obuf,"Received: hex %02x\n",ch);
ConPuts(writeReq,obuf);
/* Valid ESC sequence terminator ends an ESC seq */
if ((InControl==3)&&((ch >= 0x40) && (ch <= 0x7E)))
{
InControl = -1;
}
if (InControl==2) InControl = 3;
/* ESC sequence finished (-1 if OK, -2 if bogus) */
if (InControl < 0)
{
InControl = 0;
ConPuts(writeReq,"=== End Control ===\n");
}
}
}
/* If IDCMP messages received, handle them */
if (signals & windowsig)
{
/* We have to ReplyMsg these when done with them */
while (winmsg = (struct IntuiMessage *)GetMsg(win->UserPort))
{
switch(winmsg->Class)
{
case IDCMP_CLOSEWINDOW:
Done = TRUE;
break;
default:
break;
}
ReplyMsg((struct Message *)winmsg);
}
}
}
/* We always have an outstanding queued read request
* so we must abort it if it hasn't completed,
* and we must remove it.
*/
if(!(CheckIO(readReq))) AbortIO(readReq);
WaitIO(readReq); /* clear it from our replyport */
cleanup();
exit(RETURN_OK);
}
