285 lines
6.3 KiB
C
285 lines
6.3 KiB
C
/* This module implements the serial line framing method used by
|
|
* net/rom nodes. This allows the net/rom software to talk to
|
|
* an actual net/rom over its serial interface, which is useful
|
|
* if we want to do packet switching for multi-line wormholes.
|
|
* Dan Frank, W9NK
|
|
*/
|
|
#include "options.h" /* included in case SERIALTEST changes */
|
|
#include "config.h"
|
|
#ifdef NRS
|
|
#include <stdio.h>
|
|
#include "global.h"
|
|
#include "mbuf.h"
|
|
#include "iface.h"
|
|
#include "ax25.h"
|
|
#include "nrs.h"
|
|
#include "asy.h"
|
|
#ifdef TRACE
|
|
#include "trace.h"
|
|
#endif
|
|
#if defined(MSDOS) && defined(SERIALTEST)
|
|
#include "8250.h"
|
|
#endif
|
|
|
|
int asy_output();
|
|
|
|
/* control structures, sort of overlayed on async control blocks */
|
|
struct nrs nrs[ASY_MAX];
|
|
|
|
/* Send a raw net/rom serial frame */
|
|
void
|
|
nrs_raw(interface,bp)
|
|
struct interface *interface;
|
|
struct mbuf *bp;
|
|
{
|
|
void dump(),nrsq();
|
|
#ifdef TRACE
|
|
dump(interface,IF_TRACE_OUT,TRACE_AX25,bp) ;
|
|
#endif
|
|
/* Queue a frame on the output queue and start transmitter */
|
|
nrsq(interface->dev,bp);
|
|
}
|
|
|
|
/* Encode a raw packet in net/rom framing, put on link output queue, and kick
|
|
* transmitter
|
|
*/
|
|
static void
|
|
nrsq(dev,bp)
|
|
int16 dev; /* Serial line number */
|
|
struct mbuf *bp; /* Buffer to be sent */
|
|
{
|
|
void nrasy_start();
|
|
register struct nrs *sp;
|
|
struct mbuf *nrs_encode();
|
|
|
|
if((bp = nrs_encode(bp)) == NULLBUF)
|
|
return;
|
|
|
|
sp = &nrs[dev];
|
|
enqueue(&sp->sndq,bp);
|
|
sp->sndcnt++;
|
|
if(sp->tbp == NULLBUF)
|
|
nrasy_start(dev);
|
|
}
|
|
|
|
/* Start output, if possible, on asynch device dev */
|
|
static void
|
|
nrasy_start(dev)
|
|
int16 dev;
|
|
{
|
|
register struct nrs *sp;
|
|
int stxrdy();
|
|
|
|
if(!stxrdy(dev))
|
|
return; /* Transmitter not ready */
|
|
|
|
sp = &nrs[dev];
|
|
if(sp->tbp != NULLBUF){
|
|
/* transmission just completed */
|
|
free_p(sp->tbp);
|
|
sp->tbp = NULLBUF;
|
|
}
|
|
if(sp->sndq == NULLBUF)
|
|
return; /* No work */
|
|
|
|
sp->tbp = dequeue(&sp->sndq);
|
|
sp->sndcnt--;
|
|
asy_output(dev,sp->tbp->data,sp->tbp->cnt);
|
|
}
|
|
|
|
/* Encode a packet in net/rom serial format */
|
|
static
|
|
struct mbuf *
|
|
nrs_encode(bp)
|
|
struct mbuf *bp;
|
|
{
|
|
struct mbuf *lbp; /* Mbuf containing line-ready packet */
|
|
register char *cp;
|
|
char c;
|
|
unsigned char csum = 0 ;
|
|
|
|
/* Allocate output mbuf that's twice as long as the packet.
|
|
* This is a worst-case guess (consider a packet full of STX's!)
|
|
* Add five bytes for STX, ETX, checksum, and two nulls.
|
|
*/
|
|
lbp = alloc_mbuf(2*len_mbuf(bp) + 5);
|
|
if(lbp == NULLBUF){
|
|
/* No space; drop */
|
|
free_p(bp);
|
|
return NULLBUF;
|
|
}
|
|
cp = lbp->data;
|
|
|
|
*cp++ = STX ;
|
|
|
|
/* Copy input to output, escaping special characters */
|
|
while(pullup(&bp,&c,1) == 1){
|
|
switch(uchar(c)){
|
|
case STX:
|
|
case ETX:
|
|
case DLE:
|
|
*cp++ = DLE;
|
|
/* notice drop through to default */
|
|
default:
|
|
*cp++ = c;
|
|
}
|
|
csum += uchar(c) ;
|
|
}
|
|
*cp++ = ETX;
|
|
*cp++ = csum ;
|
|
*cp++ = NUL ;
|
|
*cp++ = NUL ;
|
|
|
|
lbp->cnt = cp - lbp->data;
|
|
return lbp;
|
|
}
|
|
/* Process incoming bytes in net/rom serial format
|
|
* When a buffer is complete, return it; otherwise NULLBUF
|
|
*/
|
|
static
|
|
struct mbuf *
|
|
nrs_decode(dev,c)
|
|
int16 dev; /* net/rom unit number */
|
|
char c; /* Incoming character */
|
|
{
|
|
struct mbuf *bp;
|
|
register struct nrs *sp;
|
|
|
|
sp = &nrs[dev];
|
|
switch(sp->state) {
|
|
case NRS_INTER:
|
|
if (uchar(c) == STX) { /* look for start of frame */
|
|
sp->state = NRS_INPACK ; /* we're in a packet */
|
|
sp->csum = 0 ; /* reset checksum */
|
|
}
|
|
return NULLBUF ;
|
|
case NRS_CSUM:
|
|
bp = sp->rbp ;
|
|
sp->rbp = NULLBUF ;
|
|
sp->rcnt = 0 ;
|
|
sp->state = NRS_INTER ; /* go back to inter-packet state */
|
|
if (sp->csum == uchar(c)) {
|
|
sp->packets++ ;
|
|
return bp ;
|
|
}
|
|
else {
|
|
free_p(bp) ; /* drop packet with bad checksum */
|
|
sp->errors++ ; /* increment error count */
|
|
return NULLBUF ;
|
|
}
|
|
case NRS_ESCAPE:
|
|
sp->state = NRS_INPACK ; /* end of escape */
|
|
break ; /* this will drop through to char processing */
|
|
case NRS_INPACK:
|
|
switch (uchar(c)) {
|
|
/* If we see an STX in a packet, assume that previous */
|
|
/* packet was trashed, and start a new packet */
|
|
case STX:
|
|
free_p(sp->rbp) ;
|
|
sp->rbp = NULLBUF ;
|
|
sp->rcnt = 0 ;
|
|
sp->csum = 0 ;
|
|
sp->errors++ ;
|
|
return NULLBUF ;
|
|
case ETX:
|
|
sp->state = NRS_CSUM ; /* look for checksum */
|
|
return NULLBUF ;
|
|
case DLE:
|
|
sp->state = NRS_ESCAPE ;
|
|
return NULLBUF ;
|
|
}
|
|
}
|
|
/* If we get to here, it's with a character that's part of the packet.
|
|
* Make sure there's space for it.
|
|
*/
|
|
if(sp->rbp == NULLBUF){
|
|
/* Allocate first mbuf for new packet */
|
|
if((sp->rbp1 = sp->rbp = alloc_mbuf(NRS_ALLOC)) == NULLBUF) {
|
|
sp->state = NRS_INTER ;
|
|
return NULLBUF; /* No memory, drop */
|
|
}
|
|
sp->rcp = sp->rbp->data;
|
|
} else if(sp->rbp1->cnt == NRS_ALLOC){
|
|
/* Current mbuf is full; link in another */
|
|
if((sp->rbp1->next = alloc_mbuf(NRS_ALLOC)) == NULLBUF){
|
|
/* No memory, drop whole thing */
|
|
free_p(sp->rbp);
|
|
sp->rbp = NULLBUF;
|
|
sp->rcnt = 0;
|
|
sp->state = NRS_INTER ;
|
|
return NULLBUF;
|
|
}
|
|
sp->rbp1 = sp->rbp1->next;
|
|
sp->rcp = sp->rbp1->data;
|
|
}
|
|
/* Store the character, increment fragment and total
|
|
* byte counts
|
|
*/
|
|
*sp->rcp++ = c;
|
|
sp->rbp1->cnt++;
|
|
sp->rcnt++;
|
|
sp->csum += uchar(c) ; /* add to checksum */
|
|
return NULLBUF;
|
|
}
|
|
|
|
/* Process net/rom serial line I/O */
|
|
void
|
|
nrs_recv(interface)
|
|
struct interface *interface;
|
|
{
|
|
char c;
|
|
struct mbuf *bp;
|
|
int16 dev;
|
|
int16 asy_recv();
|
|
int ax_recv() ;
|
|
|
|
dev = interface->dev;
|
|
/* Process any pending input */
|
|
while(asy_recv(dev,&c,1) != 0)
|
|
if((bp = nrs_decode(dev,c)) != NULLBUF) {
|
|
|
|
#if defined(MSDOS) && defined(SERIALTEST)
|
|
/* Also done in kiss.c, kpc.c and nrs.c to clear error flag possibly
|
|
* set in the async handler
|
|
*/
|
|
extern int16 serial_err; /* defined in ipcmd.c */
|
|
extern int32 tot_rframes;
|
|
struct fifo *fp;
|
|
|
|
tot_rframes++;
|
|
fp = &asy[dev].fifo;
|
|
if(fp->error){ /* contains 8250 line status register */
|
|
serial_err++;
|
|
fp->error = 0;
|
|
free_p(bp);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
dump(interface,IF_TRACE_IN,TRACE_AX25,bp) ;
|
|
ax_recv(interface,bp);
|
|
}
|
|
|
|
/* Kick the transmitter if it's idle */
|
|
if(stxrdy(dev))
|
|
nrasy_start(dev);
|
|
}
|
|
|
|
/* donrstat: display status of active net/rom serial interfaces */
|
|
donrstat()
|
|
{
|
|
register struct nrs *np ;
|
|
register int i ;
|
|
|
|
printf("Interface SndQ RcvB NumReceived CSumErrors\n") ;
|
|
|
|
for (i = 0, np = nrs ; i < ASY_MAX ; i++, np++)
|
|
if (np->iface != NULLIF)
|
|
printf(" %8s %3d %4d %10lu %10lu\n",
|
|
np->iface->name, np->sndcnt, np->rcnt,
|
|
np->packets, np->errors) ;
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* NRS */
|