Path: utzoo!utgpu!jarvis.csri.toronto.edu!mailrus!ames!oliveb!sun!rishathra!page
From: page%rishathra@Sun.COM (Bob Page)
Newsgroups: comp.sources.amiga
Subject: v89i103:  dnet - networking code (unix side) v2.0, Part02/02
Message-ID: <101943@sun.Eng.Sun.COM>
Date: 29 Apr 89 02:38:19 GMT
Sender: news@sun.Eng.Sun.COM
Lines: 2495
Approved: page@sun.com

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 *)&ltc);
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, &ltc);
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