153 lines
3.2 KiB
C
153 lines
3.2 KiB
C
/* channel.c - basic channel handling routines */
|
||
#include <errno.h>
|
||
#include <signal.h>
|
||
#include <sgtty.h>
|
||
#include "ocm_chan.h"
|
||
|
||
static void disaster();
|
||
|
||
void c_init(c, z) register chan *c; register unsigned z;
|
||
/* Initialise an array of interprocess channels declared as: CHAN c[z]. */
|
||
{
|
||
do {
|
||
c->type=C_T_CHAN;
|
||
(c++)->c.synch=C_S_FREE;
|
||
} while (--z!=0);
|
||
}
|
||
|
||
void chan_in(v, c) long *v; register chan *c;
|
||
/* Reads a value from channel c and returns it through v. */
|
||
{
|
||
switch(c->type) {
|
||
case C_T_FILE:
|
||
if ((c->f.flgs&C_F_READAHEAD)!=0) {
|
||
*v=(c->f.preread&0377);
|
||
c->f.flgs&= ~C_F_READAHEAD;
|
||
} else {
|
||
register FILE *fp= unix_file[c->f.index];
|
||
|
||
*v= feof(fp) ? C_F_EOF : getc(fp);
|
||
}
|
||
break;
|
||
case C_T_CHAN:
|
||
deadlock=0; /* Wait for value to arrive */
|
||
while (c->c.synch!=C_S_ANY) resumenext();
|
||
|
||
*v=c->c.val;
|
||
c->c.synch=C_S_ACK; /* Acknowledge receipt */
|
||
break;
|
||
default:
|
||
disaster();
|
||
}
|
||
}
|
||
|
||
void chan_out(v, c) long v; register chan *c;
|
||
/* Send value v through channel c. */
|
||
{
|
||
switch(c->type) {
|
||
case C_T_FILE: {
|
||
register FILE *fp= unix_file[c->f.index];
|
||
struct sgttyb tty;
|
||
|
||
if ((v& ~0xff)==0) /* Plain character */
|
||
putc( (int) v, fp);
|
||
else
|
||
if (v==C_F_TEXT) {
|
||
gtty(fileno(fp), &tty);
|
||
tty.sg_flags&= ~CBREAK;
|
||
tty.sg_flags|= ECHO|CRMOD;
|
||
stty(fileno(fp), &tty);
|
||
} else
|
||
if (v==C_F_RAW) {
|
||
gtty(fileno(fp), &tty);
|
||
tty.sg_flags|= CBREAK;
|
||
tty.sg_flags&= ~(ECHO|CRMOD);
|
||
stty(fileno(fp), &tty);
|
||
}
|
||
} break;
|
||
case C_T_CHAN:
|
||
deadlock=0; /* Wait until channel is free */
|
||
while (c->c.synch!=C_S_FREE) resumenext();
|
||
|
||
c->c.val=v;
|
||
c->c.synch=C_S_ANY; /* Channel has data */
|
||
|
||
deadlock=0; /* Wait for acknowledgement */
|
||
while (c->c.synch!=C_S_ACK) resumenext();
|
||
|
||
c->c.synch=C_S_FREE; /* Back to normal */
|
||
break;
|
||
default:
|
||
disaster();
|
||
}
|
||
}
|
||
|
||
static int timeout();
|
||
|
||
int chan_any(c) register chan *c;
|
||
{
|
||
switch (c->type) {
|
||
case C_T_FILE:
|
||
if ((c->f.flgs&C_F_READAHEAD)!=0)
|
||
return 1;
|
||
else {
|
||
register FILE *fp= unix_file[c->f.index];
|
||
|
||
if (feof(fp))
|
||
return 1;
|
||
else {
|
||
extern int errno;
|
||
register ch;
|
||
|
||
deadlock=0;
|
||
/* No deadlock while waiting for key */
|
||
|
||
signal(SIGALRM, timeout);
|
||
alarm(1);
|
||
|
||
errno=0;
|
||
ch=getc(fp);
|
||
|
||
signal(SIGALRM, SIG_IGN);
|
||
alarm(0);
|
||
|
||
if (errno==EINTR)
|
||
return 0;
|
||
else {
|
||
if (!feof(fp)) {
|
||
c->f.flgs|=C_F_READAHEAD;
|
||
c->f.preread=ch;
|
||
}
|
||
return 1;
|
||
}
|
||
}
|
||
}
|
||
case C_T_CHAN:
|
||
return c->c.synch==C_S_ANY;
|
||
default:
|
||
disaster();
|
||
}
|
||
}
|
||
|
||
/* The ch=getc(fp) in the above function calls read(2) to do its task, but if
|
||
* there's no input on the file (pipe or terminal) then the read will block.
|
||
* To stop this read from blocking, we use the fact that if the read is
|
||
* interrupted by a signal that is caught by the program, then the read returns
|
||
* error EINTR after the signal is processed. Thus we use a one second alarm
|
||
* to interrupt the read with a trap to timeout(). But since the alarm signal
|
||
* may occur *before* the read is called, it is continuously restarted in
|
||
* timeout() to prevent it from getting lost.
|
||
*/
|
||
|
||
static int timeout(sig)
|
||
{
|
||
signal(SIGALRM, timeout);
|
||
alarm(1);
|
||
}
|
||
|
||
static void disaster()
|
||
{
|
||
write(2, "Fatal error: Channel variable corrupted\n", 40);
|
||
abort();
|
||
}
|