page%rishathra@Sun.COM (Bob Page) (04/29/89)
Submitted-by: dillon@postgres.berkeley.edu (Matt Dillon)
Posting-number: Volume 89, Issue 103
Archive-name: comm/dnet20-us.2
# This is a shell archive.
# Remove anything above and including the cut line.
# Then run the rest of the file through 'sh'.
# Unpacked files will be owned by you and have default permissions.
#----cut here-----cut here-----cut here-----cut here----#
#!/bin/sh
# shar: SHell ARchive
# Run the following text through 'sh' to create:
# dnet/net.c
# dnet/internal.c
# dnet/globals.c
# dnet/files.c
# dnet/dnet.h
# dnet/dnet.c
# dnet/Makefile
# dnet/MODS
# dnet.servers
# doc/history
# doc/dnet.doc
# doc/putfiles.doc
# doc/dsoc.doc
# doc/dnetlib.doc
# doc/draw.doc
# lib/dnetlib.h
# lib/dnetlib.c
# lib/Makefile
# server/sgcopy.c
# server/sshell.c
# server/sloadav.c
# server/scopy.c
# server/Makefile
# server/servers.h
# This is archive 2 of a 2-part kit.
# This archive created: Thu Apr 27 15:41:48 1989
if `test ! -d dnet`
then
mkdir dnet
echo "mkdir dnet"
fi
echo "extracting dnet/net.c"
sed 's/^X//' << \SHAR_EOF > dnet/net.c
X
X/*
X * NET.C
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X *
X * NetWork raw device interface. Replace with whatever interface you
X * want.
X */
X
X#include "dnet.h"
X#include <sys/stat.h>
X
XRcvInt()
X{
X int n = read(0, RcvBuf + RcvData, RCVBUF - RcvData);
X if (n >= 0)
X RcvData += n;
X if (n <= 0) /* disallow infinite fast-timeout select loops */
X RExpect = 0;
X if (DDebug && n < 0) {
X write(2, "RcvInt ERR\n", 11);
X }
X}
X
Xstatic struct sgttyb ttym;
Xstatic struct stat Stat;
X
XNetOpen()
X{
X int async = 1;
X
X fstat(0, &Stat);
X fchmod(0, 0600);
X /*
X signal(SIGIO, RcvInt);
X */
X ioctl (0, TIOCGETP, &ttym);
X ttym.sg_flags |= RAW;
X ttym.sg_flags &= ~CBREAK;
X ttym.sg_flags &= ~ECHO;
X ioctl (0, TIOCSETP, &ttym);
X /*
X ioctl (0, FIOASYNC, &async);
X */
X ioctl (0, FIONBIO, &async);
X}
X
XNetClose()
X{
X int async = 0;
X
X fchmod(0, Stat.st_mode);
X ioctl (0, FIONBIO, &async);
X /*
X ioctl (0, FIOASYNC, &async);
X */
X ioctl (0, TIOCGETP, &ttym);
X ttym.sg_flags &= ~RAW;
X ttym.sg_flags |= ECHO;
X ioctl (0, TIOCSETP, &ttym);
X}
X
XNetWrite(buf, bytes, expectreply)
Xubyte *buf;
X{
X if (expectreply)
X DidWrite = 1;
X if (DDebug)
X fprintf(stderr, "NETWRITE %08lx %ld\n", buf, bytes);
X gwrite(0, buf, bytes);
X}
X
Xgwrite(fd, buf, bytes)
Xregister char *buf;
Xregister long bytes;
X{
X register long n;
X while (bytes) {
X n = write(fd, buf, bytes);
X if (n > 0) {
X bytes -= n;
X buf += n;
X continue;
X }
X if (errno == EINTR)
X continue;
X if (errno == EWOULDBLOCK) {
X fd_set fd_wr;
X fd_set fd_ex;
X FD_ZERO(&fd_wr);
X FD_ZERO(&fd_ex);
X FD_SET(fd, &fd_wr);
X FD_SET(fd, &fd_ex);
X select(fd+1, NULL, &fd_wr, &fd_ex, NULL);
X continue;
X }
X if (errno == EPIPE)
X return;
X dneterror("gwrite");
X }
X}
X
SHAR_EOF
echo "extracting dnet/internal.c"
sed 's/^X//' << \SHAR_EOF > dnet/internal.c
X
X/*
X * INTERNAL.C
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X *
X * Usually SCMD_OPEN requests attempt to connect() to the UNIX
X * domain socket of the server. However, some 'ports' are designated
X * as internal to DNET. They reside here.
X *
X * -IALPHATERM
X */
X
X#include "dnet.h"
X#include "../server/servers.h"
X#include <sys/stat.h>
X#include <sys/wait.h>
X#include <sys/resource.h>
X#include <sys/uio.h>
X#include <strings.h>
X
Xextern char *getenv();
X
Xisinternalport(port)
Xuword port;
X{
X if (port == PORT_IALPHATERM)
X return(1);
X return(0);
X}
X
Xiconnect(ps, port)
Xint *ps;
Xuword port;
X{
X if (port == PORT_IALPHATERM)
X return(ialphaterm_connect(ps, port));
X return(-1);
X}
X
Xialphaterm_connect(pmaster)
Xint *pmaster;
X{
X struct sgttyb sg;
X struct tchars tc;
X struct ltchars ltc;
X#ifdef TIOCGSIZE
X struct ttysize ts;
X#else
X#ifdef TIOCGWINSZ
X struct winsize ws;
X#endif
X#endif
X int lmode;
X int fdmaster;
X int fdslave;
X int pid;
X char *slavename;
X
X ioctl(0, TIOCGETP, (char *)&sg);
X ioctl(0, TIOCGETC, (char *)&tc);
X ioctl(0, TIOCGLTC, (char *)<c);
X ioctl(0, TIOCLGET, (char *)&lmode);
X#ifdef TIOCGSIZE
X ioctl(0, TIOCGSIZE, &ts);
X#else
X#ifdef TIOCGWINSZ
X ioctl(0, TIOCGWINSZ, &ws);
X#endif
X#endif
X
X sg.sg_flags &= ~(RAW);
X sg.sg_flags |= ECHO;
X#ifdef TIOCGSIZE
X ts.ts_lines = 23;
X ts.ts_cols = 77;
X#else
X#ifdef TIOCGWINSZ
X ws.ws_row = 23;
X ws.ws_col = 77;
X#endif
X#endif
X
X if (DDebug)
X fprintf(stderr, "PTY openning internal pty\n");
X if (openpty(&fdmaster, &fdslave, &slavename) >= 0) {
X if (DDebug)
X fprintf(stderr, "PTY open successfull\n");
X if ((pid = fork()) == NULL) {
X int i;
X setenv("DNET=", "IALPHATERM");
X setuid(getuid());
X signal(SIGHUP, SIG_DFL);
X signal(SIGINT, SIG_DFL);
X signal(SIGQUIT, SIG_DFL);
X signal(SIGTERM, SIG_DFL);
X signal(SIGCHLD, SIG_DFL);
X signal(SIGTSTP, SIG_IGN);
X ioctl(open("/dev/tty", 2), TIOCNOTTY, NULL);
X close(open(slavename, 0));
X dup2(fdslave, 0);
X dup2(0, 1);
X dup2(0, 2);
X for (i = 3; i < 256; ++i)
X close(i);
X ioctl(0, TIOCSETN, &sg);
X ioctl(0, TIOCSETC, &tc);
X ioctl(0, TIOCSLTC, <c);
X ioctl(0, TIOCLSET, &lmode);
X#ifdef TIOCSSIZE
X ioctl(0, TIOCSSIZE, &ts);
X#else
X#ifdef TIOCSWINSZ
X ioctl(0, TIOCSWINSZ, &ws);
X#endif
X#endif
X {
X char *shell = getenv("SHELL");
X char *home = getenv("HOME");
X if (!shell)
X shell = "/bin/sh";
X if (!home)
X home = ".";
X chdir(home);
X execl(shell, "-fshell", NULL);
X perror(shell);
X }
X _exit(1);
X }
X if (pid > 0) {
X *pmaster = fdmaster;
X close(fdslave);
X if (DDebug)
X fprintf(stderr, "PTY OPEN OK.2\n");
X return(1);
X }
X close(fdmaster);
X close(fdslave);
X if (DDebug)
X fprintf(stderr, "PTY OPEN FAILURE.1\n");
X }
X if (DDebug)
X fprintf(stderr, "PTY OPEN FAILURE.2\n");
X return(-1);
X}
X
Xopenpty(pfdm, pfds, pnames)
Xint *pfdm;
Xint *pfds;
Xchar **pnames;
X{
X static char ptcs[] = { "0123456789abcdef" };
X static char plate[] = { "/dev/ptyxx" };
X struct stat stat;
X int i;
X int j;
X
X for (i = 'p';; ++i) {
X plate[8] = i;
X plate[9] = ptcs[0];
X if (lstat(plate, &stat) < 0)
X break;
X for (j = 0; ptcs[j]; ++j) {
X plate[9] = ptcs[j];
X plate[5] = 'p';
X if ((*pfdm = open(plate, O_RDWR)) >= 0) {
X plate[5] = 't';
X if ((*pfds = open(plate, O_RDWR)) >= 0) {
X *pnames = plate;
X if (DDebug)
X fprintf(stderr, "PTY FOUND %s\n", *pnames);
X return(1);
X }
X close(*pfdm);
X }
X }
X }
X return(-1);
X}
X
Xisetrows(fd, rows)
X{
X#ifdef TIOCSSIZE
X struct ttysize ts;
X if (ioctl(fd, TIOCGSIZE, &ts) >= 0) {
X ts.ts_lines = rows;
X ioctl(fd, TIOCSSIZE, &ts);
X }
X#else
X#ifdef TIOCSWINSZ
X struct winsize ws;
X if (ioctl(fd, TIOCGWINSZ, &ws) >= 0) {
X ws.ws_row = rows;
X ioctl(fd, TIOCSWINSZ, &ws);
X }
X#endif
X#endif
X}
X
Xisetcols(fd, cols)
X{
X#ifdef TIOCSSIZE
X struct ttysize ts;
X if (ioctl(fd, TIOCGSIZE, &ts) >= 0) {
X ts.ts_cols = cols;
X ioctl(fd, TIOCSSIZE, &ts);
X }
X#else
X#ifdef TIOCSWINSZ
X struct winsize ws;
X if (ioctl(fd, TIOCSWINSZ, &ws) >= 0) {
X ws.ws_col = cols;
X ioctl(fd, TIOCSWINSZ, &ws);
X }
X#endif
X#endif
X}
X
SHAR_EOF
echo "extracting dnet/globals.c"
sed 's/^X//' << \SHAR_EOF > dnet/globals.c
X
X/*
X * GLOBALS.C
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X */
X
X#include "dnet.h"
X
Xint Enable_Abort;
X
Xlong USecPerByte = 1000;/* for 9600 baud.. should really set properly */
Xint DNet_fd = -1; /* Master listen socket */
XPKT Pkts[9]; /* data buffers for packets */
XPKT *Raux = Pkts+8; /* next packet in */
Xubyte WCBuf[64];
XPKT *RPak[4] = { Pkts+0,Pkts+1,Pkts+2,Pkts+3 };
XPKT *WPak[4] = { Pkts+4,Pkts+5,Pkts+6,Pkts+7 };
XCHAN Chan[MAXCHAN]; /* Channels */
XLIST TxList; /* For pending SCMD_DATA reqs. */
Xfd_set Fdread;
Xfd_set Fdwrite;
Xfd_set Fdexcept;
Xvoid (*Fdstate[FD_SETSIZE])();
Xubyte Fdperm[FD_SETSIZE];
Xuword FdChan[FD_SETSIZE];
Xubyte RcvBuf[RCVBUF];
Xuword RcvData;
Xuword RExpect;
Xubyte RTimedout;
Xubyte WTimedout;
Xuword WChan; /* Read and Write channels */
Xuword RChan;
Xuword RPStart;
Xuword WPStart;
Xuword WPUsed;
Xuword RState;
Xuword Rto_act, Wto_act;
Xubyte DDebug;
Xubyte DidWrite;
Xubyte Restart;
Xubyte DeldQuit;
Xulong NumCon;
X
X
SHAR_EOF
echo "extracting dnet/files.c"
sed 's/^X//' << \SHAR_EOF > dnet/files.c
X
X/*
X * FILES.C
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X *
X * handles actions on a per file descriptor basis, including accepting
X * new connections, closing old connections, and transfering data
X * between connections.
X */
X
X#include "dnet.h"
X
Xextern void do_localopen(), do_connect(), do_open1(), do_openwait(), do_open();
X
X/*
X * new connection over master port... open request. read two byte port
X * number, allocate a channel, and send off to the remote
X */
X
Xvoid
Xdo_localopen(n, fd)
X{
X struct sockaddr sa;
X int addrlen = sizeof(sa);
X int s;
X uword chan;
X
X if (DDebug)
X fprintf(stderr, "DO_LOCALOPEN %ld %ld\n", n, fd);
X while ((s = accept(fd, &sa, &addrlen)) >= 0) {
X chan = alloc_channel();
X fcntl(s, F_SETFL, FNDELAY);
X if (DDebug)
X fprintf(stderr, " ACCEPT: %ld on channel %ld ", s, chan);
X if (chan == 0xFFFF) {
X ubyte error = 1;
X gwrite(s, &error, 1);
X close(s);
X if (DDebug)
X fprintf(stderr, "(no channels)\n");
X continue;
X }
X Fdstate[s] = do_open1;
X FdChan[s] = chan;
X FD_SET(s, &Fdread);
X FD_SET(s, &Fdexcept);
X Chan[chan].fd = s;
X Chan[chan].state = CHAN_LOPEN;
X if (DDebug)
X fprintf(stderr, "(State = CHAN_LOPEN)\n");
X }
X}
X
Xvoid
Xdo_open1(n, fd)
X{
X uword port;
X char trxpri[2];
X uword chan = FdChan[fd];
X COPEN co;
X int n;
X
X if (DDebug)
X fprintf(stderr, "DO_OPEN %ld %ld on channel %ld ", n, fd, chan);
X for (;;) {
X n = read(fd, &port, 2);
X if (n < 0) {
X if (errno == EINTR)
X continue;
X if (errno == EWOULDBLOCK)
X return;
X }
X read(fd, trxpri, 2);
X if (n != 2)
X dneterror("do_open1: unable to read 2 bytes");
X break;
X }
X if (DDebug)
X fprintf(stderr, "Port %ld\n", port);
X co.chanh = chan >> 8;
X co.chanl = chan;
X co.porth = port >> 8;
X co.portl = port;
X co.error = 0;
X co.pri = trxpri[1];
X Chan[chan].port = port;
X Chan[chan].pri = 126;
X WriteStream(SCMD_OPEN, &co, sizeof(co), chan);
X Chan[chan].pri = trxpri[0];
X Fdstate[fd] = do_openwait;
X if (DDebug)
X fprintf(stderr, " Newstate = openwait\n");
X}
X
Xvoid
Xdo_openwait(n, fd)
X{
X ubyte buf[32];
X if (DDebug)
X fprintf(stderr, "************ ERROR DO_OPENWAIT %ld %ld\n", n, fd);
X n = read(fd, buf, 32);
X if (DDebug) {
X fprintf(stderr, " OPENWAIT, READ %ld bytes\n", n);
X if (n < 0)
X perror("openwait:read");
X }
X}
X
Xvoid
Xdo_open(nn, fd)
X{
X extern void nop();
X char buf[256];
X uword chan = FdChan[fd];
X int n;
X
X n = read(fd, buf, sizeof(buf));
X if (DDebug) {
X fprintf(stderr, "DO_OPEN %ld %ld, RECEIVE DATA on chan %ld (%ld by)\n",
X nn, fd, chan, n);
X fprintf(stderr, " fd, chanfd %ld %ld\n", fd, Chan[chan].fd);
X if (n < 0)
X perror("open:read");
X }
X if (n == 0 || nn == 2) { /* application closed / exception cond */
X CCLOSE cc;
X
X if (DDebug)
X fprintf(stderr, " DO_OPEN: REMOTE EOF, channel %d\n", chan);
X
X cc.chanh = chan >> 8;
X cc.chanl = chan;
X WriteStream(SCMD_CLOSE, &cc, sizeof(CCLOSE), chan);
X Chan[chan].state = CHAN_CLOSE;
X Chan[chan].flags |= CHANF_LCLOSE;
X if (Chan[chan].flags & CHANF_RCLOSE) {
X ;
X /* should never happen
X int fd = Chan[chan].fd;
X Chan[chan].state = CHAN_FREE;
X Chan[chan].fd = -1;
X Fdstate[fd] = nop;
X FD_CLR(fd, &Fdread);
X FD_CLR(fd, &Fdexcept);
X close(fd);
X */
X } else {
X FD_CLR(fd, &Fdread);
X FD_CLR(fd, &Fdexcept);
X }
X }
X if (n > 0) {
X WriteStream(SCMD_DATA, buf, n, chan);
X }
X}
X
SHAR_EOF
echo "extracting dnet/dnet.h"
sed 's/^X//' << \SHAR_EOF > dnet/dnet.h
X
X/*
X * DNET.H
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X */
X
X#include <sys/types.h>
X#include <sys/ioctl.h>
X#include <sys/socket.h>
X#include <sys/time.h>
X#include <sys/file.h>
X
X/* V2.01 */
X#include <sys/param.h>
X#include <pwd.h>
X
X#include <signal.h>
X#include <stdio.h>
X#include <errno.h>
X#ifndef FD_SETSIZE
X#define FD_SETSIZE (sizeof(struct fd_set) * 8)
X#endif
X#ifndef NFDBITS
X#define NFDBITS 32
X#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
X#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
X#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
X#define FD_ZERO(p) bzero((char *)(p), sizeof(*(p)))
X#endif
X#ifndef sigmask
X#define sigmask(m) (1 << ((m)-1))
X#endif
X
X#ifndef LASTTRYDNETSERVERS
X#define LASTTRYDNETSERVERS "/usr/local/lib/dnet/dnet.servers"
X#endif
X
Xstruct Node {
X struct Node *ln_Succ;
X struct Node *ln_Pred;
X};
X
Xstruct List {
X struct Node *lh_Head;
X struct Node *lh_Tail;
X struct Node *lh_TailPred;
X};
X
X
Xtypedef unsigned char ubyte;
Xtypedef unsigned short uword;
Xtypedef unsigned long ulong;
X
Xtypedef struct List LIST;
Xtypedef struct Node NODE;
X
X#include "channel.h"
X
X#define PKT struct _PKT
X#define XIOR struct _XIOR
X
X#define EMPTY 0 /* empty (sent) */
X#define READY 1 /* data ready (not sent yet) */
X#define RCVBUF 4096
X
X#define MAXCHAN 128 /* Max # of channels supported */
X#define SYNC 0xFF /* SYNC character */
X#define WTIME 2000000 /* in micro seconds (expect ack) */
X#define RTIME 1000000 /* in micro seconds (read to) */
X#define MAXPKT 200 /* maximum packet size (data area) */
X#define MINPKT 32 /* minimum packet size (data area) for purposes */
X /* of determining the dynamic maximum packet size*/
X /* only. Actual minimum is, of course, 1 byte */
X
X#define OVERHEAD 7 /* for packets with data */
X
XXIOR {
X NODE io_Node;
X ubyte *io_Data;
X ulong io_Length;
X ulong io_Actual;
X uword io_Channel;
X ubyte io_Command;
X ubyte io_Error;
X char io_Pri;
X};
X
XPKT {
X uword iolength; /* send: length of packet, recv: length of data */
X ubyte state; /* EMPTY, READY */
X
X ubyte sync; /* THE PACKET */
X ubyte ctl;
X ubyte cchk;
X ubyte lenh;
X ubyte lenl;
X ubyte data[MAXPKT+2];
X};
X
X /*
X * In receiving a packet the receiver can be in one of these
X * states.
X */
X
X#define RS_SYNC 0 /* Waiting for sync */
X#define RS_CTL 1 /* Waiting for command */
X#define RS_CCHK 2 /* Waiting for check byte */
X#define RS_LEN1 3 /* Waiting for MSB length byte */
X#define RS_LEN2 4 /* Waiting for LSB length byte */
X#define RS_DATA 5 /* Waiting for data & checksum */
X
X /*
X * The low level protocol generates packets. This is used
X * for error checking, data sequencing, retries, restart, etc...
X * The packet format is:
X *
X * SYNC sss0xccc CHK
X * SYNC sss1xccc CHK nnnnnnnn nnnnnnnn [DATA] CHK2
X * msb lsb
X *
X * sss = sequence #
X * B4 = packet contains data
X * B3 = reserved (may be used to extend the command set)
X * ccc = PKF_?????
X *
X * NOTE that the data length nnn..nn is not checked with either
X * CHK or CHK2 . The protocol will determine if the length
X * is reasonable (< MAXPKT) and then try to read that many
X * bytes. The CHK will obviously fail if the length was
X * incorrect.
X */
X
X#define PKF_SEQUENCE 0xE0 /* Sequence # */
X#define PKF_DATA 0x10 /* 1-65535 bytes */
X#define PKF_RESERVED 0x08 /* reserved bit */
X#define PKF_MASK 0x07 /* command mask */
X
X#define PKCMD_WRITE 1 /* A DATA packet */
X#define PKCMD_CHECK 2 /* Request ACK or NAK for win */
X#define PKCMD_ACK 3 /* ACK a window */
X#define PKCMD_NAK 4 /* NAK a window */
X#define PKCMD_RESTART 5 /* RESTART dnet. (new) */
X#define PKCMD_ACKRSTART 6 /* ACK a restart (new) */
X#define PKCMD_RESERVE3 7
X
X /*
X * All channel multiplexing, channel commands, etc... is encoded
X * within a PKCMD_WRITE packet.
X *
X * Channel commands are characterized by a one byte control
X * field and up to 7 bytes of data. The control field format
X * is: 10cccnnn [DATA] ccc = SCMD_??
X * nnn = # additional data bytes
X */
X
X#define SCMD_SWITCH 0x00 /* switch active channel # */
X#define SCMD_OPEN 0x01 /* open a channel */
X#define SCMD_CLOSE 0x02 /* close a channel */
X#define SCMD_ACKCMD 0x03 /* ack an open/close request */
X#define SCMD_EOFCMD 0x04 /* Reof or Weof */
X#define SCMD_QUIT 0x05 /* QUIT dnet */
X#define SCMD_IOCTL 0x06 /* channel ioctl (new),PTY sup */
X#define SCMD_RESERVE1 0x07
X
X /*
X * Stream data is characterized by the following format:
X *
X * msb lsb
X * 11nnnnnn nnnnnnnn [128-16383 bytes DATA]
X * 0nnnnnnn [0-127 bytes DATA]
X *
X * NOTE: 11000000 0ccccccc nnnnnnnn reserved for furture ext. of
X * SCMD commands.
X */
X
X#define SCMD_DATA 0x08 /* stream command, DATA (dummy ID) */
X
X /*
X * Each channel can be in one of several states.
X */
X
X#define CHAN_FREE 0x01 /* free channel */
X#define CHAN_ROPEN 0x02 /* remote open, wait port msg */
X#define CHAN_LOPEN 0x03 /* local open, wait reply */
X#define CHAN_OPEN 0x04 /* channel open */
X#define CHAN_CLOSE 0x05 /* one side of channel closed */
X
X#define CHANF_ROK 0x01 /* remote hasn't EOF'd us yet */
X#define CHANF_WOK 0x02 /* remote will accept data */
X#define CHANF_LCLOSE 0x04 /* channel closed on our side */
X#define CHANF_RCLOSE 0x08 /* channel closed on rem side */
X
Xextern ubyte *RemHead();
Xextern ubyte *malloc();
Xextern char *getenv();
X
X#ifndef NOEXT
Xextern long USecPerByte;
Xextern int DNet_fd;
Xextern PKT Pkts[9];
Xextern ubyte WCBuf[64];
Xextern PKT *RPak[4];
Xextern PKT *WPak[4];
Xextern CHAN Chan[MAXCHAN];
Xextern LIST TxList; /* For pending DNCMD_WRITE reqs. */
Xextern fd_set Fdread;
Xextern fd_set Fdwrite;
Xextern fd_set Fdexcept;
Xextern void (*Fdstate[FD_SETSIZE])();
Xextern ubyte Fdperm[FD_SETSIZE];
Xextern uword FdChan[FD_SETSIZE];
Xextern ubyte RcvBuf[RCVBUF];
Xextern ubyte RTimedout, WTimedout;
Xextern uword Rto_act, Wto_act;
Xextern uword RcvData;
Xextern uword RExpect;
Xextern uword RChan;
Xextern uword WChan;
Xextern uword RPStart;
Xextern uword WPStart;
Xextern uword WPUsed;
Xextern uword RState;
Xextern ubyte DDebug;
Xextern ubyte DidWrite;
Xextern ubyte Restart;
Xextern ubyte DeldQuit;
Xextern ulong NumCon;
X
Xextern int errno;
X
X#endif
X
SHAR_EOF
echo "extracting dnet/dnet.c"
sed 's/^X//' << \SHAR_EOF > dnet/dnet.c
X
X/*
X * DNET.C
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X *
X * Handles action on all active file descriptors and dispatches
X * to the proper function in FILES.C
X *
X */
X
X#include "dnet.h"
X#include <sys/wait.h>
X#include <sys/resource.h>
X
Xhandle_child()
X{
X union wait stat;
X struct rusage rus;
X while (wait3(&stat, WNOHANG, &rus) > 0);
X}
X
Xchar *
Xshowselect(ptr)
Xfd_set *ptr;
X{
X static char buf[FD_SETSIZE+32];
X short i;
X
X for (i = 0; i < FD_SETSIZE; ++i) {
X buf[i] = (FD_ISSET(i, ptr)) ? '1' : '0';
X }
X buf[i] = 0;
X return(buf);
X}
X
X
Xloganddie()
X{
X fflush(stderr);
X fprintf(stderr, "\nHUPSIGNAL\n");
X perror("HUP, last error:");
X fprintf(stderr, "Last select return:\n");
X fprintf(stderr, " %s\n", showselect(&Fdread));
X fprintf(stderr, " %s\n", showselect(&Fdwrite));
X fprintf(stderr, " %s\n", showselect(&Fdexcept));
X fprintf(stderr, "RcvData = %ld\n", RcvData);
X fprintf(stderr, "RChan/WChan = %ld/%ld\n", RChan, WChan);
X fprintf(stderr, "RPStart = %ld\n", RPStart);
X fprintf(stderr, "WPStart = %ld\n", WPStart);
X fprintf(stderr, "WPUsed = %ld\n", WPUsed);
X fprintf(stderr, "RState = %ld\n", RState);
X fflush(stderr);
X kill(0, SIGILL);
X exit(1);
X}
X
X#define SASIZE(sa) (sizeof(sa)-sizeof((sa).sa_data)+strlen((sa).sa_data))
X
Xmain(ac,av)
Xchar *av[];
X{
X long sink_mask, dnet_mask;
X long mark = 0;
X ubyte notdone;
X char local_dir[MAXPATHLEN];
X struct passwd pw_info;
X extern void RcvInt();
X
X if (getenv("DNETDIR")) {
X strcpy(local_dir, getenv("DNETDIR"));
X if (chdir(local_dir)) {
X fprintf(stderr, "Unable to chdir to DNETDIR: %s\n", local_dir);
X exit(1);
X }
X freopen("DNET.LOG", "w", stderr);
X } else {
X pw_info = *getpwuid(getuid());
X strcpy(local_dir, pw_info.pw_dir);
X strcat(local_dir, "/.dnet");
X if (chdir(local_dir)) {
X mkdir(local_dir, 0700);
X if (chdir(local_dir)) {
X fprintf(stderr, "Unable to create dir %s\n", local_dir);
X exit(1);
X }
X }
X freopen("DNET.LOG", "w", stderr);
X }
X fprintf(stderr, "DNet startup\n");
X fprintf(stderr, "Log file placed in %s\n", local_dir);
X fflush(stderr);
X
X signal(SIGINT, SIG_IGN);
X signal(SIGPIPE, SIG_IGN);
X signal(SIGQUIT, SIG_IGN);
X signal(SIGCHLD, handle_child);
X signal(SIGHUP, loganddie);
X
X bzero(Pkts,sizeof(Pkts));
X setlistenport("");
X
X {
X register short i;
X for (i = 1; i < ac; ++i) {
X register char *ptr = av[i];
X if (*ptr != '-') {
X DDebug = 1;
X fprintf(stderr, "Debug mode on\n");
X continue;
X }
X switch(*ptr) {
X case 'B':
X USecPerByte = atoi(ptr+1) / 10; /* bytes per second */
X USecPerByte = 1000000 / USecPerByte;
X fprintf(stderr, "Assuming about %ld uS/byte for timeout calc\n",
X USecPerByte
X );
X break;
X default:
X fprintf(stderr, "Unknown option: %c\n", *ptr);
X printf("Unknown option: %c\n", *ptr);
X exit(1);
X }
X }
X }
X
X NewList(&TxList);
X
X Fdperm[0] = 1;
X Fdstate[0] = RcvInt;
X FD_SET(0, &Fdread);
X FD_SET(0, &Fdexcept);
X
X fprintf(stderr, "DNET RUNNING, Listenfd=%ld\n", DNet_fd);
X NetOpen(); /* initialize network and interrupt driven read */
X TimerOpen(); /* initialize timers */
X
X do_netreset();
X do_restart();
X
X notdone = 1;
X while (notdone) {
X /*
X * MAIN LOOP. select() on all the file descriptors. Set the
X * timeout to infinity (NULL) normally. However, if there is
X * a pending read or write timeout, set the select timeout
X * to 2 seconds in case they timeout before we call select().
X * (i.e. a timing window). OR, if we are in the middle of a
X * read, don't use descriptor 0 and timeout according to
X * the expected read length, then set the descriptor as ready.
X */
X
X fd_set fd_rd;
X fd_set fd_wr;
X fd_set fd_ex;
X struct timeval tv, *ptv;
X int err;
X
X fd_rd = Fdread;
X fd_wr = Fdwrite;
X fd_ex = Fdexcept;
X
X tv.tv_sec = 0; /* normally wait forever for an event */
X tv.tv_usec= 0;
X ptv = NULL;
X if ((Rto_act || Wto_act)) { /* unless timeout pending */
X ptv = &tv;
X tv.tv_sec = 2;
X }
X
X /* ... or expecting data (don't just wait for one byte).
X *
X * This is an attempt to reduce the CPU usage for the process.
X * If we are expecting data over the serial line, then don't
X * return from the select() even if data is available, but
X * wait for the timeout period indicated before reading the
X * data. Don't wait more than 64 byte times or we may loose
X * some data (the silo's are only so big.. like 128 bytes).
X *
X * Currently, USecPerByte is not set properly (set for 9600 baud)
X */
X
X if (RExpect) {
X ptv = &tv;
X tv.tv_usec= USecPerByte * ((RExpect < 64) ? RExpect : 64);
X tv.tv_sec = 0;
X FD_CLR(0, &fd_rd);
X }
X err = select(FD_SETSIZE, &fd_rd, &fd_wr, &fd_ex, ptv);
X if (RExpect) {
X FD_SET(0, &fd_rd); /* pretend data ready */
X }
X if (DDebug)
X fprintf(stderr, "SERR %ld %ld %08lx %08lx\n",
X err, errno, RExpect, ptv
X );
X
X if (RTimedout) {
X RTimedout = 0;
X do_rto();
X mark = 0;
X }
X if (WTimedout) {
X WTimedout = 0;
X do_wto();
X }
X if (err < 0) {
X if (errno == EBADF) {
X perror("select");
X dneterror(NULL);
X }
X } else {
X register short i;
X register short j;
X register long mask;
X
X for (i = 0; i < FD_SETSIZE/NFDBITS; ++i) {
X if (mask = fd_ex.fds_bits[i]) {
X for (j = i * NFDBITS; mask; (mask >>= 1),(++j)) {
X if (mask & 1)
X (*Fdstate[j])(2,j);
X }
X }
X if (mask = fd_wr.fds_bits[i]) {
X for (j = i * NFDBITS; mask; (mask >>= 1),(++j)) {
X if (mask & 1)
X (*Fdstate[j])(1,j);
X }
X }
X if (mask = fd_rd.fds_bits[i]) {
X for (j = i * NFDBITS; mask; (mask >>= 1),(++j)) {
X if (mask & 1)
X (*Fdstate[j])(0,j);
X }
X }
X }
X }
X if (RcvData != mark)
X mark = do_rnet();
X do_wupdate();
X do_wnet();
X }
X dneterror(NULL);
X}
X
Xvoid
Xnop()
X{
X}
X
Xdo_netreset()
X{
X register short i;
X register CHAN *ch;
X for (i = 0; i < FD_SETSIZE; ++i) {
X if (!Fdperm[i])
X Fdstate[i] = nop;
X }
X for (i = 0, ch = Chan; i < MAXCHAN; ++i, ++ch) {
X switch(ch->state) {
X case CHAN_OPEN:
X case CHAN_LOPEN: /* pending on network */
X case CHAN_CLOSE:
X if (ch->fd >= 0) {
X FD_CLR(ch->fd, &Fdread);
X FD_CLR(ch->fd, &Fdexcept);
X Fdstate[ch->fd] = nop;
X close(ch->fd);
X ch->fd = -1;
X ch->state = CHAN_FREE;
X ch->flags = 0;
X --NumCon;
X }
X ClearChan(&TxList, i, 1);
X break;
X }
X }
X RPStart = 0;
X WPStart = 0;
X WPUsed = 0;
X RState = 0;
X RChan = 0;
X WChan = 0;
X}
X
Xdo_restart()
X{
X static ubyte buf[3] = { SYNC, PKCMD_RESTART, (SYNC<<1)^PKCMD_RESTART };
X Restart = 1;
X NetWrite(buf, sizeof(buf), 1);
X WTimeout(WTIME);
X}
X
Xsetlistenport(remotehost)
Xchar *remotehost;
X{
X static struct sockaddr sa[2];
X int s;
X extern void do_localopen();
X
X if (DNet_fd >= 0) {
X unlink(sa[0].sa_data);
X Fdstate[DNet_fd] = nop;
X Fdperm[DNet_fd] = 0;
X FD_CLR(DNet_fd, &Fdread);
X FD_CLR(DNet_fd, &Fdexcept);
X close(DNet_fd);
X }
X setenv("DNETHOST=", remotehost);
X sprintf(sa[0].sa_data, "DNET.%s", remotehost);
X unlink(sa[0].sa_data);
X sa[0].sa_family = AF_UNIX;
X
X s = socket(PF_UNIX, SOCK_STREAM, 0);
X fcntl(s, F_SETOWN, getpid());
X fcntl(s, F_SETFL, FNDELAY);
X if (bind(s, &sa[0], SASIZE(sa[0])) < 0) {
X perror("bind");
X exit(1);
X }
X if (listen(s, 5) < 0) {
X unlink(sa[0].sa_data);
X perror("listen");
X exit(1);
X }
X DNet_fd = s;
X Fdstate[DNet_fd] = do_localopen;
X Fdperm[DNet_fd] = 1;
X FD_SET(DNet_fd, &Fdread);
X FD_SET(DNet_fd, &Fdexcept);
X}
X
SHAR_EOF
echo "extracting dnet/Makefile"
sed 's/^X//' << \SHAR_EOF > dnet/Makefile
X
X# THE DNET DRIVER, UNIX END
X#
X# DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X#
X# the BIN should be placed in your path for ease of use. DNET uses
X# UNIX level sockets allowing multiple users on a system to run it
X# independantly. You should make a special directory (Example: .DNET)
X# and then setenv DNETDIR ~/.DNET/ ... all clients and servers will
X# use the enviroment variable to find/create the UNIX level sockets.
X
XBIN = ../bin
XOBJS = dnet.o control.o files.o globals.o net.o subs.o internal.o
X
X
X$(BIN)/dnet: $(OBJS)
X cc $(OBJS) -o $(BIN)/dnet
X
Xclean:
X rm -f *.o make.out
X
SHAR_EOF
echo "extracting dnet/MODS"
sed 's/^X//' << \SHAR_EOF > dnet/MODS
X
Xnet.c: notion of reply expected added to NetWrite()
Xdnet.c: select modified. On error still attempt write ops
X
SHAR_EOF
echo "extracting dnet.servers"
sed 's/^X//' << \SHAR_EOF > dnet.servers
X
X8192 ~/src/dnet.unix/bin/scopy ~
X8193 ~/src/dnet.unix/bin/sshell ~
X8197 ~/src/dnet.unix/bin/sloadav ~
X8201 ~/src/dnet.unix/bin/sgcopy ~
X
SHAR_EOF
if `test ! -d doc`
then
mkdir doc
echo "mkdir doc"
fi
echo "extracting doc/history"
sed 's/^X//' << \SHAR_EOF > doc/history
X
X V1.00 sometime in 1987
X First release
X
X V1.20 sometime in 1988
X Fixes to the first release
X
X V2.00 1 March 1989
X
X Major fixes, additions, and other items.
X
X
X
SHAR_EOF
echo "extracting doc/dnet.doc"
sed 's/^X//' << \SHAR_EOF > doc/dnet.doc
X
XUNIX/DNET
X
X DNET [debug]
X
X Run the DNET protocol on descriptor 0. If the enviroment variable
X DNETDIR exists, DNET will create the rendezvous sockets in the
X specified directory (DNETDIR must have a hanging slash on it),
X otherwise the current directory is used.
X
X DNET also opens a log file (DNET.LOG) in the directory. If the debug
X option is given, DNET writes gobs of debugging information to the log.
X
X Descriptor 0 may be a tty or socket.
X
X To allow DNET to startup servers on demand, the file "dnet.servers"
X must exist in the rendezvous directory.
X
X -Matt
X
SHAR_EOF
echo "extracting doc/putfiles.doc"
sed 's/^X//' << \SHAR_EOF > doc/putfiles.doc
XUNIX/PUTFILES
XAMIGA/PUTFILES
X
X PUTFILES [-dDESTDIR] file/dir file/dir file/dir ..
X
X File transfer client. Transfer the specified files and or directories
X to the destination directory on the remote machine. For instance:
X
X unix: putfiles -dram: charlie.txt /usr/include
X
X *places the file charlie.txt as ram:charlie.txt, and places the
X directory structure /usr/include as ram:include/(whatever).
X
X The default destination directory depends on the remote host. If the
X destination is an Amiga, the default is DF0: (so you probably always
X want to specify a -d switch). On the UNIX end, the default is whatever
X is set in the file dnet.servers
X
X Currently, no file compression is done. I also hope to add
X semi-automatic crash recovery (continue download where you left off
X after a crash), though it should be noted that it is very difficult
X to crash DNET with random modem noise.
X
SHAR_EOF
echo "extracting doc/dsoc.doc"
sed 's/^X//' << \SHAR_EOF > doc/dsoc.doc
X
X
XUNIX/DSOC
X
X
XDSOC [port#]
X
X (default: 8196 = AMIGSHELL (CLI window))
X
X Connect to the remote port but keep the TTY in COOKED mode (normal).
X The connection will be terminated by killing the process on the UNIX
X end or typing ^C. NOTE THAT ^C KILLS DSOC AND IS NOT SENT THROUGH TO
X THE REMOTE CLI.
X
X The default port accesses the SCLI server on the Amiga end, which
X starts up a CLI. Things work properly only if *MY* PIPE: device is
X installed on the Amiga. Things close down properly only if you
X have a CLI prompt when you exit DSOC.
X
X The SCLI server currently handles only one connection at a time.
X
SHAR_EOF
echo "extracting doc/dnetlib.doc"
sed 's/^X//' << \SHAR_EOF > doc/dnetlib.doc
X
XUNIX/DNETLIB
X
X UNIX END DNET LIBRARY INTERFACE
X
X See the server source for good examples of usage.
X
Xlong private;
Xuword port
Xchar *buf;
Xint fd;
Xint res1..5, bytes
Xchar pri;
Xlong val68, valvax;
X
Xprivate = DListen(port) listen on a port (server)
X fd = DAccept(private) accept a connection (server)
X DNAAccept(private) don't accept a conn.(server)
X fd = DOpen(host, port, txpri, rxpri) open a remote connection (client)
X res1 = read(fd, buf, bytes) standard unix read()
X res2 = gread(fd, buf, bytes) (see below)
X res3 = ggread(fd, buf, bytes) (see below)
X res4 = write(fd, buf, bytes) standard unix write()
X res5 = gwrite(fd, buf, bytes) (see below)
X close(fd);
X
X val68 = ntohl68(valvax) convert to and from MC68000 longword format.
X valvax= htonl68(val68)
X
X
XDListen() sets up a UNIX domain socket in the current directory unless
X another is specified by the DNETDIR enviroment variable.
X Returns a private structure pointer or NULL on error.
X
X This call will override any existing server for the port in
X the directory permanently. It does not cause an existing
X server to exit, however, and you should be careful to kill
X old servers before starting new ones. See the source for a
X template of correct server code.
X
XDAccept() Accepts a new connection on the port. Returns a file
X descriptor or a negative value. This call will block.
X
XDOpen() Attempt to connect to a port on the remote machine. Returns
X a file descriptor or a negative value. The error is either
X due to not finding DNET's master port (DNET must be running),
X or the remote server not running.
X
X This call looks in the current directory for the master
X socket unless another is specified by the DNETDIR enviroment
X variable.
X
X Two priorities are specified. One for sending, and one for
X receiving data. A priority is a value -127 to 126 inclusive,
X with 126 the highest priority. Normally, priorities range
X from -80 (file transfers) to +20 (terminal window).
X
XDEof() Send an EOF without closing the connection. Currently doesn't
X work worth shit, so don't use it.
X
Xwrite() Standard UNIX write call. But we are dealing with a socket
X here, so one must be careful of the return value. (1) WRITE()
X may not return the # bytes requested to write, but less,
X (2) WRITE() may return a negative value indicating an error or
X that it was interrupted or that it would have blocked (if you
X have got non-blocking IO setup). (3) WRITE() returns 0 on
X socket EOF.
X
Xgwrite() This call will write all the bytes specified, whether the
X socket is non-blocking or not. It handles restarting the
X WRITE() call on EINTR and properly handles EWOULDBLOCK.
X
X It returns the number bytes requested or fewer on error. If
X fewer bytes are returned you should close the socket and exit.
X
Xread() Standard UNIX read call. But we are still dealing with a
X socket here and anything might happen. READ() can return fewer
X than the number of bytes requested, 0 on EOF, or a negative
X number indicating various errors.
X
Xgread() GREAD() handles retrying if the EINTR error occurs. GREAD()
X blocks until at least one character is received (or EOF), and
X does this even if the socket is marked non-blocking. GREAD()
X returns 0 on EOF/ERROR.
X
Xggread() GGREAD() not only retries on EINTR, but will block until ALL
X the requested bytes are read in, even if the socket is marked
X non-blocking. GGREAD() returns -1 on EOF/ERROR. You can also
X tell if an EOF/ERROR occured if fewer than the requested
X number of bytes are read.
X
SHAR_EOF
echo "extracting doc/draw.doc"
sed 's/^X//' << \SHAR_EOF > doc/draw.doc
X
XUNIX/DRAW
X
X
XDRAW [port#]
X
X (default: 8195 = AMIGTERM (talk window))
X
X Connect to the remote port and place the TTY in RAW mode. The
X connection can only be terminated by the remote end, or by killing
X the process on the UNIX end.
X
X The default port brings up a 'talk' window on the Amiga. AMIGATERM
X will recognize a ^C sent from DRAW and close the connection.
X
SHAR_EOF
if `test ! -d lib`
then
mkdir lib
echo "mkdir lib"
fi
echo "extracting lib/dnetlib.h"
sed 's/^X//' << \SHAR_EOF > lib/dnetlib.h
X
X#define EFATAL 0
X#define EWARN 1
X#define EDEBUG 2
X
SHAR_EOF
echo "extracting lib/dnetlib.c"
sed 's/^X//' << \SHAR_EOF > lib/dnetlib.c
X
X/*
X * DNETLIB.C
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X *
X * Library Interface for DNET.
X */
X
X#include <sys/types.h>
X#include <sys/socket.h>
X#include <fcntl.h>
X#include <signal.h>
X#include <stdio.h>
X#include <errno.h>
X#ifdef O_CREAT
X#include <sys/file.h>
X#endif
X#include "../lib/dnetlib.h"
X
Xextern char *getenv();
X
Xtypedef unsigned short uword;
Xtypedef unsigned long ulong;
Xtypedef unsigned char ubyte;
Xtypedef struct sockaddr SOCKADDR;
X
Xtypedef struct {
X int s;
X uword port;
X} CHANN;
X
X#define NAMELEN sizeof(".PORT.XXXXX")
X#define NAMEPAT "%s.PORT.%ld"
X
Xchar *getdirpart();
X
XCHANN *
XDListen(port)
Xuword port;
X{
X CHANN *chan;
X int s;
X SOCKADDR *sa = (SOCKADDR *)malloc(sizeof(SOCKADDR)+256);
X char *dirstr = getenv("DNETDIR") ? getenv("DNETDIR") : "";
X
X sprintf(sa->sa_data, NAMEPAT, dirstr, port);
X sa->sa_family = AF_UNIX;
X unlink(sa->sa_data);
X
X s = socket(PF_UNIX, SOCK_STREAM, 0);
X fcntl(s, F_SETOWN, getpid());
X if (bind(s, sa, sizeof(*sa)-sizeof(sa->sa_data)+strlen(sa->sa_data)) < 0) {
X close(s);
X free(sa);
X return(NULL);
X }
X if (listen(s, 5) < 0) {
X close(s);
X unlink(sa->sa_data);
X free(sa);
X return(NULL);
X }
X chan = (CHANN *)malloc(sizeof(CHANN));
X chan->s = s;
X chan->port = port;
X free(sa);
X return(chan);
X}
X
X
XDUnListen(chan)
XCHANN *chan;
X{
X char *dirstr = getenv("DNETDIR") ? getenv("DNETDIR") : "";
X char buf[32];
X
X close(chan->s);
X sprintf(buf, NAMEPAT, dirstr, chan->port);
X unlink(buf);
X free(chan);
X}
X
XDAccept(chan)
XCHANN *chan;
X{
X SOCKADDR sa;
X int addrlen = sizeof(sa);
X int fd;
X
X fd = accept(chan->s, &sa, &addrlen);
X return(fd);
X}
X
XDOpen(host, port, txpri, rxpri)
Xchar *host;
Xuword port;
Xchar txpri, rxpri;
X{
X int s;
X char rc;
X short xb[3];
X SOCKADDR *sa = (SOCKADDR *)malloc(sizeof(SOCKADDR)+256);
X char *dirstr = getenv("DNETDIR") ? getenv("DNETDIR") : "";
X
X if (rxpri < -127)
X rxpri = -127;
X if (rxpri > 126)
X rxpri = 126;
X if (txpri < -127)
X txpri = -127;
X if (txpri > 126)
X txpri = 126;
X
X if (host == NULL)
X host = (getenv("DNETHOST")) ? getenv("DNETHOST"):"";
X
X sa->sa_family = AF_INET;
X sprintf(sa->sa_data, "%s%s%s", dirstr, "DNET.", host);
X
X s = socket(PF_UNIX, SOCK_STREAM, 0);
X fcntl(s, F_SETOWN, getpid());
X if (connect(s, sa, sizeof(*sa)-sizeof(sa->sa_data)+
X strlen(sa->sa_data))<0) {
X close(s);
X free(sa);
X return(-1);
X }
X free(sa);
X xb[0] = port;
X ((char *)&xb[1])[0] = txpri;
X ((char *)&xb[1])[1] = rxpri;
X write(s, xb, 4);
X if (read(s, &rc, 1) == 1 && rc == 0)
X return(s);
X close(s);
X return(-1);
X}
X
XDEof(fd)
X{
X char dummy;
X
X shutdown(fd, 1);
X write(fd, &dummy, 0);
X}
X
Xgwrite(fd, buf, bytes)
Xchar *buf;
X{
X int n;
X int orig = bytes;
X extern int errno;
X while (bytes) {
X n = write(fd, buf, bytes);
X if (n > 0) {
X bytes -= n;
X buf += n;
X continue;
X }
X if (n < 0) {
X if (errno == EINTR)
X continue;
X if (errno == EWOULDBLOCK) {
X int wm = 1 << fd;
X int em = 1 << fd;
X if (select(fd+1, NULL, &wm, &em, NULL) < 0)
X continue;
X if (wm)
X continue;
X }
X return(orig - bytes);
X }
X }
X return(orig);
X}
X
Xgread(fd, buf, bytes)
Xchar *buf;
X{
X int n;
X int orig = bytes;
X extern int errno;
X while (bytes) {
X n = read(fd, buf, bytes);
X if (n > 0) {
X bytes -= n;
X buf += n;
X break;
X }
X if (n < 0) {
X if (errno == EINTR)
X continue;
X if (errno == EWOULDBLOCK) {
X int rm = 1 << fd;
X int em = 1 << fd;
X if (select(fd+1, &rm, NULL, &em, NULL) < 0)
X continue;
X if (rm)
X continue;
X }
X return(orig - bytes);
X }
X if (n == 0)
X break;
X }
X return(orig - bytes);
X}
X
Xggread(fd, buf, bytes)
Xchar *buf;
X{
X int n;
X int ttl = 0;
X while (bytes) {
X n = gread(fd, buf, bytes);
X if (n > 0) {
X bytes -= n;
X buf += n;
X ttl += n;
X continue;
X }
X return(-1);
X }
X return(ttl);
X}
X
X/*
X * Convert to and from 68000 longword format. Of course, it really
X * doesn't matter what format you use, just as long as it is defined.
X */
X
Xntohl68(n)
Xulong n;
X{
X return(
X (((ubyte *)&n)[0] << 24)|
X (((ubyte *)&n)[1] << 16)|
X (((ubyte *)&n)[2] << 8)|
X (((ubyte *)&n)[3])
X );
X}
X
Xhtonl68(n)
Xulong n;
X{
X ulong v;
X ((ubyte *)&v)[0] = n >> 24;
X ((ubyte *)&v)[1] = n >> 16;
X ((ubyte *)&v)[2] = n >> 8;
X ((ubyte *)&v)[3] = n;
X return(v);
X}
X
X
XDoOption(ac, av, ops, args)
Xshort ac;
Xchar *av[];
Xchar *ops;
Xlong args;
X{
X register short i;
X short j;
X
X for (i = j = 1; i < ac; ++i) {
X register char *ptr = av[i];
X if (*ptr != '-') {
X av[j++] = av[i];
X continue;
X }
X while (*++ptr) {
X register char *op;
X long **ap = (long **)&args;
X short isshort;
X
X for (op = ops; *op && *op != *ptr;) {
X if (*op == *ptr)
X break;
X if (*++op == '%') {
X while (*op && *op != 's' && *op != 'd')
X ++op;
X if (*op)
X ++op;
X }
X if (*op == ',') /* optional , */
X ++op;
X ++ap;
X }
X if (*op == 0)
X return(-1);
X if (op[1] != '%') {
X *(short *)*ap = 1;
X ++ap;
X continue;
X }
X op += 2;
X isshort = 1;
X while (*op && *op != 's' && *op != 'd') {
X switch(*op) {
X case 'h':
X isshort = 1;
X break;
X case 'l':
X isshort = 0;
X break;
X default:
X return(-1);
X }
X ++op;
X }
X switch(*op) {
X case 's':
X if (ptr[1]) {
X *(char **)*ap = ptr + 1;
X ptr = "\0";
X } else {
X *(char **)*ap = av[++i];
X }
X break;
X case 'd':
X if (isshort)
X *(short *)*ap = atoi(++ptr);
X else
X *(long *)*ap = atoi(++ptr);
X while (*ptr >= '0' && *ptr <= '9')
X ++ptr;
X break;
X default:
X return(-1);
X }
X }
X }
X return(j);
X}
X
Xelog(how, ctl, arg)
Xchar *ctl;
Xlong arg;
X{
X char *dir = getenv("DNETDIR");
X FILE *fi;
X char buf[256];
X long dtime;
X
X time(&dtime);
X
X if (!dir)
X dir = "";
X sprintf(buf, "%s%s", dir, "DNET.LOG");
X if (fi = fopen(buf, "a")) {
X strcpy(buf, ctime(&dtime));
X buf[strlen(buf)-1] = 0;
X fprintf(fi, "%s ", buf);
X fprintf(fi, ctl, arg);
X putc('\n', fi);
X fclose(fi);
X }
X if (how == EFATAL)
X exit(1);
X}
X
SHAR_EOF
echo "extracting lib/Makefile"
sed 's/^X//' << \SHAR_EOF > lib/Makefile
X
X
Xdnetlib.o : dnetlib.c
X cc -c dnetlib.c
X
SHAR_EOF
if `test ! -d server`
then
mkdir server
echo "mkdir server"
fi
echo "extracting server/sgcopy.c"
sed 's/^X//' << \SHAR_EOF > server/sgcopy.c
X
X/*
X * SGCOPY.C V1.1
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
X *
X * GET-COPY SERVER (NEW COPY SERVER)
X *
X * The current version only accepts one connection at a time. This server
X * will send requested files to the remote machine.
X *
X * length in 68000 longword format.
X */
X
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <sys/wait.h>
X#include <sys/time.h>
X#include <sys/dir.h>
X#include <sys/file.h>
X#include <sys/resource.h>
X#include <stdio.h>
X#include <errno.h>
X#include <signal.h>
X
X#include "servers.h"
X
Xtypedef struct {
X char Cmd;
X char Str[64];
X long Val;
X} HDR;
X
Xtypedef unsigned char ubyte;
Xchar *getnamepart();
Xchar *getdirpart();
X
Xchar Buf[4096];
Xint Chan;
X
Xchandler()
X{
X union wait stat;
X struct rusage rus;
X while (wait3(&stat, WNOHANG, &rus) > 0);
X}
X
Xmain(ac,av)
Xchar *av[];
X{
X long chann = DListen(PORT_GFILECOPY);
X int fd;
X int n;
X char buf[256];
X extern int errno;
X
X if (av[1])
X chdir(av[1]);
X signal(SIGCHLD, chandler);
X signal(SIGPIPE, SIG_IGN);
X for (;;) {
X fd = DAccept(chann);
X if (fd < 0) {
X if (errno == EINTR)
X continue;
X break;
X }
X if (fork() == NULL) {
X SGCopy(fd);
X _exit(1);
X }
X close(fd);
X }
X perror("SCOPY");
X}
X
XSGCopy(fd)
Xint fd;
X{
X short error = 0;
X static HDR Hdr;
X
X Chan = fd;
X error = WriteHeader('H', "Hello, GCopy server V1.30", 0);
X if (error)
X return(error);
X switch(ReadHeader(&Hdr)) {
X default:
X case -1:
X error = 1;
X return(error);
X case 'H':
X break;
X }
X while (!error) {
X switch(ReadHeader(&Hdr)) {
X case 'G':
X {
X char svdir[1024];
X getwd(svdir);
X if (chdir(getdirpart(Hdr.Str)) < 0) {
X error = WriteHeader('N', "Unable to cd to dir", 0);
X } else {
X error = PutObject(getnamepart(Hdr.Str));
X }
X chdir(svdir);
X }
X break;
X case 'E':
X goto done;
X case 'P': /* put-files, not implemented */
X default:
X error = 1;
X break;
X }
X }
Xdone:
X ;
X}
X
XPutObject(str)
Xchar *str;
X{
X struct stat stat;
X short error = 0;
X
X if (lstat(str, &stat) < 0) {
X error = WriteHeader('N', "Unable to find object", 0);
X return(0);
X }
X if (stat.st_mode & S_IFDIR) {
X error = PutDir(str);
X } else {
X error = PutFile(str);
X }
X return(0);
X}
X
XPutDir(name)
Xchar *name;
X{
X struct stat stat;
X char svdir[1024];
X static HDR Hdr;
X short error = 0;
X char *fn = getnamepart(name);
X DIR *dir;
X struct direct *de;
X
X if (lstat(name, &stat) < 0 || !(dir = opendir(name))) {
X WriteHeader('N', "Possible Disk Error", 0);
X error = 1;
X goto done;
X }
X if (error = WriteHeader('D', fn, 0))
X goto done;
X switch(ReadHeader(&Hdr)) {
X case 'Y':
X break;
X case 'S':
X goto done;
X case 'N':
X error = 1;
X break;
X default:
X error = 1;
X break;
X }
X if (error)
X goto done;
X
X getwd(svdir);
X if (chdir(name) < 0) {
X error = 1;
X WriteHeader('N', "unable to chdir", 0);
X }
X if (error)
X goto done;
X
X while (de = readdir(dir)) {
X if (strcmp(de->d_name, ".") == 0)
X continue;
X if (strcmp(de->d_name, "..") == 0)
X continue;
X if (lstat(de->d_name, &stat) < 0) {
X continue;
X }
X if (stat.st_mode & S_IFDIR) {
X error = PutDir(de->d_name);
X } else {
X error = PutFile(de->d_name);
X }
X if (error)
X break;
X }
X WriteHeader('E', NULL, 0);
X chdir(svdir);
Xdone:
X return(error);
X}
X
XPutFile(name)
Xchar *name;
X{
X int fd = -1;
X static HDR Hdr;
X long len;
X short error = 0;
X char *fn = getnamepart(name);
X
X fd = open(fn, O_RDONLY, 0);
X if (fd < 0) { /* don't do anything if unable to open it */
X WriteHeader('N', "file not readable", 0);
X goto done;
X }
X len = lseek(fd, 0L, 2);
X if (error = WriteHeader('F', fn, len))
X goto done;
X switch(ReadHeader(&Hdr)) {
X case 'Y':
X lseek(fd, Hdr.Val, 0); /* start pos. */
X len -= Hdr.Val;
X if (len < 0)
X len = 0;
X break;
X case 'S':
X goto done;
X case 'N':
X error = 1;
X break;
X default:
X error = 1;
X break;
X }
X if (error)
X goto done;
X while (len) {
X register long n = (len > sizeof(Buf)) ? sizeof(Buf) : len;
X
X if (read(fd, Buf, n) != n) { /* read failed! */
X error = 10;
X goto done;
X }
X if (gwrite(Chan, Buf, n) != n) {
X error = 10;
X goto done;
X }
X len -= n;
X }
Xdone:
X if (fd >= 0)
X close(fd);
X return(error);
X}
X
X
XWriteHeader(c, str, len)
Xchar c;
Xchar *str;
Xlong len;
X{
X ubyte sl;
X
X if (str == NULL)
X str = "";
X sl = strlen(str);
X
X if (gwrite(Chan, &c, 1) < 0)
X return(1);
X if (gwrite(Chan, &sl,1) < 0)
X return(1);
X if (gwrite(Chan, str, sl) != sl)
X return(1);
X len = htonl68(len);
X if (gwrite(Chan, &len, 4) != 4)
X return(1);
X return(0);
X}
X
XReadHeader(hdr)
XHDR *hdr;
X{
X ubyte sl;
X ubyte cmd;
X
X hdr->Cmd = -1;
X if (ggread(Chan, &cmd, 1) != 1)
X return(-1);
X if (ggread(Chan, &sl, 1) != 1)
X return(-1);
X if (sl >= sizeof(hdr->Str)) {
X return(-1);
X }
X if (ggread(Chan, hdr->Str, sl) != sl)
X return(-1);
X hdr->Str[sl] = 0;
X if (ggread(Chan, &hdr->Val, 4) != 4)
X return(-1);
X hdr->Val = ntohl68(hdr->Val);
X hdr->Cmd = cmd;
X return(hdr->Cmd);
X}
X
Xchar *
Xgetnamepart(str)
Xchar *str;
X{
X register char *ptr = str + strlen(str);
X
X while (ptr >= str) {
X if (*ptr == '/')
X break;
X --ptr;
X }
X return(ptr+1);
X}
X
Xchar *
Xgetdirpart(str)
Xchar *str;
X{
X static char buf[1024];
X
X strcpy(buf, str);
X getnamepart(buf)[0] = 0;
X if (buf[0] == 0)
X return(".");
X return(buf);
X}
SHAR_EOF
echo "extracting server/sshell.c"
sed 's/^X//' << \SHAR_EOF > server/sshell.c
X
X/*
X * S_SHELL.C OBSOLETE OBSOLETE OBSOLETE
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X *
X * Connect a csh to a pseudo terminal pair... PORT_ALPHATERM
X * NOTE!! PORT_IALPHATERM (a pseudo-terminal csh) is also available
X * through the FTERM client program on the Amiga side, and much faster
X * since the server for PORT_IALPHATERM is DNET itself (one less process
X * to go through).
X *
X * -doesn't handle SIGWINCH
X * -doesn't handle flow control ... don't cat any long files!
X */
X
X#include <stdio.h>
X#include <sys/wait.h>
X#include <sys/time.h>
X#include <sys/resource.h>
X#include <errno.h>
X#include <signal.h>
X
X#include "servers.h"
X
Xchandler()
X{
X union wait stat;
X struct rusage rus;
X while (wait3(&stat, WNOHANG, &rus) > 0);
X}
X
Xmain(ac,av)
Xchar *av[];
X{
X long chann = DListen(PORT_ALPHATERM);
X int fd;
X int n;
X char buf[256];
X extern int errno;
X
X if (av[1])
X chdir(av[1]);
X signal(SIGCHLD, chandler);
X signal(SIGPIPE, SIG_IGN);
X for (;;) {
X fd = DAccept(chann);
X if (fd < 0) {
X if (errno == EINTR)
X continue;
X break;
X }
X if (fork() == NULL) {
X dup2(fd, 0);
X dup2(fd, 1);
X dup2(fd, 2);
X close(fd);
X execl("/usr/ucb/rlogin", "rlogin", "localhost", NULL);
X exit(1);
X }
X close(fd);
X }
X perror("SSHELL");
X}
X
SHAR_EOF
echo "extracting server/sloadav.c"
sed 's/^X//' << \SHAR_EOF > server/sloadav.c
X
X/*
X * SLOADAV.C
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X *
X * Reports the load average every 5 minutes or until the connection
X * is closed.
X */
X
X#include <stdio.h>
X#include <sys/wait.h>
X#include <sys/time.h>
X#include <sys/resource.h>
X#include <errno.h>
X#include <signal.h>
X
X#include "servers.h"
X
Xchandler()
X{
X union wait stat;
X struct rusage rus;
X while (wait3(&stat, WNOHANG, &rus) > 0);
X}
X
Xmain(ac,av)
Xchar *av[];
X{
X long chann = DListen(PORT_LOADAV);
X int fd;
X int n;
X char buf[256];
X extern int errno;
X
X if (av[1])
X chdir(av[1]);
X signal(SIGCHLD, chandler);
X signal(SIGPIPE, SIG_IGN);
X for (;;) {
X fd = DAccept(chann);
X if (fd < 0) {
X if (errno == EINTR)
X continue;
X break;
X }
X if (fork() == NULL) {
X do_loadav(fd);
X close(fd);
X _exit(1);
X }
X close(fd);
X }
X perror("SLOADAV");
X}
X
Xdo_loadav(fd)
X{
X char dummy;
X char buf[256];
X FILE *fi;
X
X while (ggread(fd, &dummy, 1) == 1) {
X fi = popen("uptime", "r");
X if (fi == NULL)
X break;
X if (fgets(buf, 256, fi)) {
X dummy = strlen(buf);
X buf[dummy-1] = 0;
X gwrite(fd, &dummy, 1);
X gwrite(fd, buf, dummy);
X }
X if (ferror(fi))
X break;
X pclose(fi);
X }
X}
X
SHAR_EOF
echo "extracting server/scopy.c"
sed 's/^X//' << \SHAR_EOF > server/scopy.c
X
X/*
X * SCOPY.C
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X *
X * Remote file copy server (putfiles is the client program)
X */
X
X#include <sys/types.h>
X#include <sys/stat.h>
X#include <sys/wait.h>
X#include <sys/time.h>
X#include <sys/file.h>
X#include <sys/resource.h>
X#include <stdio.h>
X#include <errno.h>
X#include <signal.h>
X
X#include "servers.h"
X#include "../lib/dnetlib.h"
X
Xchar Buf[4096];
X
Xchandler()
X{
X union wait stat;
X struct rusage rus;
X while (wait3(&stat, WNOHANG, &rus) > 0);
X}
X
Xmain(ac,av)
Xchar *av[];
X{
X long chann = DListen(PORT_FILECOPY);
X int fd;
X int n;
X char buf[256];
X extern int errno;
X
X elog(EDEBUG, "SCOPY START", 0);
X if (av[1])
X chdir(av[1]);
X signal(SIGCHLD, chandler);
X signal(SIGPIPE, SIG_IGN);
X for (;;) {
X fd = DAccept(chann);
X if (fd < 0) {
X if (errno == EINTR)
X continue;
X break;
X }
X elog(EDEBUG, "SCOPY CONNECT", 0);
X if (fork() == NULL) {
X putdir(fd, ".");
X _exit(1);
X }
X close(fd);
X }
X perror("SCOPY");
X}
X
Xputdir(chan, dirname)
Xchar *dirname;
X{
X struct stat stat;
X char olddir[256];
X char co, nl, name[128];
X long len;
X int ret = -1;
X
X getwd(olddir);
X if (lstat(dirname, &stat) >= 0 && !(stat.st_mode & S_IFDIR)) {
X char rc = 'N';
X gwrite(chan, &rc, 1);
X elog(EWARN, "SCOPY: Unable to cd to dir '%s'", dirname);
X return(1);
X }
X if (chdir(dirname) < 0) {
X if (mkdir(dirname, 0777) < 0 || chdir(dirname) < 0) {
X char rc = 'N';
X elog(EWARN, "SCOPY: Unable to create directory '%s'", dirname);
X gwrite(chan, &rc, 1);
X return(1);
X }
X }
X co = 'Y';
X gwrite(chan, &co, 1);
X while (ggread(chan, &co, 1) == 1) {
X if (ggread(chan, &nl, 1) != 1 || ggread(chan, name, nl) != nl)
X break;
X if (ggread(chan, &len, 4) != 4)
X break;
X len = ntohl68(len);
X switch(co) {
X case 'C':
X co = 'Y';
X if (chdir(name) < 0) {
X if (mkdir(name, 0777) < 0 || chdir(name) < 0) {
X co = 'N';
X elog(EWARN, "SCOPY: Unable to create directory '%s'",
X dirname);
X }
X }
X gwrite(chan, &co, 1);
X break;
X case 'W':
X if (putfile(chan, name, len) < 0) {
X ret = -1;
X elog(EWARN, "SCOPY: Failure on file %.*s", len, name);
X goto fail;
X }
X break;
X case 'X':
X if (putdir(chan, name) < 0) {
X ret = -1;
X goto fail;
X }
X break;
X case 'Y':
X ret = 1;
X co = 'Y';
X gwrite(chan, &co, 1);
X goto fail;
X default:
X co = 'N';
X gwrite(chan, &co, 1);
X break;
X }
X }
Xfail:
X chdir(olddir);
X return(ret);
X}
X
Xputfile(chan, name, len)
Xchar *name;
X{
X long fd = open(name, O_WRONLY|O_CREAT|O_TRUNC, 0666);
X long n, r;
X char rc;
X
X if (fd < 0) {
X rc = 'N';
X gwrite(chan, &rc, 1);
X return(0);
X }
X rc = 'Y';
X gwrite(chan, &rc, 1);
X while (len) {
X r = (len > sizeof(Buf)) ? sizeof(Buf) : len;
X n = ggread(chan, Buf, r);
X if (n != r)
X break;
X if (write(fd, Buf, n) != n)
X break;
X len -= n;
X }
X close(fd);
X if (len) {
X unlink(name);
X return(-1);
X }
X rc = 'Y';
X gwrite(chan, &rc, 1);
X return(0);
X}
X
SHAR_EOF
echo "extracting server/Makefile"
sed 's/^X//' << \SHAR_EOF > server/Makefile
X
X# DNET SERVERS
X#
X#
X# DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X
XNETLIB = ../lib/dnetlib.o
XBIN = ../bin
X
X
Xall: $(NETLIB) $(BIN)/scopy $(BIN)/sshell \
X $(BIN)/sloadav $(BIN)/sgcopy
X
X$(BIN)/scopy: scopy.o
X cc scopy.o $(NETLIB) -o $(BIN)/scopy
X
X$(BIN)/sgcopy: sgcopy.o
X cc sgcopy.o $(NETLIB) -o $(BIN)/sgcopy
X
X$(BIN)/sshell: sshell.o
X cc sshell.o $(NETLIB) -o $(BIN)/sshell
X
X$(BIN)/sloadav: sloadav.o
X cc sloadav.o $(NETLIB) -o $(BIN)/sloadav
X
Xclean:
X rm -f *.o make.out
X
SHAR_EOF
echo "extracting server/servers.h"
sed 's/^X//' << \SHAR_EOF > server/servers.h
X
X/*
X * SERVERS.H
X *
X * DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
X */
X
X#define PORT_FILECOPY 8192
X#define PORT_ALPHATERM 8193
X#define PORT_ECHO 8194
X#define PORT_IALPHATERM 8195
X#define PORT_AMIGATERM 8195
X#define PORT_AMIGASHELL 8196
X#define PORT_LOADAV 8197
X#define PORT_PRINTER 8198
X#define PORT_PASSWD 8199
X#define PORT_BBS 8200
X#define PORT_GFILECOPY 8201
X
X
SHAR_EOF
echo "End of archive 2 (of 2)"
# if you want to concatenate archives, remove anything after this line
exit