From 42336b017ba010d03c1db3c28c8549e5d97a1cd9 Mon Sep 17 00:00:00 2001
From: Bdale Garbee <bdale@gag.com>
Date: Mon, 19 May 2008 23:11:09 -0600
Subject: [PATCH 1/1] Imported Upstream version 5.1

---
 .eggrc           |  86 ++++
 Makefile         | 142 +++++++
 README           |  39 ++
 basket.c         | 837 +++++++++++++++++++++++++++++++++++++++
 basketrc.sample  |  10 +
 byteorder.h      |  64 +++
 crc16.c          |  68 ++++
 egg.c            | 996 +++++++++++++++++++++++++++++++++++++++++++++++
 eggrc.sample     |  86 ++++
 eggui.c          | 191 +++++++++
 eggui.h          |  29 ++
 errnos.h         |  62 +++
 examine.c        |  61 +++
 genlib.c         | 254 ++++++++++++
 genlib.h         |  75 ++++
 global.h         | 186 +++++++++
 hw_pear.c        | 241 ++++++++++++
 hwapi.h          |  53 +++
 ipproto.c        |  39 ++
 ipproto.h        |  17 +
 lecuyer.c        | 135 +++++++
 lecuyer.h        |   8 +
 network.c        | 368 +++++++++++++++++
 network.h        |  76 ++++
 reg.h            |  76 ++++
 reg_orion.c      | 306 +++++++++++++++
 reg_pear.c       | 232 +++++++++++
 reg_pseudo.c     | 134 +++++++
 regs.h           |  17 +
 regtable.h       |  13 +
 regtest.c        | 120 ++++++
 sample.basketrc  |  10 +
 sample.eggrc     |  86 ++++
 sample.pppscript |  30 ++
 storage.c        | 599 ++++++++++++++++++++++++++++
 storage.h        |  63 +++
 testmain.c       | 220 +++++++++++
 testudp.c        |  89 +++++
 usleep.c         |  77 ++++
 version.h        |   7 +
 xdsub.c          | 107 +++++
 41 files changed, 6309 insertions(+)
 create mode 100644 .eggrc
 create mode 100644 Makefile
 create mode 100644 README
 create mode 100644 basket.c
 create mode 100644 basketrc.sample
 create mode 100644 byteorder.h
 create mode 100644 crc16.c
 create mode 100644 egg.c
 create mode 100644 eggrc.sample
 create mode 100644 eggui.c
 create mode 100644 eggui.h
 create mode 100644 errnos.h
 create mode 100644 examine.c
 create mode 100644 genlib.c
 create mode 100644 genlib.h
 create mode 100644 global.h
 create mode 100644 hw_pear.c
 create mode 100644 hwapi.h
 create mode 100644 ipproto.c
 create mode 100644 ipproto.h
 create mode 100644 lecuyer.c
 create mode 100644 lecuyer.h
 create mode 100644 network.c
 create mode 100644 network.h
 create mode 100644 reg.h
 create mode 100644 reg_orion.c
 create mode 100644 reg_pear.c
 create mode 100644 reg_pseudo.c
 create mode 100644 regs.h
 create mode 100644 regtable.h
 create mode 100644 regtest.c
 create mode 100644 sample.basketrc
 create mode 100644 sample.eggrc
 create mode 100755 sample.pppscript
 create mode 100644 storage.c
 create mode 100644 storage.h
 create mode 100644 testmain.c
 create mode 100644 testudp.c
 create mode 100644 usleep.c
 create mode 100644 version.h
 create mode 100644 xdsub.c

diff --git a/.eggrc b/.eggrc
new file mode 100644
index 0000000..b8c44bc
--- /dev/null
+++ b/.eggrc
@@ -0,0 +1,86 @@
+# Configuration file for egg collection software
+# This specifies the egg configuration information, the contact
+# information for its basket(s), and initial data acquisition parameters.
+
+# Each line consists of a case-sensitive keyword and a series of
+# options.  Defined keywords are: 
+#
+#   EGG <name> <id> <ip addr> <primbasket> <conntype> <connival> <url>
+#
+# The primary basket <primbasket> is the name of the basket (defined
+# below) that should be contacted retrieve data from this Egg.
+# The connection type <conntype> is "PERM" (permanent) or "DND"
+# (dial-and-drop).  So far the code does not support the DND option.
+# The connection interval <connival> determines the time (in minutes)
+# between transmission attempts.  If specified, and not equal to
+# ".", <url> gives a URL (for example http://www.somesite.net/page.html)
+# which will be linked to the egg <name> in status reports.  Note that
+# this specification has meaning only in the .basketrc file.  For
+# compatibility, it is permitted in an .eggrc file, but is ignored.
+#
+#   BASKET <name> <ip addr>
+#
+# This entry tells us about the existence of a set of baskets.  The
+# basket named as primary is the one which will be contacted
+# initially. 
+#
+#   PROTOCOL <samprec> <secrec> <recpkt> <trialsz>
+#
+# Specify the default data collection protocol.  The arguments are 
+# <samprec> samples per record (1-10, though this should always be 5-10),
+# <secrec> seconds per records (1-3000),
+# <recpkt> records per packet (1-60), and 
+# <trialsz> bits per sample (32-255).
+#
+#   REG <type> <port> <baud>
+#
+# Specify hardware device.  Supported types include "PEAR" only at
+# this time.  Port is serial port number (e.g. 1 for /dev/ttyS1);
+# <baud> is baud rate.
+#
+#   NETUP <script> <args> ...
+#   NETDOWN <script> <args> ...
+#
+# Provide script files to be run to bring up and tear down the network
+# connection on demand.  These will only be used if connection type is
+# DND.
+
+#EGG halley 1 10.0.0.111 halley PERM 1
+#BASKET halley 10.0.0.111
+#EGG halley 1 10.0.0.111 mercury DND 3
+#BASKET mercury 10.0.0.125
+
+#EGG noosphere 28 128.112.35.133 noosphere PERM 1
+#BASKET noosphere 128.112.35.133
+
+#   diesse -> diesse
+#EGG diesse 37 193.8.230.134 diesse PERM 1
+#BASKET diesse 193.8.230.134
+
+#   noosphere -> diesse
+EGG noosphere 28 128.112.35.133 diesse PERM 1
+BASKET diesse 193.8.230.134
+
+#   throop -> diesse
+#EGG throop 1003 193.8.230.132 diesse PERM 1 http://www.fourmilab.ch/
+#BASKET diesse 193.8.230.134
+
+#   jura -> jura
+#EGG jura 1004 193.8.230.130 jura PERM 1 http://www.fourmilab.ch/
+#BASKET jura 193.8.230.130
+
+#   diesse -> noosphere
+#EGG diesse.fourmilab.ch 37 193.8.230.134 noosphere PERM 1
+#BASKET noosphere 128.112.35.133
+
+#EGG diesse 37 193.8.230.134 jura PERM 1
+#BASKET jura 193.8.230.130
+
+#BASKET tonga 209.157.90.137
+#BASKET tonga1 209.157.90.138
+PROTOCOL 10 10 6 200
+#REG PEAR 2 9600
+REG PSEUDO 1 9600
+#REG ORION 1 9600
+NETUP pppscript up
+NETDOWN pppscript down
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..e894eb5
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,142 @@
+
+#   Debug options you can define on the following line:
+
+#	-DALT_UI    --	Select an alternative user interface
+#			that doesn't require curses.  This allows
+#			running an egg even if there's a problem
+#			with terminal configuration.
+#
+#	-DDEBUG     --	General debug output
+#
+#	-DHEXDUMP   --	Dump network packets sent and received
+#			in hexadecimal, identifying the recipient
+#			or sender by IP address.  Handy when
+#			tracking down byte alignment problems.
+#
+#	-DNICE=x    --	Priority increment (positive value) which
+#			eggsh raises to while collecting data when
+#			run by super-user.  Default is 10.  Setting
+#			-DNICE=0 disables the priority adjustment
+#			mechanism.
+#
+#	-DNO_UI     --	Disable user interface in the egg.  This
+#			is handy when you want to watch other
+#			debug output.
+#
+#	-DPACKETDUMP -- Interpreted dump of packets.
+#
+#	-DSTORAGE_DEBUG  -- Debug output from storage.c database
+#			functions.
+#
+#	-DTESTPORT  --	Use EGGPORT = 2074, BASKETPORT = 2075.
+#			This permits testing an experimental
+#			version of eggsh and basket on a machine
+#			which is running production version(s)
+#			on the standard ports.
+#
+#	-DUSLEEP    --	Use a built-in emulation of usleep()
+#			based on setitimer() instead of the
+#			system library function (which may not
+#			exist on all flavours of Unix).
+
+#DEBUGOPTIONS = -DDEBUG -DPACKETDUMP -DTESTPORT -DHEXDUMP -DNO_UI -DSTORAGE_DEBUG
+
+#DEBUGOPTIONS = -DTESTPORT -DDEBUG -DPACKETDUMP -DNO_UI -DALT_UI
+
+#DEBUGOPTIONS = -DTESTPORT
+
+#DEBUGOPTIONS =
+
+#DEBUGOPTIONS = -DTESTPORT -DALT_UI -DNO_UI
+
+#DEBUGOPTIONS = -DDEBUG -DALT_UI -DNO_UI
+
+#DEBUGOPTIONS = -DDEBUG -DNO_UI -DHEXDUMP
+
+# Build for throop/Orion egg
+#DEBUGOPTIONS = -DNO_UI -DALT_UI -DDEBUG -DUSLEEP -DFLUSH
+
+# Current debug options
+#DEBUGOPTIONS = -DNO_UI -DALT_UI -DDEBUG -DTESTPORT
+
+DEBUGOPTIONS = -DREPORT=1 -DEGG_DYNAMIC
+
+#   For Linux with GCC
+CC = gcc
+PFLAGS = -g -ansi -Wall -DLinux -DUSLEEP -D_GNU_SOURCE
+LIBS = -lncurses
+
+#   For Solaris 2.6 with Sun compiler
+#CC = cc
+#PFLAGS = -g -DSolaris
+#LIBS = -lcurses -lsocket -lnsl
+
+#   Silicon Graphics Irix 5.3 with SGI compiler.  Yes
+#   we do define "Solaris" along with "Irix" for such a build.
+#CC = cc
+#PFLAGS = -g -DSolaris -DIrix -DUSLEEP
+#LIBS = -lcurses
+
+CFLAGS = $(PFLAGS) $(DEBUGOPTIONS)
+
+HWOBJ = reg_orion.o reg_pear.o reg_pseudo.o
+APPOBJ = storage.o network.o crc16.o genlib.o xdsub.o
+EGGOBJ = egg.o eggui.o lecuyer.o usleep.o
+BASKETOBJ = basket.o
+TESTOBJ = testmain.o
+
+PROGRAMS = eggsh basket regtest
+
+default: $(PROGRAMS)
+
+all: $(PROGRAMS) tarballs
+
+eggsh:	$(EGGOBJ) $(HWOBJ) $(APPOBJ)
+	$(CC) $(CFLAGS) -o eggsh $(EGGOBJ) $(HWOBJ) $(APPOBJ) $(LIBS)
+
+examine: $(APPOBJ) examine.o
+	$(CC) $(CFLAGS) -o examine storage.o crc16.o genlib.o examine.o
+
+basket: $(BASKETOBJ) $(APPOBJ)
+	$(CC) $(CFLAGS) -o basket $(BASKETOBJ) $(APPOBJ) $(LIBS)
+
+tarballs: $(PROGRAMS)
+	tar czf eggware.tgz sample.eggrc eggsh regtest README
+	tar czf eggsrc.tgz  sample.eggrc sample.basketrc $(PROGRAMS) README Makefile *.c *.h
+
+test:	eggsh
+	eggsh 1 9600 200 10 10
+
+clean:
+	rm -f $(PROGRAMS) *.o *.bak .*.bak core dumpreg.dat egg.status eggsample.pid
+
+cleandata:
+	rm -rf 199*-*
+
+basket.o: basket.c global.h genlib.h storage.h network.h version.h
+
+#collect.o: collect.c global.h genlib.h regs.h collect.h
+
+egg.o: egg.c global.h genlib.h storage.h network.h regs.h version.h
+
+eggui.o: eggui.c global.h genlib.h errnos.h eggui.h regs.h version.h
+
+global.h: byteorder.h
+
+hw_pear.o: hw_pear.c global.h genlib.h
+
+lecuyer.o: lecuyer.c
+
+network.o: network.c global.h genlib.h network.h
+
+regs.h: reg.h
+
+reg_orion.o: reg_orion.c reg.h
+
+reg_pear.o: reg_pear.c reg.h
+
+reg_pseudo.o: reg_pseudo.c reg.h lecuyer.h
+
+storage.o: storage.c global.h genlib.h storage.h
+
+usleep.o: usleep.c
diff --git a/README b/README
new file mode 100644
index 0000000..b2422ce
--- /dev/null
+++ b/README
@@ -0,0 +1,39 @@
+		      GCP (EGG) Software README
+
+    Setting up to host an egg for the Global Consciousness Project
+
+The experiment produces data and stores them on your local disk as well
+as shipping the data to the central server.  You will want to create a
+separate directory for the egg material.  If you have a computer sent
+from the GCP, the directory will be /home/egg. The software will create
+within that directory subdirectories to store the data.  The storage
+load is not large (see the architecture document on the website,
+http://noosphere.princeton.edu, for more detail.  After some months 
+you may wish to remove old data, but leave two or more months' data for
+backup.  
+
+The program you need to run is eggsh.  It uses a configuration file
+called .eggrc, and you must edit the line near the end to enter your IP
+address.  This should be a fixed IP address if possible, but the basket
+software can accept data from eggs at dynamic addresses.  A file called 
+sample.eggrc or eggrc.mod can be renamed to .eggrc if the .eggrc is not
+present.  The "joe" editor is relatively user-friendly.
+
+If the program does not run, you may need to recompile on your machine.
+There is a makefile.  Do make clean, then make.
+
+The sample .eggrc file specifies the first serial port, and if you are 
+using a different port, you must change that specification.
+
+The sample pppscript file assumes you will have a fixed IP.  You will
+have more appropriate pppscript and pppchat models at the time you are
+setting up.
+
+Let us know about ways to make this process simple and efficient.  Write
+down your experiences and difficulties, and send to us any useful notes 
+that can be part of the instructions for other hosts.
+
+Thanks
+
+RDN, last update: 99-03-14
+
diff --git a/basket.c b/basket.c
new file mode 100644
index 0000000..abd33c6
--- /dev/null
+++ b/basket.c
@@ -0,0 +1,837 @@
+/* PROGRAM:	basket
+ * FILE:	$Header: /home/egg/src/RCS/basket.c,v 1.8 1999/02/28 19:58:49 ghn Exp $
+ * PURPOSE:	Main program for basket software
+ * AUTHOR:	Greg Nelson
+ * DATE:	98-06-28
+ *
+ * REVISED:
+ * $Log: basket.c,v $
+ * Revision 1.8  1999/02/28 19:58:49  ghn
+ * Version 5.1: Support for ip address masks to allow us to limit egg
+ * spoofing to users on a limited subnet (cf. EGG_DYNAMIC).  Added
+ * flexible interface/port cmdline arguments and config file arguments.
+ * Report the eggs we are accepting.
+ *
+ * Revision 1.7  1999/01/01 23:52:31  ghn
+ * Allow basket to start with no net connection and handle connection
+ * going up and down.
+ *
+ * Revision 1.6  1998/12/31 22:07:56  ghn
+ * Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.5  1998/08/03 20:40:13  kelvin
+ * PACKETDUMP, SIGHUP reset when signal caught.
+ * 
+ * Revision 1.4  1998/08/01  18:52:49  ghn
+ * Added John's byte-order-independence changes.
+ *
+ * Revision 1.3  1998/08/01 17:02:05  ghn
+ * Incorporate John's Solaris fixes and terminate STAT lines properly.
+ *
+ * Revision 1.2  1998/07/21 11:44:04  ghn
+ * Added headers.
+ *
+ * Copyright 1998 - Greg Nelson
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include "global.h"
+#include "genlib.h"
+#include "storage.h"
+#include "network.h"
+#include "errnos.h"
+#include "version.h"
+
+#define EGGSTATS        "egg.status"
+
+static int32 BasketReceiveDataPacket(char *pktbuf, int16 isegg, int16 thisegg,
+			      struct sockaddr_in *rhost);
+static void MakeRequest(ReqPacket *pkt, uint16 eggid, uint32 whence);
+static void MakeSettings(SettingsPacket *pkt, uint16 eggid);
+static void LoadRCFile(void);
+static void LoadEggStats(void);
+static void SaveEggStats(void);
+static void handle_sighup(int arg);
+
+EggEntry eggtable[MAX_EGGS];
+BasketEntry baskettable[MAX_BASKETS];
+EggHeader protocol;
+
+short numeggs, numbaskets;
+char	*pgmname;		      /* Program name from argv[0] */
+char	*myaddr;		      /* Interface to bind */
+int16	myport;			      /* Service port to bind */
+
+static int htmlInterval = 0;	      /* HTML status file update interval in seconds */
+static char htmlFile[256] = "";       /* HTML status file name */
+static uint32 upsince = 0;	      /* Basket start time */
+#define htmlReport (htmlFile[0] != 0) /* Make HTML report ? */
+
+struct {
+    uint32 firstPacket;               /* Time of "first contact" with egg */
+    uint32 trials;		      /* Number of trials received */
+    uint32 missing;		      /* Number of missing samples */
+    double sum; 		      /* Sum of trials to date */
+} eggStatistics[MAX_EGGS];
+
+/*  updateHTML	--  Update HTML status file if a decent interval
+		    has passed since the last update.  */
+
+static void updateHTML(void)
+{
+    if (htmlReport) {
+	int i;
+	static uint32 lastHtml = 0;
+	uint32 now = getzulutime(NULL);
+	char udate[256], ustime[256];
+        static char timeFormat[] = "%Y-%m-%d %T";
+
+	/* When first called, set the last HTML update interval to
+	   the present moment.	This defers generation of the first
+	   HTML report until htmlInterval elapses.  This prevents
+	   issuing a potentially-misleading HTML report based on
+	   incomplete information. */
+
+	if (lastHtml == 0) {
+	    lastHtml = now;
+	}
+
+	if ((now - lastHtml) >= htmlInterval) {
+	    FILE *hf;
+
+	    lastHtml = now;
+            hf = fopen(htmlFile, "w");
+	    if (hf == NULL) {
+                fprintf(stderr, "Cannot open HTML status file %s.  Updates discarded.\n", htmlFile);
+		htmlFile[0] = 0;      /* Suppress further updates */
+		return;
+	    }
+
+	    strftime(udate, sizeof udate, timeFormat, gmtime((time_t *) &now));
+	    strftime(ustime, sizeof ustime, timeFormat, gmtime((time_t *) &upsince));
+
+            fprintf(hf, "\
+<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">\n\
+<html version=\"-//W3C//DTD HTML 3.2 Final//EN\">\n\
+<head>\n\
+<title>Basket %s Status Report</title>\n\
+<meta http-equiv=\"Refresh\" content=\"%d\">\n\
+</head>\n\
+<body>\n\
+<center>\n\
+<h1>Basket %s Status Report</h1>\n\
+<h3>Last update: %s UTC</h3>\n\
+<h4>Basket started at %s UTC<br>\n\
+%s</h4>\n\
+</center>\n\
+<center>\n\
+<h2>Egg Status</h2>\n\
+<table border cellpadding=4>\n\
+<tr><th>Name<th>Number<th>Up Since<th>Last Packet<th>Active\n\
+<th>Trials<th>Missed<th>Coverage<th>Mean\n\
+",
+	    baskettable[0].name, htmlInterval, baskettable[0].name, udate, ustime, Version);
+
+	    for (i = 0; i < numeggs; i++) {
+	      char url1[256], url2[256];
+
+	      if ((eggtable[i].lastupd == 0) || (eggStatistics[i].firstPacket == 0)) {
+                  strcpy(udate, "<td colspan=2 align=center><em>Never contacted</em>");
+                  strcpy(ustime, "");
+	      } else {
+                  strftime(udate, sizeof udate, "<td align=center>%Y-%m-%d %T", gmtime((time_t *) &eggtable[i].lastupd));
+                  strftime(ustime, sizeof ustime, "<td align=center>%Y-%m-%d %T", gmtime((time_t *) &eggStatistics[i].firstPacket));
+	      }
+	      if (eggtable[i].url == NULL) {
+		  url1[0] = url2[0] = 0;
+	      } else {
+                  sprintf(url1, "<a href=\"%s\">", eggtable[i].url);
+                  strcpy(url2, "</a>");
+	      }
+              fprintf(hf, "<tr><td>%s%s%s<td align=center>%d%s%s<td align=center>%s\n\
+",
+		      url1,
+		      eggtable[i].name,
+		      url2,
+		      eggtable[i].id,
+		      ustime,
+		      udate,
+                      eggtable[i].setup ? "Yes" : "No"
+	      );
+
+	      if (eggStatistics[i].trials == 0) {
+                  fprintf(hf, "<td align=center>&nbsp;<td align=center>&nbsp;<td align=center>&nbsp;<td align=center>&nbsp;\n");
+	      } else {
+		  uint32 coverage;
+
+                  /* The following expression computes "coverage" for
+		     the egg--the percentage of samples received
+		     to the number prescribed by the protocol
+		     for the time in which the egg has been in contact. */
+		  coverage = (100L * eggStatistics[i].trials * protocol.samp_rec) /
+		      (protocol.sec_rec * (now - eggStatistics[i].firstPacket));
+		  if (coverage > 100) {
+		      coverage = 100;
+		  }
+
+                  fprintf(hf, "<td align=center>%ld<td align=center>%ld<td align=center>%ld%%<td align=center>%.3f\n",
+			  eggStatistics[i].trials,
+			  eggStatistics[i].missing,
+			  coverage,
+			  eggStatistics[i].sum / eggStatistics[i].trials
+		  );
+	      }
+	    }
+
+
+            fprintf(hf, "\
+</table>\n\
+</center>\n\
+<center>\n\
+<h4>Egg Status Table Fields</h4>\n\
+<table width=\"75%%\" cellpadding=3>\n\
+<tr><td valign=top><b>Name</b> <td>Egg name<p>\n\
+<tr><td valign=top><b>Number</b> <td>Egg number.  Thousands digit indicates type of random event generator.<p>\n\
+<tr><td valign=top><b>Up Since</b> <td>Time and date in first packet received from egg since basket started.<p>\n\
+<tr><td valign=top><b>Last Packet</b> <td>Time and date of most recently received packet from egg.<p>\n\
+<tr><td valign=top><b>Active</b> <td>Has egg ever communicated with this basket since it was started?<p>\n\
+<tr><td valign=top><b>Trials</b> <td>Number of trials received from this egg.<p>\n\
+<tr><td valign=top><b>Missed</b> <td>Number of scheduled trials missed by egg due to synchronisation problems.<p>\n\
+<tr><td valign=top><b>Coverage</b> <td>Percent of trials collected from this egg since basket\n\
+    started compared to the number scheduled by the protocol.<p>\n\
+<tr><td valign=top><b>Mean</b> <td>Arithmetic mean of trials performed by this egg.\n\
+</table>\n\
+</center>\n\
+</body>\n\
+</html>\n");
+	    fclose(hf);
+#ifdef DEBUG
+            fprintf(stderr, "Updating HTML file %s at %s",
+		htmlFile, asctime(gmtime((time_t *) &now)));
+#endif
+	}
+    }
+}
+
+static void Usage(void) {
+  printf("Usage: %s [-i interface] [-p port]\n", pgmname);
+  exit(-1);
+}
+
+/*  Main program.  */
+
+int main(int argc, char *argv[]) {
+  char			*pktbuf;
+  uint16		pkttype, pktsize, pkt_eggid;
+  int			sdlisten, res;
+  struct sockaddr_in	rhost;
+  ReqPacket		rpkt;
+  SettingsPacket	spkt;
+  int			i, isbasket, isegg, thisegg;
+  char			*remname;
+#ifdef SIGACTION_WORKING
+  struct sigaction	sigact;
+#endif
+#ifdef EGG_DYNAMIC 
+  uint32		ipvalidate, ipmatch, ipmask;
+#endif
+
+  pgmname = argv[0];
+  argv++; argc--;
+
+  /* Defaults correspond to original usage */
+  myport = BASKETPORT;
+  myaddr = NULL;
+
+  while (argc) {
+    if (argv[0][0] == '-') {
+      switch(argv[0][1]) {
+      case 'i':	/* Specify interface */
+	if (argc < 2) Usage();
+	myaddr = argv[1];
+	argv++; argc--;
+	break;
+      case 'p':	/* Specify port */
+	if (argc < 2) Usage();
+	myport = atoi(argv[1]);
+	if (myport < 0) Usage();
+	argv++; argc--;
+	break;
+      default:	/* Oops. */
+	Usage();
+      }
+    } else {
+      Usage();
+    }
+    argv++; argc--;
+  }
+
+  LoadRCFile();
+  LoadEggStats();
+
+#ifdef Solaris
+  /* Solaris has an eccentric definition of sigaction() which
+     doesn't seem to even work according to Sun's own
+     documentation.  (sa_flags is a 4 element array of
+     unsigned longs, with no mention of how one stores the
+     flags into it.)  Let's just use plain old signal for
+     the moment. */
+  signal(SIGHUP, handle_sighup);
+#else
+#ifdef SIGACTION_WORKING
+  sigact.sa_handler = handle_sighup;
+  sigact.sa_mask = 0;
+  sigact.sa_flags = 0;
+  sigact.sa_restorer = NULL;
+  sigaction(SIGHUP, &sigact, NULL);
+#else
+  signal(SIGHUP, handle_sighup);
+#endif
+#endif
+
+  /* No connection at outset */
+  sdlisten = -1;
+
+  /* Initialize storage system. */
+  InitStorage("%Y-%m/%Y-%m-%d-$b");
+
+  upsince = getzulutime(NULL);
+
+  fprintf(stderr, "Starting basket %s.\n", Version);
+
+  /* Inner loop is currently single thread:
+     1A. Wait for connection.  When a connection comes in,
+	 packet has been decrypted and verified.
+     1B. Validate connection.
+     1C. Reply to connection. */
+  while (1) {
+    /* If no current listening connection, try to get one,
+       and if that fails, sleep and try later. */
+
+    if (sdlisten < 0) {
+      /* Get a listening socket at BASKETPORT.
+         Only allow our */
+      sdlisten = InitNetwork(myaddr, myport);
+      if (sdlisten < 0) {
+	sleep(1);
+	continue;
+      }
+    }
+
+    /* 1A. Wait for connection. */
+    res = NetListen(sdlisten, &pktbuf, &rhost, TRUE);
+    if (res < 0) {
+      fprintf(stderr, "NetListen error: %d\n", res);
+      continue;
+    }
+    
+    /* 1B. Validate connection. 
+       Remote host address is in rhost.  Make sure this is either an
+       egg or a basket, and set the flag appropriately. */
+#ifdef EGG_DYNAMIC
+    ipvalidate = ntohl(rhost.sin_addr.s_addr);
+#endif
+
+    isegg = isbasket = 0;
+    for (i = 0; i < numeggs; i++) {
+#ifdef EGG_DYNAMIC
+      /* When mask == 32:	ipmask = 0xFFFFFFFF (all significant)
+	      mask == 16:	ipmask = 0xFFFF0000 (only top half sig)
+	      mask ==  0:	ipmask = 0x00000000 (none significant) */
+      ipmask = (0xFFFFFFFF << (32-eggtable[i].netmask));
+      ipmatch = ntohl(eggtable[i].ipaddr.sin_addr.s_addr);
+      if ((ipvalidate & ipmask) == (ipmatch & ipmask)) {
+	isegg = eggtable[i].id;
+	thisegg = i;
+	remname = eggtable[i].name;
+      }      
+#else
+      if (!memcmp(&(rhost.sin_addr),
+		  &(eggtable[i].ipaddr.sin_addr),
+		  sizeof(rhost.sin_addr))) {
+	isegg = eggtable[i].id;
+	thisegg = i;
+	remname = eggtable[i].name;
+      }
+#endif
+    }
+    for (i = 0; i < numbaskets; i++) {
+      if (!memcmp(&(rhost.sin_addr),
+		  &(baskettable[i].ipaddr.sin_addr),
+		  sizeof(rhost.sin_addr))) {
+	isbasket = 1;
+	remname = baskettable[i].name;
+      }
+    }
+
+    if (!isegg && !isbasket) {
+      fprintf(stderr, "Attempt to connect from unknown source: %s\n",
+	      sockaddr2dquad(&rhost));
+      continue;
+    }
+
+    memcpy(&pkttype, pktbuf, sizeof(uint16));
+    memcpy(&pktsize, pktbuf+sizeof(uint16), sizeof(uint16));
+    pkttype = ntohs(pkttype);
+    pktsize = ntohs(pktsize);
+    if (pktsize < 6) {
+      fprintf(stderr, "Packet doesn't contain an egg id, why?\n");
+      continue;
+    }
+    pkt_eggid = ntohs(*((uint16 *) (pktbuf + 4)));
+
+    /* Am I hearing from who I think I am? */
+#if EGG_DYNAMIC
+    /* Have to assume the best case before testing: that the
+       pkt_eggid is actually correct. */
+    for (i = 0; i < numeggs; i++) if (eggtable[i].id == pkt_eggid) break;
+
+    if (i == numeggs) {
+      /* Must be a spoof, and possibly an attempt to crash software too. */
+      fprintf(stderr, "%s: Egg spoofing?  %s reporting itself as %d\n",
+	      pgmname, hl2dquad(ipvalidate), pkt_eggid);
+      continue;
+    }
+
+    ipmask = (0xFFFFFFFF << (32-eggtable[i].netmask));
+    ipmatch = ntohl(eggtable[i].ipaddr.sin_addr.s_addr);
+    if ((ipvalidate & ipmask) != (ipmatch & ipmask)) {
+      fprintf(stderr, "%s: Egg spoofing?  %s reporting itself as %d\n",
+	      pgmname, hl2dquad(ipvalidate), pkt_eggid);
+      continue;
+    } else {
+      isegg = eggtable[i].id;
+      thisegg = i;
+      remname = eggtable[i].name;
+    }      
+#else
+    if (isegg != pkt_eggid) {
+      fprintf(stderr, "%s: Egg spoofing?  %d reporting itself as %d\n",
+	      pgmname, isegg, pkt_eggid);
+      continue;
+    }
+#endif
+
+    /* 1D. Reply to connection. */
+    switch(pkttype) {
+    case DATA_PACKET:
+      /* Put it away. */
+      BasketReceiveDataPacket(pktbuf, isegg, thisegg, &rhost);
+
+      break;
+    case REQ_PACKET:
+      /* Is this how baskets communicate? */
+      break;
+    case AWAKE_PACKET:
+#ifdef PACKETDUMP
+      {
+	uint32 egg_now_time;
+
+	memcpy(&egg_now_time, pktbuf + 6, sizeof egg_now_time);
+	egg_now_time = ntohl(egg_now_time);
+	fprintf(stderr, "Awake egg %d (%s) at its %lu: %s",
+		pkt_eggid, eggtable[thisegg].name, egg_now_time,
+		asctime(gmtime((time_t *) &egg_now_time)));
+      }
+#endif
+
+      /* Calculate last data received from this egg, decide what
+	 to ask for. */
+      MakeRequest(&rpkt, isegg, eggtable[thisegg].lastupd);
+      rhost.sin_port = htons(EGGPORT);
+      res = NetTalk(&rhost, (char *)&rpkt, TRUE);
+      if (res < 0) fprintf(stderr, "NetTalk error %d.\n", res);
+
+      /* If setup looks like it's out of date, correct it. */
+      if (!eggtable[thisegg].setup) {
+	MakeSettings(&spkt, thisegg);
+	rhost.sin_port = htons(EGGPORT);
+	res = NetTalk(&rhost, (char *)&spkt, TRUE);
+        if (res < 0) fprintf(stderr, "NetTalk error %d.\n", res);
+      }
+      break;
+
+    case SETTINGS_PACKET:
+      /* I don't have settings, Bozo. */
+      break;
+    }
+    free(pktbuf);
+  }
+}
+
+/*  handle_sighup  --  Catch SIGHUP and reload configuraton files.  */
+
+static void handle_sighup(int arg) {
+  /* Reread the RC file */
+  LoadRCFile();
+  LoadEggStats();
+#ifdef DEBUG
+  fprintf(stderr, "Received SIGHUP: reloading configuration files.\n");
+#endif
+#ifndef SIGACTION_WORKING
+  signal(SIGHUP, handle_sighup);      /* Reset signal handler for bottom-feeder signal() */
+#endif
+}
+
+/*  LoadRCFile	--  Load basket configuration file.  */
+
+static void LoadRCFile(void) {
+  FILE *fp;
+  char linebuf[200];
+  char *myargv[MAX_PARSE], *tp;
+  int myargc, lcount, p, i;
+
+  if ((fp = fopen(".basketrc", "r")) == NULL) {
+    if ((fp = fopen("~/.basketrc", "r")) == NULL) {
+      if ((fp = fopen("/etc/basketrc", "r")) == NULL) {
+        fprintf(stderr, "%s: Couldn't find a basket RC file.\n", pgmname);
+	exit(-1);
+      }
+    }
+  }
+
+  numeggs = numbaskets = 0;
+  lcount = 0;
+
+  while(fgets(linebuf, 200, fp) != NULL) {
+    /* Comments and blank lines ignored. */
+    lcount++;
+    if (*linebuf == '#' || *linebuf == '\n') continue;
+    Parse(linebuf, &myargc, myargv);
+    if (myargc == 0) continue;
+    if (!strcmp(myargv[0], "EGG")) {
+      if (myargc < 7 || myargc > 8) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+	
+      eggtable[numeggs].name = mallocpy(myargv[1]);
+      eggtable[numeggs].id = atoi(myargv[2]);
+      dquad2sockaddr(&(eggtable[numeggs].ipaddr), 
+		     &(eggtable[numeggs].netmask),
+		     myargv[3]);
+      eggtable[numeggs].primbasket = mallocpy(myargv[4]);
+      eggtable[numeggs].conntype = (!strcmp(myargv[5], "PERM"))?CONN_PERM:CONN_DND;
+      eggtable[numeggs].connival = atoi(myargv[6]);
+      eggtable[numeggs].url = NULL;
+      if ((myargc > 7) && (strcmp(myargv[7], ".") != 0)) {
+	eggtable[numeggs].url = mallocpy(myargv[7]);
+      }
+      numeggs++;
+    } else if (!strcmp(myargv[0], "BASKET")) {
+      if (myargc != 3) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+      baskettable[numbaskets].name = mallocpy(myargv[1]);
+      dquad2sockaddr(&(baskettable[numbaskets].ipaddr), NULL, myargv[2]);
+      numbaskets++;
+    } else if (!strcmp(myargv[0], "PROTOCOL")) {
+      if (myargc != 5) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+      protocol.samp_rec = atoi(myargv[1]);
+      protocol.sec_rec = atoi(myargv[2]);
+      protocol.rec_pkt = atoi(myargv[3]);
+      protocol.trialsz = atoi(myargv[4]);
+    } else if (!strcmp(myargv[0], "HTML")) {
+      if (myargc != 3) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+      htmlInterval = atoi(myargv[1]);
+      strcpy(htmlFile, myargv[2]);
+#ifdef DEBUG
+      fprintf(stderr, "Updating HTML file %s every %d seconds.\n", htmlFile, htmlInterval);
+#endif
+    } else if (!strcmp(myargv[0], "PORT") ||
+	       !strcmp(myargv[0], "INTERFACE")) {
+      if (myargc != 2) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+      tp = (char *) malloc(200);
+      for (*tp = 0, p = 1; p < myargc; p++) {
+	strcat(tp, myargv[p]);
+        if (p < myargc-1) strcat(tp, " ");
+      }
+
+      if (!strcmp(myargv[0], "PORT")) {
+	if (atoi(tp) <= 0) {
+	  fprintf(stderr, "%s: RC error, ignoring bad port %d, using %d\n",
+		  pgmname, atoi(tp), myport);
+	} else {
+	  myport = atoi(tp);
+	}
+	free(tp);
+      } else if (!strcmp(myargv[0], "INTERFACE")) myaddr = tp;
+    } else {
+      fprintf(stderr, "%s: RC error, %s is unknown keyword\n", pgmname, myargv[0]);
+      exit(-1);
+    }
+  }
+  fclose(fp);
+
+#if REPORT > 0
+  /* Report a list of the eggs that we are accepting. */
+  for (i = 0; i < numeggs; i++) {
+    fprintf(stderr, "Egg %2d:\tid = %4d\tip=%s/%d\n", 
+	    i, eggtable[i].id, 
+	    sockaddr2dquad(&(eggtable[i].ipaddr)),
+	    eggtable[i].netmask);
+  }
+#endif
+}
+
+/*  BasketReceiveDataPacket  --  Process a data packet received frm an egg.  */
+
+static int32 BasketReceiveDataPacket(char *pkt, int16 isegg, int16 thisegg,
+			      struct sockaddr_in *rhost) {
+  EggHeader		*dpktp;
+  EggCarton		result;
+  ReqPacket		rpkt;
+  uint16		offset, rec;
+  uint32		latest;
+  int32 		res;
+#ifdef DEBUG
+  uint16		i;
+#endif
+
+  EggHeader dpk;
+  char *pktP = pkt;
+  
+  /* Unpack the portable header into a host-order and aligned
+     EggHeader packet. */
+  
+  dpktp = &dpk;
+  unpackShort(dpk.type);
+  unpackShort(dpk.pktsize);
+  unpackShort(dpk.eggid);
+  unpackShort(dpk.samp_rec);
+  unpackShort(dpk.sec_rec);
+  unpackShort(dpk.rec_pkt);
+  unpackByte(dpk.trialsz);
+  unpackShort(dpk.numrec);
+
+  /* This spoofing test is probably completely redundant now. */
+#ifndef EGG_DYNAMIC      
+  /* Am I hearing from an egg, and is it who I think it is? */
+  if (isegg && isegg != dpktp->eggid) {
+    fprintf(stderr, "%s: Egg spoofing?  %d reporting itself as %d\n",
+	    pgmname, isegg, dpktp->eggid);
+    return -1;
+  }
+#endif
+
+  /* Save the packet header in the result EggCarton buffer. */
+
+  memcpy(&(result.hdr), dpktp, sizeof(EggHeader));
+  offset = sizeof(EggHeader);
+
+#ifdef DEBUG
+  {
+    uint32 stamp = 0;
+    char *spktp = pktP;
+
+    if (result.hdr.numrec > 0) {
+      unpackLong(stamp);
+    }
+    pktP = spktp;
+    fprintf(stderr, "Received packet: %d records from egg %d (%s).\n",
+      result.hdr.numrec, dpktp->eggid, eggtable[thisegg].name);
+  }
+#endif
+
+  /* Unpack the individual data records from the packet and
+     transcribe to the result EggCarton.  */
+  
+  for (latest = 0, rec = 0; rec < result.hdr.numrec; rec++) {
+    unpackLong(result.records[rec].timestamp);	 /* Record timestamp */
+    if (result.records[rec].timestamp > latest)
+      latest = result.records[rec].timestamp;
+#ifdef DEBUG
+    fprintf(stderr, "  %10lu  ", result.records[rec].timestamp);
+#endif
+    /* Assumes sizeof(trial) = 1 */
+    unpackBytes(&(result.records[rec].trials), result.hdr.samp_rec);
+#ifdef DEBUG
+    for (i = 0; i < result.hdr.samp_rec; i++) {
+      fprintf(stderr, "%3d ", result.records[rec].trials[i]);
+    }
+    fprintf(stderr, "%s", asctime(gmtime((time_t *) &result.records[rec].timestamp)));
+#endif
+  }
+
+  /* Save the packet in the basket database file. */
+  
+  if ((res = SavePacket(&result)) < 0) return res;
+
+  /* If we're generating an HTML report, update the per-basket
+     statistics based on the content of this packet. */
+
+  if (htmlReport) {
+      int r, t;
+      uint32 ptrials = 0, psum = 0, dropped = 0;
+
+      /* Update the egg status for HTML report. */
+
+      for (r = 0; r < result.hdr.rec_pkt; r++) {
+	  for (t = 0; t < result.hdr.samp_rec; t++) {
+	      if (result.records[r].trials[t] != EGG_MISSING_DATA) {
+		  ptrials++;
+		  psum += result.records[r].trials[t];
+	      } else {
+		  dropped++;
+	      }
+	  }
+      }
+      eggStatistics[thisegg].trials += ptrials;
+      eggStatistics[thisegg].sum += psum;
+
+      /* If this is the first packet received from the egg, and
+         the first sample in it is missing, don't count missing
+         samples against this egg, since it's probable this is
+	 the first packet collected since the egg started, which
+	 will contain initial missing samples for time before the
+	 egg started. */
+
+      if (eggStatistics[thisegg].firstPacket != 0) {
+	  eggStatistics[thisegg].missing += dropped;
+      } else {
+	  eggStatistics[thisegg].firstPacket = result.records[0].timestamp;
+      }
+  }
+
+  if (latest > eggtable[thisegg].lastupd) {
+    eggtable[thisegg].lastupd = latest;
+    SaveEggStats();
+    updateHTML();		      /* Update HTML status file, if warranted */
+    if (latest < getzulutime(NULL)) {
+      /* Get more data if it looks like there should be more. */
+      MakeRequest(&rpkt, isegg, eggtable[thisegg].lastupd);
+      rhost->sin_port = htons(EGGPORT);
+      res = NetTalk(rhost, (char *)&rpkt, TRUE);
+      if (res < 0) fprintf(stderr, "NetTalk error %d.\n", (int)res);
+    }
+  }
+
+  /* If the protocol now in effect differs from that of the
+     packet just received from the egg, mark the egg as not
+     set-up, and thus in need of a SETTINGS_PACKET to reset
+     its protocol. */
+
+  eggtable[thisegg].setup = (protocol.samp_rec == dpktp->samp_rec &&
+			     protocol.sec_rec == dpktp->sec_rec &&
+			     protocol.rec_pkt == dpktp->rec_pkt &&
+			     protocol.trialsz == dpktp->trialsz);
+
+  return ERR_NONE;
+}
+
+/*  MakeRequest  --  Assemble a request packet for a given egg,
+		     specifying, in whence, the time and date
+		     of the last sample received from that egg.  */
+
+static void MakeRequest(ReqPacket *pkt, uint16 eggid, uint32 whence) {
+  char *pktP = (char *) pkt;
+
+  packShort(REQ_PACKET);
+  packShort((4 * sizeof(uint16)) + sizeof(uint32));
+  packShort(eggid);
+  packLong(whence);
+}
+
+/*  MakeSettings  --  Create a settings packet.  This packet,
+		      sent periodically to connected eggs,
+		      informs them of any change in protocol.  */
+
+static void MakeSettings(SettingsPacket *pkt, uint16 eggid) {
+  char *pktP = (char *) pkt;
+
+  packShort(SETTINGS_PACKET);
+  packShort((7 * sizeof(uint16)) + sizeof(uint32) + sizeof(trial));
+  packShort(eggid);
+  packLong(getzulutime(NULL));
+  packShort(protocol.samp_rec);
+  packShort(protocol.sec_rec);
+  packShort(protocol.rec_pkt);
+  packByte(protocol.trialsz);
+}
+
+/*  LoadEggStats  --  Initialise in-memory egg status table
+		      from the EGGSTATS file.  */
+
+static void LoadEggStats(void) {
+  FILE *fp;
+  char linebuf[200], *myargv[MAX_PARSE], *name;
+  int i, f, myargc, id, setup;
+  int32 lastupd;
+
+  /* Default stats */
+  for (i = 0; i < numeggs; i++) {
+    eggtable[i].lastupd = 0;
+    eggtable[i].setup = 0;
+  }
+  
+  if ((fp = fopen(EGGSTATS, "r")) == NULL) return;
+  
+  while(fgets(linebuf, 200, fp) != NULL) {
+    /* Comments and blank lines ignored. */
+    if (*linebuf == '#' || *linebuf == '\n') continue;
+    Parse(linebuf, &myargc, myargv);
+    if (myargc == 0) continue;
+    if (!strcmp(myargv[0], "STAT") && myargc == 5) {
+      name = myargv[1];
+      id = atoi(myargv[2]);
+      lastupd = atol(myargv[3]);
+      setup = atoi(myargv[4]);
+      for (f = 0, i = 0; i < numeggs; i++) {
+	if (eggtable[i].id == id &&
+	    !strcmp(eggtable[i].name, name)) {
+	  eggtable[i].lastupd = lastupd;
+	  eggtable[i].setup = setup;
+	  f = 1;
+	}
+      }
+      if (!f) fprintf(stderr, "%s: Egg '%s' no longer hosted.\n", pgmname, name);
+    }
+  }
+  fclose(fp);
+}
+
+/*  SaveEggStats  --  Dump in-memory egg status to the EGGSTATS file.  */
+
+static void SaveEggStats(void) {
+  FILE *fp;
+  int i;
+
+  if ((fp = fopen(EGGSTATS, "w")) == NULL) {
+    /* Couldn't write stats! */  
+    fprintf(stderr, "%s: Couldn't save egg stats!\n", pgmname);
+    return;
+  }
+
+  fprintf(fp, "# Status lines of form:\n");
+  fprintf(fp, "#   STAT <eggname> <eggid> <lastupdzulu> <setupvalid>\n");
+  for (i = 0; i < numeggs; i++) {
+    fprintf(fp, "STAT %s %d %ld %d\n",
+	    eggtable[i].name,
+	    eggtable[i].id,
+	    eggtable[i].lastupd,
+	    eggtable[i].setup);
+  }
+  fclose(fp);
+}
diff --git a/basketrc.sample b/basketrc.sample
new file mode 100644
index 0000000..09da1e6
--- /dev/null
+++ b/basketrc.sample
@@ -0,0 +1,10 @@
+#BASKET diesse 193.8.230.134
+#BASKET jura 193.8.230.130
+BASKET noosphere 128.112.35.133
+EGG diesse 37 193.8.230.134 diesse PERM 1 http://www.fourmilab.ch/
+EGG noosphere 28 128.112.35.133 noosphere PERM 1 http://noosphere.princeton.edu/
+EGG throop 1003 193.8.230.132 throop PERM 1
+EGG jura 1004 193.8.230.130 jura PERM 1
+EGG dicklnx.psy.uva.nl 1000 145.18.117.41 diesse PERM 1 http://www.psy.uva.nl/bierman
+PROTOCOL 10 10 6 200
+HTML 60 /ftp/entrenous/k/basket.html
diff --git a/byteorder.h b/byteorder.h
new file mode 100644
index 0000000..6071e53
--- /dev/null
+++ b/byteorder.h
@@ -0,0 +1,64 @@
+/*
+
+	Byte-order invariant definitions
+
+*/
+
+/*  The following macros allow packing fields of various types
+    into a byte-oriented packet with a running pointer named
+    pktP.  The reason we store then memcpy rather than storing
+    through a cast of pktP to the desired type is that the
+    latter approach can result in alignment faults when run
+    on RISC machines which typically require values to be
+    aligned at an even multiple of their length.  */
+
+#define packShort(x) { \
+			short s = htons((short) (x)); \
+			memcpy(pktP, &s, sizeof(short)); \
+			pktP += sizeof(short); \
+		     }
+
+#define packLong(x) { \
+			long l = htonl((long) (x)); \
+			memcpy(pktP, &l, sizeof(long)); \
+			pktP += sizeof(long); \
+		    }
+
+#define packByte(x) { \
+			char c = (x); \
+			memcpy(pktP, &c, sizeof(char)); \
+			pktP += sizeof(char); \
+		    }
+
+#define packBytes(x, n) { \
+			    memcpy(pktP, x, n); \
+			    pktP += n; \
+			}
+
+/*  These macros unpack fields of various lengths from a
+    byte-packet packet in network byte order pointed to by
+    pktP.  Note that the argument of these macros must be
+    an lvalue.	*/
+
+#define unpackShort(x) { \
+			    short s; \
+			    memcpy(&s, pktP, sizeof(short)); \
+			    pktP += sizeof(short); \
+			    x = ntohs(s); \
+		       }
+
+#define unpackLong(x) { \
+			   long l; \
+			   memcpy(&l, pktP, sizeof(long)); \
+			   pktP += sizeof(long); \
+			   x = ntohl(l); \
+		      }
+
+#define unpackByte(x) { \
+			*((char *) &x) = (char) *pktP++; \
+		      }
+
+#define unpackBytes(x, n) { \
+			    memcpy(x, pktP, n); \
+			    pktP += n; \
+			  }
diff --git a/crc16.c b/crc16.c
new file mode 100644
index 0000000..fb4649f
--- /dev/null
+++ b/crc16.c
@@ -0,0 +1,68 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/crc16.c,v 1.1 1998/07/21 11:42:15 ghn Exp $
+ * PURPOSE:     Functions to calculate CRC checksum
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-04-12
+ *
+ * REVISED:     $Log: crc16.c,v $
+ * REVISED:     Revision 1.1  1998/07/21 11:42:15  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#include "global.h"
+
+/* Calculate 16 bit CRC checksum on specified block */
+
+#define TBLSIZE		256
+#define CRC16_POLY	0xA001
+#define CRC16_INIT	0
+
+uint16 CRC16Table[TBLSIZE] = {
+  0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
+  0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440,
+  0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40,
+  0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841,
+  0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40,
+  0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41,
+  0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641,
+  0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040,
+  0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240,
+  0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441,
+  0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41,
+  0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840,
+  0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41,
+  0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40,
+  0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640,
+  0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041,
+  0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
+  0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441,
+  0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41,
+  0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840,
+  0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41,
+  0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40,
+  0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640,
+  0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041,
+  0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241,
+  0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440,
+  0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40,
+  0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841,
+  0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40,
+  0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41,
+  0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641,
+  0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040};
+  
+uint16 BlockCRC16(byte *block, uint32 len) {
+  uint16 crc;
+  uint32 i, indx;
+
+  crc = CRC16_INIT;
+  for (i = 0; i < len; i++) {
+    indx = (uint8)(*block++ ^ crc);
+    crc >>= 8;
+    crc ^= CRC16Table[indx];
+  }
+  return crc;
+}
diff --git a/egg.c b/egg.c
new file mode 100644
index 0000000..84786c5
--- /dev/null
+++ b/egg.c
@@ -0,0 +1,996 @@
+/* PROGRAM:	eggsh
+ * FILE:	$Header: /home/egg/src/RCS/egg.c,v 1.8 1999/02/28 20:01:43 ghn Exp $
+ * PURPOSE:	EGG site data collection
+ * AUTHOR:	Greg Nelson
+ * DATE:	98-06-20
+ *
+ * REVISED:
+ * $Log: egg.c,v $
+ * Revision 1.8  1999/02/28 20:01:43  ghn
+ * Version 5.1: Added command line parsing for interface/port configuration.
+ * Changed default interface to 0.0.0.0, so that egg will normally bind to
+ * all incoming interfaces.  Reports interface/port it is using, right before
+ * the screen gets cleared and you can't see it.
+ *
+ * Revision 1.7  1999/01/01 23:57:20  ghn
+ * Remove excess code associated with CPU-bound version and "OLDWAY" UI
+ * and egg HW selection. Add back in updated block algorithm description.
+ * Allow non-CPU-bound version to exchange more than 1 packet per second.
+ * Get rid of warnings when network is not reachable, assuming this is a
+ * transient error.
+ *
+ * Revision 1.6  1998/12/31 22:07:56  ghn
+ * Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.5  1998/08/03 20:35:55  kelvin
+ * PACKETDUMP support.
+ * 
+ * Revision 1.4  1998/08/01  21:34:26  ghn
+ * Connected user interface and added PSEUDO suppor into main line.
+ *
+ * Revision 1.3  1998/08/01 18:51:25  ghn
+ * Added John's byte-order-independence changes.
+ * 
+ * Revision 1.2  1998/08/01 17:04:26  ghn
+ * Lots of fixes from John, plus DND support.
+ * 
+ * Revision 1.1  1998/07/21 11:41:35  ghn
+ * Initial revision
+ * 
+ * Copyright 1998 - Greg Nelson
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+
+#include "global.h"
+#include "genlib.h"
+#include "storage.h"
+#include "network.h"
+#include "eggui.h"
+#include "errnos.h"
+#include "regs.h"
+#include "regtable.h"
+#include "version.h"
+
+/* Good old Linux doesn't define the following functions
+   by default in the #include files the manual page claims
+   it does, and the conditional declarations with __USE_xx
+   doesn't work.  Explicitly declare them, which doesn't
+   seem to do any harm on systems where these functions are
+   properly declared.  If you get errors on the following
+   declarations, you can probably get around them by #ifdef-ing
+   the declarations off for your platform. */
+
+extern int nice(int inc);
+extern int strcasecmp(const char *s1, const char *s2);
+
+/*  Prototypes for forward functions.  */
+
+static void MakeAwake(AwakePacket *pkt);
+static void MakeDataPkt(char **pkt, EggCarton *src);
+static void LoadRCFile(char *filename);
+static double SetCollOpts(void);
+static int GreetBasket(void);
+static void handle_sigkill(int arg), handle_sighup(int arg);
+
+EggEntry eggtable[MAX_EGGS];
+BasketEntry baskettable[MAX_BASKETS];
+EggHeader protocol;
+REG_driver *configuredREG = NULL;     /* Configured REG driver */
+
+short numeggs = 0, numbaskets = 0;
+
+static DevOpts devopts; 	      /* Device options for REG */
+static CollectRecord coll;
+static EggCarton savebuffer;
+char	*pgmname;		      /* Program name from argv[0] */
+char	*myaddr;		      /* Interface to bind */
+int16	myport;			      /* Service port to bind */
+int32 lastDataSent = 0; 	      /* Time last packet sent to basket */
+
+/* If no priority increment has been specified at compile time, set to
+   our default of ±10. [+/- 10, for folks without 8bit editors] */
+
+#ifndef NICE
+#define NICE	10
+#endif
+static int niceness = NICE;	      /* Priority increment/decrement for collection */
+
+/* Status exported to user interface. */
+
+int32 time_latency = 0, time_housekeeping = 0;
+
+#ifdef ALT_UI
+static double mean_Packet = 0.0, mean_Grand = 0.0;
+static int32 total_Packets = 0;
+#endif
+
+/*  resetCarton  --  Clear existing data from savebuffer and
+		     reinitialise for a sampling interval
+		     beginning at the specified start_time.  */
+
+static void resetCarton(uint32 start_time)
+{
+    int i;
+    uint32 sec_pkt;
+
+    /* Save current collection options to packet. */
+
+    memcpy(&(savebuffer.hdr), &(coll.opts), sizeof(EggHeader));
+
+    /* Set number of records in packet and clear record
+       buffers to missing data. */
+
+    savebuffer.hdr.numrec = savebuffer.hdr.rec_pkt; /* Mark all records present */
+
+    /* Align start_time to even multiple of seconds per
+       packet. */
+
+    sec_pkt = savebuffer.hdr.sec_rec * savebuffer.hdr.rec_pkt;
+    start_time = sec_pkt * (start_time / sec_pkt);
+
+    for (i = 0; i < savebuffer.hdr.rec_pkt; i++) {
+	savebuffer.records[i].timestamp = start_time;
+	start_time += savebuffer.hdr.sec_rec;
+#if MAXBITS < 256
+	memset(savebuffer.records[i].trials, EGG_MISSING_DATA, MAXSAMP_REC);
+#else
+#error "Can't represent MAXBITS in a byte value."
+#endif
+    }
+}
+
+/*  saveProtocol  --  Save current protocol in the .eggprotocolrc file.  */
+
+static void saveProtocol(void)
+{
+    FILE *rcfile;
+
+    rcfile = fopen(".eggprotocolrc", "w");
+    if (rcfile == NULL) {
+        fprintf(stderr, "%s: Cannot create .eggprotocolrc file.\n", pgmname);
+	exit(-1);
+    }
+    fprintf(rcfile, "#\n#  Current protocol for egg\n#\n");
+    fprintf(rcfile, "#   PROTOCOL <samp_rec> <sec_rec> <rec_pkt> <trialsz>\n");
+    fprintf(rcfile, "PROTOCOL %d %d %d %d\n", protocol.samp_rec, protocol.sec_rec,
+	protocol.rec_pkt, protocol.trialsz);
+    fclose(rcfile);
+}
+
+static void Usage(void) {
+  printf("Usage: %s [-i interface] [-p port]\n", pgmname);
+  exit(-1);
+}
+
+/*  Main program.  */
+
+int main(int argc, char *argv[]) {
+  char			*pktbuf, *outpktbuf;
+  uint16		pkttype, pktsize;
+  int			sdlisten, res;
+  struct sockaddr_in	rhost;
+  EggCarton		retrcart;
+  int			i, isbasket;
+  char			*remname;
+  int32 		lastconn, lastsend;
+  double		sps;
+#ifdef SIGACTION_WORKING
+  struct sigaction	sigact;
+#endif
+  FILE *pidfile, *rcfile;
+
+  pgmname = argv[0];
+  argv++; argc--;
+
+  /* Defaults correspond to original usage */
+  myport = EGGPORT;
+  myaddr = "0.0.0.0";
+
+  while (argc) {
+    if (argv[0][0] == '-') {
+      switch(argv[0][1]) {
+      case 'i':	/* Specify interface */
+	if (argc < 2) Usage();
+	myaddr = argv[1];
+	argv++; argc--;
+	break;
+      case 'p':	/* Specify port */
+	if (argc < 2) Usage();
+	myport = atoi(argv[1]);
+	if (myport < 0) Usage();
+	argv++; argc--;
+	break;
+      default:	/* Oops. */
+	Usage();
+      }
+    } else {
+      Usage();
+    }
+    argv++; argc--;
+  }
+
+#ifdef Solaris
+  /* Solaris has an eccentric definition of sigaction() which
+     doesn't seem to even work according to Sun's own
+     documentation.  (sa_flags is a 4 element array of
+     unsigned longs, with no mention of how one stores the
+     flags into it.)  Let's just use plain old signal for
+     the moment. */
+  signal(SIGKILL, handle_sigkill);
+  signal(SIGHUP, handle_sighup);
+#else
+#ifdef SIGACTION_WORKING
+  sigact.sa_handler = handle_sigkill;
+  sigact.sa_mask = 0;
+  sigact.sa_flags = 0;
+  sigact.sa_restorer = NULL;
+  sigaction(SIGKILL, &sigact, NULL);
+
+  sigact.sa_handler = handle_sighup;
+  sigaction(SIGHUP, &sigact, NULL);
+#else
+  signal(SIGKILL, handle_sigkill);
+  signal(SIGHUP, handle_sighup);
+#endif
+#endif
+
+  fprintf(stderr, "Starting egg %s.\n", Version);
+
+  /* Save our process ID in a file for folks who might wish
+     to send us a signal. */
+
+  pidfile = fopen("eggsample.pid", "w");
+  if (pidfile == NULL) {
+    fprintf(stderr, "Unable to create eggsample.pid file.\n");
+    exit(-1);
+  }
+  fprintf(pidfile, "%d\n", getpid());
+  fclose(pidfile);
+
+  /* If we aren't being run by the super-user, disable the
+     priority raising and lowering mechanism. */
+
+  if (getuid() != 0) {
+    niceness = 0;
+  }
+
+#ifdef DEBUG
+  printf("User ID = %d.  Niceness = %d.\n", getuid(), niceness);
+  printf("REG drivers installed: ");
+  for (i = 0; reg_table[i] != NULL; i++) {
+    printf(" %s", reg_table[i]->reg_name);
+  }
+  printf("\n");
+#endif
+
+  LoadRCFile(NULL);
+
+  /* If an auxiliary configuration file exists, load it on
+     top of the arguments loaded from the main RC file.  If
+     it doesn't exist, create it. */
+
+  if ((rcfile = fopen(".eggprotocolrc", "r")) != NULL) {
+    fclose(rcfile);
+    LoadRCFile(".eggprotocolrc");
+  } else {
+    saveProtocol();
+  }
+
+  if (configuredREG == NULL) {
+    fprintf(stderr, "%s: RC error, no REG specified for egg.\n",
+	pgmname);
+    exit(-1);
+  }
+#ifdef DEBUG
+    else {
+    printf("REG configured: %s = %d, %d, %ld\n", configuredREG ->reg_name,
+	devopts.type, devopts.port, devopts.baud);
+  }
+#endif
+
+
+  sps = SetCollOpts();
+
+  if ((coll.dd = OpenDev(&devopts)) < 0) {
+    fprintf(stderr, "Couldn't talk to hardware device.\n");
+    exit(1);
+  }
+
+  if (EvalSpeed(coll.dd) < coll.opts.trialsz * sps) {
+    fprintf(stderr, "Requested speed exceeds device capabilities.\n");
+    exit(-1);
+  }
+
+#if REPORT > 0
+  if (myaddr) {
+    fprintf(stderr, "TCP configured: %s.%d\n", myaddr, myport);
+  } else {
+    fprintf(stderr, "TCP configured: hostname.%d\n", myport);
+  }
+#endif
+
+  UIInit();
+
+  sdlisten = -1;	/* No conn yet. */
+  lastconn = lastsend = 0;
+
+  /* Initialise carton to zero time, indicating no data in
+     initial carton. */
+  resetCarton(0);
+
+  /* Initialize storage system */
+  InitStorage("%Y-%m/%Y-%m-%d-$06E");
+
+  /* Inner loop is currently two threads which are both processed
+     together through NBIO.
+
+     2A. Adjust priority and sleep until time computed below (2H).
+     2B. Busy wait until second ticks over.
+     2C. Empty REG input buffer (if needed), then collect sample.
+     2D. Lower priority to handle bookkeeping; save packet.
+     2E. Update user interface.
+
+     2F. Send awake packet if connival is passed.
+     2G. [DND only] Put net to sleep if we've been waiting more than a minute
+
+     1A. Wait for connection.  When a connection comes in,
+	 packet has been decrypted and verified.
+     1B. Validate connection.
+     1C. Reply to connection.
+     1D. If we have more than MINSLEEP time left in second,
+         go back to 1A.
+
+     2H. Compute new sleep time.
+  */
+
+  while (1) {
+    static int sleeptime = 0;
+    static struct timeval t, lt = {0, 0};
+    struct timeval ct;
+    trial sample;
+    int havedata;
+    uint32 rindex;
+#ifdef DEBUG
+    uint32 msec, usec;
+#endif
+
+#ifndef SLACK
+#define SLACK	50000		      /* CPU loop resynchronisation time in microseconds */
+#endif
+
+#ifndef	MINSLEEP
+#define MINSLEEP	100000		/* Minimum sleep time, usec */
+#endif
+
+    /* 2A. If we have successfully computed a sleep time until
+       the window opens to collect the next sample, give up
+       the CPU until that time arrives. */
+
+    if (niceness != 0) {
+	nice(-niceness);	      /* Raise priority for re-dispatch */
+    }
+    if (sleeptime > 0) {
+	Usleep((unsigned) sleeptime);
+    }
+
+    /* 2B. We're now close to the start of the next second.  Watch the
+       time until the second changes, then collect the next sample.
+       Note that this method of doing things enforces the one
+       sample/second that has become standard practise.  The code at
+       the bottom of the loop could be changed to allow for a longer
+       interval, but this code enforces a minimum of a 1-second change
+       for each sample. */
+
+    while (1) {
+      gettimeofday(&t, NULL);
+      if (lt.tv_sec == 0) lt.tv_sec = t.tv_sec;
+      if (t.tv_sec != lt.tv_sec) break;
+    }
+
+    /* 2C. It is now time to collect the next sample.  Discard any
+       any data in the input queue and get the sample.	*/
+
+    Discard(coll.dd);
+    sample = Sample(coll.dd, coll.opts.trialsz);
+    if (niceness != 0) {
+      nice(niceness); 	      /* Collection done.  Lower priority to normal. */
+    }
+
+    /* 2D. Okay, we're now in "quality time"--the slack after collection
+       of a sample until the time for the next sample arrives.
+       Now is an excellent time to do all kinds of housekeeping.
+       First of all, see if the sample just collected fits into
+       the packet currently being assembled.  If not, we need to
+       save the last packet in the egg data file and initialise
+       a new packet for the time period in which this sample was
+       collected. */
+
+    if ((savebuffer.records[0].timestamp == 0) ||
+	((savebuffer.records[0].timestamp +
+	  (savebuffer.hdr.sec_rec * savebuffer.hdr.rec_pkt)) <= t.tv_sec)) {
+
+      if (savebuffer.records[0].timestamp != 0) {
+	static int firstpacket = 1;
+#ifdef ALT_UI
+	int r, t;
+	uint32 ptrials = 0, psum = 0;
+	static uint32 totalTrials = 0;
+	static double totalGrand = 0.0;
+#endif
+
+	/* Sample isn't within current packet.  Dump packet to the egg
+	   data file and reinitialise to the window containing the
+	   sample we just collected.  But first, a little gimmick.  If
+	   this is the first packet we've collected and it contains
+	   one or more missing samples at the beginning, discard it.
+	   This keeps the routine missing samples in the first packet
+	   after the egg starts up from being reported as missing
+	   samples due to genuine synchronisation errors. */
+
+	if (!(firstpacket && (savebuffer.records[0].trials[0] == EGG_MISSING_DATA))) {
+	  SavePacket(&savebuffer);
+	}
+#ifdef DEBUG
+	else {
+	  fprintf(stderr, "Dropping first packet to discard start-up missing samples.\n");
+	}
+#endif
+	firstpacket = 0;
+
+#ifdef ALT_UI
+	/* Update the last packet and grand mean data for the debug
+	   interface status display. */
+
+	for (r = 0; r < savebuffer.hdr.rec_pkt; r++) {
+	  for (t = 0; t < savebuffer.hdr.samp_rec; t++) {
+	    if (savebuffer.records[r].trials[t] != EGG_MISSING_DATA) {
+	      ptrials++;
+	      psum += savebuffer.records[r].trials[t];
+	    }
+	  }
+	}
+	mean_Packet = ((double) psum) / ptrials;
+	totalGrand += psum;
+	totalTrials += ptrials;
+	mean_Grand = totalGrand / totalTrials;
+	total_Packets++;
+	printf("Packets sent: %ld  Packet mean: %6.2f  Grand mean: %6.2f\n",
+		total_Packets, mean_Packet, mean_Grand);
+#endif
+      }
+
+      /* Check for change to the collection parameters...
+	 now is the time to implement it. */
+
+      if (coll.opts.rec_pkt != protocol.rec_pkt ||
+	  coll.opts.trialsz != protocol.trialsz ||
+	  coll.opts.sec_rec != protocol.sec_rec ||
+	  coll.opts.samp_rec != protocol.samp_rec) {
+	sps = SetCollOpts();
+	saveProtocol();
+      }
+      /* Reinitialise carton to interval containing sample */
+      resetCarton(t.tv_sec);
+    }
+
+    /* Store the sample into the carton, which is now guaranteed to
+       bracket the interval in which it was collected. */
+
+#ifdef DEBUG
+    /* But let's be sure it really *is* in the interval. */
+    if (t.tv_sec < savebuffer.records[0].timestamp ||
+	t.tv_sec >= (savebuffer.records[0].timestamp + savebuffer.hdr.sec_rec * savebuffer.hdr.rec_pkt)) {
+      fprintf(stderr, "***Sample, collected at %ld, is not within packet starting at %ld.\n",
+	      t.tv_sec, savebuffer.records[0].timestamp);
+      exit(-1);
+    }
+#endif
+
+    rindex = t.tv_sec - savebuffer.records[0].timestamp;
+    savebuffer.records[rindex / savebuffer.hdr.sec_rec].trials[rindex % savebuffer.hdr.sec_rec] = sample;
+
+    /* 2E. Update user interface. */
+
+#ifndef NO_UI
+    coll.data.trials[coll.sampct] = sample;
+    coll.sampct++;
+    UIUpdate(coll.sampct >= coll.opts.samp_rec, &coll);
+
+    if (coll.sampct >= coll.opts.samp_rec) {
+	coll.sampct = 0;
+    }
+#endif
+
+    /* Now that the current sample has been dealt which, check
+       for egg-initiated actions whose time has come.  */
+
+    /* 2F. First of all, it it's time to prod the basket with an
+       awake packet, lob one over the pole. */
+
+    if (getzulutime(NULL) - lastconn > (eggtable[0].connival * 60L)) {
+      lastsend = lastconn = getzulutime(NULL);
+      
+      /* If this is a dial-and-drop egg, connect to the network before
+	 sending the packet. */
+
+      if (sdlisten < 0 && eggtable[0].conntype == CONN_DND) {
+	sdlisten = NetUp(eggtable[0].upcmd, myaddr, myport);
+      }
+      
+      GreetBasket();
+    }
+    
+    /* 2G. If this is a dial-and-drop egg and it's been more than a
+       minute since we sent anything, tear down the network connection. */
+    
+    if (eggtable[0].conntype == CONN_DND && sdlisten >= 0) {
+      if ((getzulutime(NULL) - lastsend) > 60L) {
+	NetDown(eggtable[0].dncmd, sdlisten);
+	sdlisten = -1;
+      }
+    }
+
+    /* Now deal with basket-initiated requests received on the socket
+       since the last time around the loop.  To improve throughput for
+       dialup connections, we may come back here several times if we
+       have more data and if time allows.  */
+
+    do {
+      havedata = 0;	/* Don't loop unless net activity happens. */
+
+      /* 1A. Wait for connection. */
+      if (eggtable[0].conntype == CONN_PERM) {
+	if (sdlisten < 0) {
+	  /* Initialize networking, get a listening socket at EGGPORT */
+	  sdlisten = InitNetwork(myaddr, myport);
+	}
+      }
+      if (sdlisten >= 0) {
+	res = NetListen(sdlisten, &pktbuf, &rhost, FALSE);
+	if (res < 0 && res != ERR_COMM_TMOUT) {
+	  fprintf(stderr, "NetListen error: %d\n", res);
+	  break;	/* Out of do loop */
+	}
+	/* Data present, process networking thread */
+	if (res == ERR_NONE) {
+	  /* 1B. Validate connection. 
+	     Remote host address is in rhost.  Make sure this is either an
+	     egg or a basket, and set the flag appropriately. */
+	  isbasket = 0;
+	  for (i = 0; i < numbaskets; i++) {
+	    if (!memcmp(&(rhost.sin_addr),
+			&(baskettable[i].ipaddr.sin_addr),
+			sizeof(rhost.sin_addr))) {
+	      isbasket = 1;
+	      remname = baskettable[i].name;
+	    }
+	  }
+	  
+	  if (!isbasket) {
+	    fprintf(stderr, "Attempt to connect from unknown source: %s",
+		    sockaddr2dquad(&rhost));
+	    break;	/* Out of do loop */
+	  }
+
+	  havedata = 1;	/* Initial assumption, until disproven. */
+	  
+	  memcpy(&pkttype, pktbuf, sizeof(uint16));
+	  memcpy(&pktsize, pktbuf+sizeof(uint16), sizeof(uint16));
+	  pkttype = ntohs(pkttype);
+	  pktsize = ntohs(pktsize);
+	  
+	  /* 1C. Reply to connection. */
+	  switch(pkttype) {
+	  case DATA_PACKET:
+	  case AWAKE_PACKET:
+	    /* Not acceptable at an eggsite. */
+	    fprintf(stderr, "%s: EGG could not accept %d packet\n", 
+		    pgmname, pkttype);
+	    break;
+	    
+	    /* Request for data from a basket. */
+	    
+	  case REQ_PACKET:
+	    {
+	      uint16 reggid;
+	      uint32 stime;
+	      char *pktP = pktbuf + (2 * sizeof(uint16));
+	      
+	      unpackShort(reggid);
+	      unpackLong(stime);
+#ifdef PACKETDUMP
+	      fprintf(stderr, "Request: eggid = %d, starttm = %ld: %s",
+		      reggid, stime, asctime(gmtime((time_t *) &stime)));
+#endif
+	      res = LoadPacket(stime, reggid, &retrcart);
+	    }
+	    if (res == ERR_NONE) {
+	      /* NetPacketize it */
+	      MakeDataPkt(&outpktbuf, &retrcart);
+	      rhost.sin_port = htons(BASKETPORT);
+	      res = NetTalk(&rhost, outpktbuf, TRUE);
+	      if (res < 0) {
+		fprintf(stderr, "NetTalk failed (%d)\n", res);
+	      }
+	      free(outpktbuf);
+	      lastDataSent = lastsend = getzulutime(NULL);
+	    } else if (res == ERR_EOF) {
+	      /* End of data.  If DND, bring down connection */
+	      if (eggtable[0].conntype == CONN_DND) {
+		NetDown(eggtable[0].dncmd, sdlisten);
+		sdlisten = -1;
+	      }
+	      havedata = 0;
+	    }
+	    break;
+	    
+	  case SETTINGS_PACKET:
+	    /* Update settings in buffer, will change at next packet
+	       boundary. */
+	    
+	    { char *pktP = pktbuf + (3 * sizeof(uint16)) + sizeof(uint32);
+	    
+	    unpackShort(protocol.samp_rec);
+	    unpackShort(protocol.sec_rec);
+	    unpackShort(protocol.rec_pkt);
+	    unpackByte(protocol.trialsz);
+	    }
+#ifdef PACKETDUMP
+	    fprintf(stderr, "Settings: samp_rec = %d, sec_rec = %d, rec_pkt = %d, trialsz = %d\n",
+		    protocol.samp_rec, protocol.sec_rec, protocol.rec_pkt, protocol.trialsz);
+#endif
+	    break;
+	  }
+	  free(pktbuf);
+	}
+      }
+      gettimeofday(&ct, NULL);
+    } while (havedata && ct.tv_usec < 1000000L - MINSLEEP);
+
+    /* 2H. Compute the length in microseconds we should sleep before
+       the top of the next second.  Note that we compute the interval
+       based on the time at the bottom of the loop, after dealing with
+       whatever housekeeping requests may have been performed since
+       collecting the last sample. */
+
+    gettimeofday(&ct, NULL);
+    if (lt.tv_sec == 0) {
+	lt.tv_sec = t.tv_sec - 1;
+    }
+    time_latency = (((t.tv_sec - lt.tv_sec) - 1) * 1000000L) + t.tv_usec;
+    time_housekeeping = ((ct.tv_sec - t.tv_sec) * 1000000L) + (ct.tv_usec - t.tv_usec);
+#ifdef DEBUG
+    usec = time_latency;
+    msec = usec / 1000;
+    usec %= 1000;
+    printf("Sampling latency: %ld.%03ld msec", msec, usec);
+
+    usec = time_housekeeping;
+    msec = usec / 1000;
+    usec %= 1000;
+    printf("  Housekeeping time: %ld.%03ld msec\n", msec, usec);
+#endif
+    lt = ct;
+    sleeptime = ((1000000 - SLACK) - ct.tv_usec);
+    /* printf("Sleep time = %d usec\n", sleeptime); */
+  }
+}
+
+/* EGG specific */
+
+/*  LoadRCFile	--  Read in a configuration file.  If the filename
+		    argument is NULL, the default file is read.
+		    Otherwise, configuration statements are read
+		    from the file given by the argument.  */
+
+static void LoadRCFile(char *filename) {
+  FILE *fp;
+  char linebuf[200];
+  char *myargv[MAX_PARSE], *tp;
+  int myargc, lcount, p, b, i;
+
+  if (filename != NULL) {
+    if ((fp = fopen(filename, "r")) == NULL) {
+        fprintf(stderr, "%s: Cannot open auxiliary configuration file %s.\n", pgmname, filename);
+	exit(-1);
+    }
+  } else {
+    if ((fp = fopen(".eggrc", "r")) == NULL) {
+      if ((fp = fopen("~/.eggrc", "r")) == NULL) {
+        if ((fp = fopen("/etc/eggrc", "r")) == NULL) {
+          fprintf(stderr, "%s: Couldn't find a egg RC file.\n", pgmname);
+	  exit(-1);
+	}
+      }
+    }
+  }
+
+  lcount = 0;
+
+  while(fgets(linebuf, 200, fp) != NULL) {
+    /* Comments and blank lines ignored. */
+    lcount++;
+    if (*linebuf == '#' || *linebuf == '\n') continue;
+    Parse(linebuf, &myargc, myargv);
+    if (myargc == 0) continue;
+    if (!strcmp(myargv[0], "EGG")) {
+      if (myargc < 7 || myargc > 8) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+      if (numeggs > 0) {
+        fprintf(stderr, "%s: RC error, line %d, only one EGG allowed\n", 
+		pgmname, lcount);
+	exit(-1);
+      }
+
+      eggtable[0].name = mallocpy(myargv[1]);
+      eggtable[0].id = atoi(myargv[2]);
+      dquad2sockaddr(&(eggtable[0].ipaddr), NULL, myargv[3]);
+      eggtable[0].primbasket = mallocpy(myargv[4]);
+      eggtable[0].conntype = (!strcmp(myargv[5], "PERM"))?CONN_PERM:CONN_DND;
+      eggtable[0].connival = atoi(myargv[6]);
+      eggtable[0].url = NULL;	/* URL specification is permitted, but ignored */
+      numeggs = 1;
+    } else if (!strcmp(myargv[0], "BASKET")) {
+      if (myargc != 3) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+      baskettable[numbaskets].name = mallocpy(myargv[1]);
+      dquad2sockaddr(&(baskettable[numbaskets].ipaddr), NULL, myargv[2]);
+      numbaskets++;
+    } else if (!strcmp(myargv[0], "PROTOCOL")) {
+      if (myargc != 5) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+      protocol.samp_rec = atoi(myargv[1]);
+      protocol.sec_rec = atoi(myargv[2]);
+      protocol.rec_pkt = atoi(myargv[3]);
+      protocol.trialsz = atoi(myargv[4]);
+
+    /*	REG:  Configure Random Event Generator for this egg.  */
+
+    } else if (!strcmp(myargv[0], "REG")) {
+      if (myargc != 4) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+      if (configuredREG != NULL) {
+        fprintf(stderr, "%s: RC error, line %d, multiple REGs specified.\n",
+		pgmname, lcount);
+	exit(-1);
+      }
+      for (i = 0; reg_table[i] != NULL; i++) {
+	if (strcasecmp(myargv[1], reg_table[i]->reg_name) == 0) {
+	  configuredREG = reg_table[i];
+	  devopts.type = reg_table[i]->reg_type;
+	}
+      }
+      if (configuredREG == NULL) {
+        fprintf(stderr, "%s: RC error, line %d, unknown REG type %s specified.\n",
+		pgmname, lcount, myargv[1]);
+	exit(-1);
+      }
+	
+      devopts.port = atoi(myargv[2]);
+      devopts.baud = atoi(myargv[3]);
+    } else if (!strcmp(myargv[0], "NETUP") ||
+               !strcmp(myargv[0], "NETDOWN") ||
+	       !strcmp(myargv[0], "PORT") ||
+	       !strcmp(myargv[0], "INTERFACE")) {
+      if (myargc < 2) {
+        fprintf(stderr, "%s: RC error, line %d, poor %s format\n", 
+		pgmname, lcount, myargv[0]);
+	exit(-1);
+      }
+      tp = (char *) malloc(200);
+      for (*tp = 0, p = 1; p < myargc; p++) {
+	strcat(tp, myargv[p]);
+        if (p < myargc-1) strcat(tp, " ");
+      }
+
+      if (!strcmp(myargv[0], "NETUP")) eggtable[0].upcmd = tp;
+      else if (!strcmp(myargv[0], "NETDOWN")) eggtable[0].dncmd = tp;
+      else if (!strcmp(myargv[0], "PORT")) {
+	if (atoi(tp) <= 0) {
+	  fprintf(stderr, "%s: RC error, ignoring bad port %d, using %d\n",
+		  pgmname, atoi(tp), myport);
+	} else {
+	  myport = atoi(tp);
+	}
+	free(tp);
+      } else if (!strcmp(myargv[0], "INTERFACE")) myaddr = tp;
+    } else {
+      fprintf(stderr, "%s: RC error, %s is unknown keyword\n", pgmname, myargv[0]);
+      exit(-1);
+    }
+  }
+
+  /* Consistency checks done only after loading the main
+     configuration file. */
+
+  if (filename == NULL) {
+    for (p = -1, b = 0; b < numbaskets; b++) {
+      if (!strcmp(baskettable[b].name, eggtable[0].primbasket)) p = b;
+    }
+
+    if (p != 0) {
+      fprintf(stderr, "%s: RC error, primary basket should be listed first.\n", pgmname);
+      exit(-1);
+    }
+  } else {
+      printf("Reloaded auxiliary configuration file %s.\n", filename);
+  }
+  fclose(fp);
+}
+
+/*  MakeAwake  --  Make a egg awake packet to let the basket
+                   know we're on line.  */
+
+static void MakeAwake(AwakePacket *pkt) {
+  char *pktP = (char *) pkt;
+
+  packShort(AWAKE_PACKET);
+  packShort((4 * sizeof(uint16)) + sizeof(uint32));
+  packShort(eggtable[0].id);
+  packLong(getzulutime(NULL));
+}
+
+/*  MakeDataPkt  --  Build a canonical network byte order data packet
+		     from the data collected in an EggCarton.  */
+
+static void MakeDataPkt(char **pkt, EggCarton *src) {
+  uint16 pktsize, rec;
+  char *pktP;
+
+  pktsize = (7 * sizeof(uint16)) + sizeof(trial) +	    /* Header */
+	    (src->hdr.numrec * (sizeof(uint32) +	    /* Trial data */
+		src->hdr.samp_rec * sizeof(trial))) +
+	    sizeof(uint16);				    /* CRC-16 */
+  *pkt = pktP = (char *) malloc(pktsize);
+
+  /* Assemble header fields into data packet. */
+
+  packShort(src->hdr.type = DATA_PACKET);
+  packShort(src->hdr.pktsize = pktsize);
+  packShort(src->hdr.eggid);
+  packShort(src->hdr.samp_rec);
+  packShort(src->hdr.sec_rec);
+  packShort(src->hdr.rec_pkt);
+  packByte(src->hdr.trialsz);
+  packShort(src->hdr.numrec);
+
+  /* Append data records to packet. */
+
+  for (rec = 0; rec < src->hdr.numrec; rec++) {
+    packLong(src->records[rec].timestamp);
+    packBytes(&(src->records[rec].trials), src->hdr.samp_rec);
+  }
+
+  /* No need to calculate CRC -- NetTalk does that for us.
+     Note that we did reserve space for the CRC when
+     allocating the packet buffer. */
+}
+
+/*  SetCollOpts  --  Set collection options from the protocol
+		     specified in the .rc file or by a basket.	*/
+
+static double SetCollOpts(void) {
+  double sps;
+
+  coll.opts.eggid = eggtable[0].id;
+  
+  coll.opts.rec_pkt = protocol.rec_pkt;
+  if (coll.opts.rec_pkt < 1) coll.opts.rec_pkt = 1;
+  if (coll.opts.rec_pkt > MAXREC_PKT) coll.opts.rec_pkt = MAXREC_PKT;
+
+  coll.opts.trialsz = protocol.trialsz;
+  if (coll.opts.trialsz < MINBITS) {
+    fprintf(stderr, "Attempt to set trial size below %d, to %d.\n",
+	    MINBITS, coll.opts.trialsz);
+    coll.opts.trialsz = MINBITS;
+  }
+  if (coll.opts.trialsz > MAXBITS) {
+    fprintf(stderr, "Attempt to set trial size above %d, to %d.\n",
+	    MAXBITS, coll.opts.trialsz);
+    coll.opts.trialsz = MAXBITS;
+  }
+
+  coll.opts.sec_rec = protocol.sec_rec;
+  if (coll.opts.sec_rec < 1) {
+    fprintf(stderr, "Attempt to set seconds/record below 1, to %d.\n",
+	    coll.opts.sec_rec);
+    coll.opts.sec_rec = 1;
+  }
+  if (coll.opts.sec_rec > MAXSEC_REC) {
+    fprintf(stderr, "Attempt to set seconds/record above %d, to %d.\n",
+	    MAXSEC_REC, coll.opts.sec_rec);
+    coll.opts.sec_rec = MAXSEC_REC;
+  }
+
+  coll.opts.samp_rec = protocol.samp_rec;
+  if (coll.opts.samp_rec < 1) {
+    fprintf(stderr, "Attempt to set samples/record below 1, to %d.\n",
+	    coll.opts.samp_rec);
+    coll.opts.samp_rec = 1;
+  }
+  if (coll.opts.samp_rec > MAXSAMP_REC) {
+    fprintf(stderr, "Attempt to set samples/record above %d, to %d.\n",
+	    MAXSAMP_REC, coll.opts.samp_rec);
+    coll.opts.samp_rec = MAXSAMP_REC;
+  }
+
+  sps = (double)coll.opts.samp_rec / (double)coll.opts.sec_rec;
+
+  fprintf(stderr, "Effective sample rate is about %f samp/sec or %f bits/sec\n",
+	  sps, coll.opts.trialsz * sps);
+  fprintf(stderr, "Packets contain %d records\n", coll.opts.rec_pkt);
+
+  return sps;
+}
+
+/*  GreetBasket  --  Send an awake packet to each configured
+		     basket.  */
+
+static int GreetBasket(void) {
+  int			i, b;
+  struct sockaddr_in	bhost;
+  AwakePacket		awake;
+
+  MakeAwake(&awake);
+
+  for (b = 0; b < numbaskets; b++) {
+    memset(&bhost, 0, sizeof(struct sockaddr_in));
+    memcpy(&bhost, &(baskettable[b].ipaddr), sizeof(bhost));
+    bhost.sin_port = htons(BASKETPORT);
+    bhost.sin_family = AF_INET;
+
+    /* Don't gripe about network unreachable.  Just means 
+       network is down right now, try later. */
+    i = NetTalk(&bhost, (char *)&awake, FALSE);
+    if (i < 0) {
+      /* Couldn't get to this one, try others. */
+#ifdef DEBUG
+      fprintf(stderr, "%s: Failure to reach basket '%s'\n", 
+	      pgmname, baskettable[b].name);
+#endif
+    } else {
+      return ERR_NONE;
+    }
+  }
+
+  return ERR_COMM_TMOUT;
+}
+
+/*  handle_sigkill  --	KILL signal handler.  Terminate user interface
+			and exit.  */
+
+static void handle_sigkill(int arg) {
+  UIClose();
+  exit(-1);
+}
+
+/*  handle_sighup  --  HUP signal handler.  Reload protocol from the
+		       .eggprotocolrc file.  */
+
+static void handle_sighup(int arg) {
+  LoadRCFile(".eggprotocolrc");
+#ifndef SIGACTION_WORKING
+  signal(SIGHUP, handle_sighup);
+#endif
+}
diff --git a/eggrc.sample b/eggrc.sample
new file mode 100644
index 0000000..b8c44bc
--- /dev/null
+++ b/eggrc.sample
@@ -0,0 +1,86 @@
+# Configuration file for egg collection software
+# This specifies the egg configuration information, the contact
+# information for its basket(s), and initial data acquisition parameters.
+
+# Each line consists of a case-sensitive keyword and a series of
+# options.  Defined keywords are: 
+#
+#   EGG <name> <id> <ip addr> <primbasket> <conntype> <connival> <url>
+#
+# The primary basket <primbasket> is the name of the basket (defined
+# below) that should be contacted retrieve data from this Egg.
+# The connection type <conntype> is "PERM" (permanent) or "DND"
+# (dial-and-drop).  So far the code does not support the DND option.
+# The connection interval <connival> determines the time (in minutes)
+# between transmission attempts.  If specified, and not equal to
+# ".", <url> gives a URL (for example http://www.somesite.net/page.html)
+# which will be linked to the egg <name> in status reports.  Note that
+# this specification has meaning only in the .basketrc file.  For
+# compatibility, it is permitted in an .eggrc file, but is ignored.
+#
+#   BASKET <name> <ip addr>
+#
+# This entry tells us about the existence of a set of baskets.  The
+# basket named as primary is the one which will be contacted
+# initially. 
+#
+#   PROTOCOL <samprec> <secrec> <recpkt> <trialsz>
+#
+# Specify the default data collection protocol.  The arguments are 
+# <samprec> samples per record (1-10, though this should always be 5-10),
+# <secrec> seconds per records (1-3000),
+# <recpkt> records per packet (1-60), and 
+# <trialsz> bits per sample (32-255).
+#
+#   REG <type> <port> <baud>
+#
+# Specify hardware device.  Supported types include "PEAR" only at
+# this time.  Port is serial port number (e.g. 1 for /dev/ttyS1);
+# <baud> is baud rate.
+#
+#   NETUP <script> <args> ...
+#   NETDOWN <script> <args> ...
+#
+# Provide script files to be run to bring up and tear down the network
+# connection on demand.  These will only be used if connection type is
+# DND.
+
+#EGG halley 1 10.0.0.111 halley PERM 1
+#BASKET halley 10.0.0.111
+#EGG halley 1 10.0.0.111 mercury DND 3
+#BASKET mercury 10.0.0.125
+
+#EGG noosphere 28 128.112.35.133 noosphere PERM 1
+#BASKET noosphere 128.112.35.133
+
+#   diesse -> diesse
+#EGG diesse 37 193.8.230.134 diesse PERM 1
+#BASKET diesse 193.8.230.134
+
+#   noosphere -> diesse
+EGG noosphere 28 128.112.35.133 diesse PERM 1
+BASKET diesse 193.8.230.134
+
+#   throop -> diesse
+#EGG throop 1003 193.8.230.132 diesse PERM 1 http://www.fourmilab.ch/
+#BASKET diesse 193.8.230.134
+
+#   jura -> jura
+#EGG jura 1004 193.8.230.130 jura PERM 1 http://www.fourmilab.ch/
+#BASKET jura 193.8.230.130
+
+#   diesse -> noosphere
+#EGG diesse.fourmilab.ch 37 193.8.230.134 noosphere PERM 1
+#BASKET noosphere 128.112.35.133
+
+#EGG diesse 37 193.8.230.134 jura PERM 1
+#BASKET jura 193.8.230.130
+
+#BASKET tonga 209.157.90.137
+#BASKET tonga1 209.157.90.138
+PROTOCOL 10 10 6 200
+#REG PEAR 2 9600
+REG PSEUDO 1 9600
+#REG ORION 1 9600
+NETUP pppscript up
+NETDOWN pppscript down
diff --git a/eggui.c b/eggui.c
new file mode 100644
index 0000000..6404456
--- /dev/null
+++ b/eggui.c
@@ -0,0 +1,191 @@
+/* PROGRAM:	eggsh
+ * FILE:	$Header: /home/egg/src/RCS/eggui.c,v 1.8 1999/02/28 20:02:54 ghn Exp $
+ * PURPOSE:	EGG site user interface
+ * AUTHOR:	Greg Nelson
+ * DATE:	98-06-28
+ *
+ * REVISED:
+ * $Log: eggui.c,v $
+ * Revision 1.8  1999/02/28 20:02:54  ghn
+ * Version 5.1: The user interface now leaves the cursor at the bottom of
+ * the screen and responds to ^L to redraw the entire screen.
+ *
+ * Revision 1.7  1999/01/01 23:58:56  ghn
+ * Take out "CPU_BOUND" conditionals; we won't run CPU_BOUND any more.
+ *
+ * Revision 1.6  1998/12/31 22:07:56  ghn
+ * Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.5  1998/08/03 20:36:28  kelvin
+ * Show time of last data collection by basket.
+ *
+ * Revision 1.4  1998/08/01  21:33:28  ghn
+ * Added real implementation for ncursed() based UI for egg.
+ *
+ * Revision 1.3  1998/08/01 18:51:25  ghn
+ * Added John's byte-order-independence changes.
+ *
+ * Revision 1.2  1998/08/01 17:05:48  ghn
+ * Trivial additions of curses related code.
+ *
+ * Revision 1.1  1998/07/21 11:41:23  ghn
+ * Initial revision
+ *
+ * Copyright 1998 - Greg Nelson
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <curses.h>
+
+/*  Curses takes it upon itself to define TRUE and FALSE,
+    incompatibly, as it happens, with the definitions in
+    global.h.  So, clear out the CURSES definitions.  */
+#ifdef TRUE
+#undef TRUE
+#endif
+#ifdef FALSE
+#undef FALSE
+#endif
+
+#include "global.h"
+#include "genlib.h"
+#include "errnos.h"
+#include "regs.h"
+#include "version.h"
+
+#ifndef NO_UI
+static int32 inittm = 0;
+#endif
+
+extern int32 lastDataSent;
+extern int32 time_latency, time_housekeeping;
+
+/* Initialize user interface, as needed. */
+int32 UIInit(void) {
+#ifndef NO_UI
+  initscr(); 
+  cbreak(); noecho(); 
+  nonl();
+  intrflush(stdscr, FALSE);
+  keypad(stdscr, TRUE);
+  timeout(0);
+  clear();
+  move(0, 0);
+  printw("Please wait, initializing...");
+  refresh();
+  inittm = 0;
+#endif
+  return ERR_NONE;
+}
+
+/* Close down user interface */
+int32 UIClose(void) {
+#ifndef NO_UI
+  endwin();
+#endif
+  return ERR_NONE;
+}
+
+/* Update user interface once on every data collection, receiving the
+   current collection result and CollectRecord. */
+int32 UIUpdate(int32 cres, CollectRecord *coll) {
+#ifndef NO_UI
+  char *tmstr;
+  double recavg;
+  static double grandavg = 0;
+  static int32 totsamp = 0;
+  int32 i, line, now;
+
+  if ((i = getch()) != ERR) {
+    if (i == 12) clear();
+  }
+
+  if (inittm == 0) {
+    inittm = getzulutime(NULL);
+    clear();
+  }
+
+  /* Show protocol. */
+
+  if (coll->sampct == 1) {
+    line = 11;
+    move(line++, 5); printw("Samples per record: %3d", (int)coll->opts.samp_rec);
+    move(line++, 5); printw("Seconds per record: %3d", (int)coll->opts.sec_rec);
+    move(line++, 5); printw("Records per packet: %3d", (int)coll->opts.rec_pkt);
+    move(line++, 5); printw("Bits per trial:     %3d", (int)coll->opts.trialsz);
+    refresh();
+  }
+
+  if (cres < 0) return ERR_NONE;
+
+  line = 0;
+  move(line++, 3);
+  printw("EGG %s ID %d REG %s %s", eggtable[0].name, eggtable[0].id,
+	 configuredREG->reg_name, Version);
+
+  tmstr = ctime(&inittm); tmstr[strlen(tmstr)-1] = 0;
+  move(line++, 5);
+  printw("Up since       %25s", tmstr);
+
+  move(line++, 5);
+  now = getzulutime(NULL);
+  tmstr = ctime(&now); tmstr[strlen(tmstr)-1] = 0;
+  printw("Last sample at %25s", tmstr);
+
+  move(line++, 5);
+  tmstr = ctime(&lastDataSent);
+  tmstr[strlen(tmstr)-1] = 0;
+  printw("Last packet at %25s", lastDataSent == 0 ? "Never" : tmstr);
+
+  /* Note that for a non-CPU_BOUND built, UIUpdate is passed a
+     collection record filled with the last 10 samples collected.
+     Since missing samples do not figure in this record, there
+     is no need to test EGG_MISSING_DATA when computing the
+     mean below. */
+
+  /* Show mean since egg started and, each time 10 samples
+     are collected, the mean for the last 10 samples. */
+
+  line++;
+  grandavg *= totsamp;
+  grandavg += coll->data.trials[coll->sampct-1]; totsamp++;
+  grandavg /= totsamp;
+  move(line++, 5);
+  printw("Grand mean:       %6.2f", grandavg);
+
+  if (cres == 1) {
+    for (recavg = 0, i = 0; i < coll->opts.samp_rec; i++)
+      recavg += coll->data.trials[i];
+    recavg /= coll->opts.samp_rec;
+    move(line, 5); 
+    printw("Last record mean: %6.2f (%d seconds)", recavg, coll->opts.sec_rec);
+  }
+  line++;			      /* Advance whether we show record mean or not */
+
+  /* Show latency (lapse between start of second as measured by
+     the computer's clock and when collection of the sample
+     actually began) and time elapsed in housekeeping (saving
+     packets in local files, talking to the basket, updating
+     the user interface, etc.) following collection of the sample.
+     If housekeeping time frequently consumes a substantial portion
+     of the inter-sample interval, the probability of lost
+     samples increases.  Both times are shown in milliseconds. */
+
+  line++;
+  move(line++, 5);
+  printw("Sampling latency:   ");
+  clrtoeol();
+  printw("%.3f ms", time_latency / 1000.0);
+  move(line++, 5);
+  printw("Housekeeping time:  ");
+  clrtoeol();
+  printw("%.3f ms", time_housekeeping / 1000.0);
+
+  move(16, 0);
+
+  refresh();
+#endif
+
+  return ERR_NONE;
+}
diff --git a/eggui.h b/eggui.h
new file mode 100644
index 0000000..6aa4090
--- /dev/null
+++ b/eggui.h
@@ -0,0 +1,29 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/eggui.h,v 1.3 1999/01/02 00:01:40 ghn Exp $
+ * PURPOSE:     EGG site user interface
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-06-28
+ *
+ * REVISED:
+ * $Log: eggui.h,v $
+ * Revision 1.3  1999/01/02 00:01:40  ghn
+ * Removed obsolete "collect.h" include.
+ *
+ * Revision 1.2  1998/12/31 22:11:05  ghn
+ *  Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.1  1998/07/21 11:40:13  ghn
+ * Initial revision
+ * 
+ * Copyright 1998 - Greg Nelson
+ */
+
+/* Initialize user interface, as needed. */
+extern int32 UIInit(void);
+
+/* Close down user interface */
+extern int32 UIClose(void);
+
+/* Update user interface once on every data collection, receiving the
+   current collection result and CollectRecord. */
+extern int32 UIUpdate(int32 cres, CollectRecord *coll);
diff --git a/errnos.h b/errnos.h
new file mode 100644
index 0000000..28b0b10
--- /dev/null
+++ b/errnos.h
@@ -0,0 +1,62 @@
+/* PROGRAM:     all
+ * FILE:        $Header: /home/ghn/projects/PEAR/egg/eggsh/RCS/errnos.h,v 1.1 1998/07/21 11:39:53 ghn Exp $
+ * PURPOSE:     Definitions for error constants
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-05-09
+ *
+ * REVISED:     $Log: errnos.h,v $
+ * REVISED:     Revision 1.1  1998/07/21 11:39:53  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+/* 0 - no error */
+#define ERR_NONE        0
+
+/* -1 to -99 - generic errors */
+#define ERR_OTHER       -1      /* Catchall for other errors */
+#define ERR_NOMEM       -2      /* Could not allocate memory            */
+#define ERR_NIMP        -3      /* Not implemented */
+#define ERR_WRONGARGN   -4      /* Wrong number of arguments.           */
+#define ERR_INRANGE     -5      /* Input out of range */
+#define ERR_OTIMEOUT    -6      /* Got a timeout, not from COMM         */
+#define ERR_STRTOOLONG  -7      /* String was longer than allowed       */
+
+/* -100 to -199 - comm errors */
+#define ERR_STRAYINPUT  -100    /* Stray characters were received       */
+#define ERR_PKT_BADSTX  -101    /* Packet did not begin with STX        */
+#define ERR_PKT_BADLEN  -102    /* Length word could not be read        */
+#define ERR_PKT_SHORT   -103    /* Packet was not long enough           */
+#define ERR_PKT_CKSUM   -104    /* Packet checksum did not match        */
+#define ERR_PKT_BADETX  -105    /* Packet did not end with ETX          */
+#define ERR_COMM_TMOUT  -106    /* Timeout during communication         */
+#define ERR_COMM_BRK    -107    /* Received break character             */
+#define ERR_COMM_PARITY -108    /* Received parity error                */
+#define ERR_COMM_FRAME  -109    /* Received framing error               */
+#define ERR_COMM_OVERRN -110    /* Received overrun error               */
+#define ERR_BUFF_FULL   -111    /* Buffer was too full to queue msg     */
+#define ERR_NOREPLY     -112    /* Device did not reply to hails        */
+#define ERR_RESPINVAL   -113    /* Response was invalid                 */
+#define ERR_COMM_BTMOUT -114    /* Timeout inside body of message       */
+#define ERR_PORT_INACT  -115    /* Attempt to use an inactive port      */
+
+/* -200 to -299 - math errors */
+#define ERR_DIV0        -200    /* Attempt to divide by zero            */
+#define ERR_NOSOLN      -201    /* Couldn't solve for discontinuities   */
+#define ERR_APPROX      -202    /* Result was an inexact approximation  */
+#define ERR_NOVARS      -203    /* No parameters were variable          */
+#define ERR_SINGULAR    -204    /* Matrix was singular, unsolvable      */
+#define ERR_OVERFLOW    -205    /* Numerical overflow                   */
+
+/* -300 to -399 - DLL specific errors */
+#define ERR_NOTSUPP     -300    /* Current device does not support fn   */
+#define ERR_RESOURCE    -301    /* Ran out of a DLL limited resource    */
+#define ERR_DEVDRVR     -302    /* Windows device driver returned err   */
+#define ERR_DEVSELECT   -303    /* Selecting a device failed (general)  */
+#define ERR_NOENT       -320    /* File not found                       */
+#define ERR_CNREAD      -321    /* Couldn't read desired data from file */
+#define ERR_CNWRITE     -322    /* Couldn't write desired data to file  */
+#define ERR_EOF         -323    /* End of file reached unexpectedly     */
+#define ERR_DLGCAN      -324    /* Dialog canceled, not an "error"      */
diff --git a/examine.c b/examine.c
new file mode 100644
index 0000000..ac4d0e8
--- /dev/null
+++ b/examine.c
@@ -0,0 +1,61 @@
+/* PROGRAM:     examine
+ * FILE:        $Header: /home/egg/src/RCS/examine.c,v 1.1 1998/07/21 11:39:04 ghn Exp $
+ * PURPOSE:     Testing data retrieval from database
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-05-09
+ *
+ * REVISED:     $Log: examine.c,v $
+ * REVISED:     Revision 1.1  1998/07/21 11:39:04  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "global.h"
+#include "storage.h"
+
+EggEntry eggtable[MAX_EGGS];
+
+int main(int argc, char *argv[]) {
+  int i, j, k, trials;
+  FILE *fp;
+  EggCarton pktbuf;
+
+  pgmname = argv[0];
+
+  if (argc != 1 && argc != 2) {
+    printf("Usage: %s [infile]\n", pgmname);
+    exit(-1);
+  }
+  
+  InitStorage(NULL);
+
+  if (argc == 1) fp = stdin;
+  else fp = fopen(argv[1], "r");
+
+  trials = 0;
+  while (1) {
+    i = LoadPacket(fp, &pktbuf);
+    if (i < 0) {
+      printf("Total trials: %d\n", trials);
+      exit(-1);
+    }
+
+    printf("Packet of %d records read\n", pktbuf.hdr.numrec);
+    for (j = 0; j < pktbuf.hdr.numrec; j++) {
+      printf("Record: %d points\n  %ld: ",
+	     pktbuf.hdr.samp_rec,
+	     pktbuf.records[j].timestamp);
+      for (k = 0; k < pktbuf.hdr.samp_rec; k++) {
+	printf("%3d ", pktbuf.records[j].trials[k]);
+	trials++;
+      }
+      printf("\n");
+    }
+  }
+
+  return 0;
+}
diff --git a/genlib.c b/genlib.c
new file mode 100644
index 0000000..de328ff
--- /dev/null
+++ b/genlib.c
@@ -0,0 +1,254 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/genlib.c,v 1.6 1999/02/28 20:05:18 ghn Exp $
+ * PURPOSE:     General library
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-05-09
+ *
+ * REVISED:
+ * $Log: genlib.c,v $
+ * Revision 1.6  1999/02/28 20:05:18  ghn
+ * Version 5.1: Changed dquad2sockaddr interface to support ip/mm mask,
+ * created hl2dquad to translate host-long to dotted quad, and modified
+ * sockaddr2dquad to use this.
+ *
+ * Revision 1.5  1998/12/31 22:07:56  ghn
+ * Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.4  1998/08/03 20:43:35  kelvin
+ * File byte-order independence.
+ *
+ * Revision 1.3  1998/08/01  18:51:25  ghn
+ * Added John's byte-order-independence changes.
+ *
+ * Revision 1.2  1998/08/01 17:07:29  ghn
+ * Casting fixes from John plus better parsing.
+ *
+ * Revision 1.1  1998/07/21 11:38:15  ghn
+ * Initial revision
+ * 
+ * Copyright 1998 - Greg Nelson
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/utsname.h>
+#include "global.h"
+#include "genlib.h"
+
+int32 getzulutime(struct timeval *ztv) {
+  struct timeval ttv;
+
+  if (ztv) {
+    gettimeofday(ztv, NULL);
+    return ztv->tv_sec;
+  } else {
+    gettimeofday(&ttv, NULL);
+    return ttv.tv_sec;
+  }
+}
+
+/* Get time difference (tv1-tv2) in msec.  Only works if less than 24
+   days have passed. */
+int32 deltams(struct timeval *tv1, struct timeval *tv2) {
+  return (tv1->tv_sec - tv2->tv_sec) * 1000L +
+         (tv1->tv_usec - tv2->tv_usec) / 1000L;
+}
+
+/* Look up an EGG id.  If we can't get it from environment, do a nutty
+   thing using CRC of uname block, which should be pretty unique. */
+uint16 GetID(void) {
+  char *idstr;
+  struct utsname utsname;
+
+  if ((idstr = getenv("EGGID")) != NULL) {
+    return atoi(idstr);
+  } else {
+    uname(&utsname);
+    return BlockCRC16((byte *)(&utsname), sizeof(struct utsname));
+  }
+}
+
+char *Packetize(EggCarton *src) {
+  char *rbuf;
+  uint32 lbuf;
+  uint16 pktsize, rec;
+  char *pktP;
+
+  pktsize = (7 * sizeof(uint16)) + sizeof(trial) +	    /* Header */
+	    sizeof(char) +				    /* ...including pad byte for trialsz */
+	    (src->hdr.numrec * (sizeof(uint32) +	    /* Trial data */
+		src->hdr.samp_rec * sizeof(trial))) +
+	    sizeof(uint32);				    /* CRC and terminator */
+  rbuf = pktP = (char *) malloc(pktsize);
+
+  /* Assemble header fields into data packet. */
+
+  packShort(src->hdr.type = DATA_PACKET);
+  packShort(src->hdr.pktsize = pktsize);
+  packShort(src->hdr.eggid);
+  packShort(src->hdr.samp_rec);
+  packShort(src->hdr.sec_rec);
+  packShort(src->hdr.rec_pkt);
+  packByte(0);			      /* Pad byte in case we want to expand trialsz */
+  packByte(src->hdr.trialsz);
+  packShort(src->hdr.numrec);
+
+  /* Append data records to packet. */
+
+  for (rec = 0; rec < src->hdr.numrec; rec++) {
+    packLong(src->records[rec].timestamp);
+    packBytes(&(src->records[rec].trials), src->hdr.samp_rec);
+  }
+  /* Get CRC, pack into base(32,32,64) notation, and add tag byte (0xFF) */
+  lbuf = BlockCRC16((byte *) rbuf, pktP - rbuf);
+  lbuf = ((lbuf & 0xF800) << 13) |
+	 ((lbuf & 0x07C0) << 10) |
+	 ((lbuf & 0x003F) << 8) |
+	 (0x00FF);
+  packLong(lbuf);
+  if ((pktP - rbuf) != pktsize) {
+    fprintf(stderr, "Length mismatch assembling packet.  Computed: %d, actually packed: %d.\n",
+	pktsize, pktP - rbuf);
+  }
+  return rbuf;
+}
+
+int32 Unpacketize(EggCarton *dst, char *src) {
+  char *pktP = src;
+  char pad;
+  uint16 rec;
+  uint32 lbuf, filecrc;
+
+  /* Unpack the portable header into a host-order and aligned
+     EggHeader packet. */
+
+  unpackShort(dst->hdr.type);
+  unpackShort(dst->hdr.pktsize);
+  unpackShort(dst->hdr.eggid);
+  unpackShort(dst->hdr.samp_rec);
+  unpackShort(dst->hdr.sec_rec);
+  unpackShort(dst->hdr.rec_pkt);
+  unpackByte(pad);		      /* Pad in case we later grow trialsz */
+  unpackByte(dst->hdr.trialsz);
+  unpackShort(dst->hdr.numrec);
+
+  if (dst->hdr.type != DATA_PACKET) {
+#ifdef DEBUG
+    fprintf(stderr, "Invalid header type 0x%04X in packet read from file.\n", dst->hdr.type);
+#endif
+    return -1;
+  }
+
+  /* Unpack the data records from the file packet. */
+
+  for (rec = 0; rec < dst->hdr.numrec; rec++) {
+    unpackLong(dst->records[rec].timestamp);
+    /* Assumes sizeof(trial) = 1 */
+    unpackBytes(&(dst->records[rec].trials), dst->hdr.samp_rec);
+  }
+
+  /* Compute the CRC, reassemble into record terminator,
+     and compare with terminator in file. */
+
+  lbuf = BlockCRC16((byte *) src, pktP - src);
+  lbuf = ((lbuf & 0xF800) << 13) |
+	 ((lbuf & 0x07C0) << 10) |
+	 ((lbuf & 0x003F) << 8) |
+	 (0x00FF);
+
+  unpackLong(filecrc);
+
+  if (lbuf != filecrc) {
+#ifdef DEBUG
+    fprintf(stderr, "Bad CRC in packet read from file.  Read 0x%08lX, computed 0x%08lX.\n", filecrc, lbuf);
+#endif
+    return -2;
+  }
+
+  if (dst->hdr.pktsize != (pktP - src)) {
+#ifdef DEBUG
+    fprintf(stderr, "Length mismatch decoding packet.  Header: %d, length decoded: %d.\n",
+      dst->hdr.pktsize, pktP - src);
+#endif
+    return -1;
+  }
+
+  /* One final little tweak.  Since we included a pad byte to allow
+     for growth in trialsz, hdr.pktsize will include it.  Subtract
+     one to hide the existence of the pad in the file from the
+     caller.  In all probability the caller isn't going to look at
+     pktsize, but you can't be too careful. */
+
+  dst->hdr.pktsize--;
+
+  return 0;
+}
+
+void Parse(char *input, int *argc, char *argv[]) {
+  char *tp;
+
+  *argc = 0;
+
+  tp = strtok(input, " \t\n");
+  while (tp != NULL && *argc < MAX_PARSE) {
+    argv[*argc] = tp;
+    *argc += 1;
+    tp = strtok(NULL, " \t\n");
+  }
+}
+
+char *mallocpy(char *input) {
+  char *res;
+
+  res = (char *)malloc(1+strlen(input));
+  if (res) strcpy(res, input);
+  return res;
+}
+
+void dquad2sockaddr(struct sockaddr_in *sinp, int16 *mask, char *dquad) {
+  char *tp, *loser;
+  long saddr;
+  short qcount;
+
+  loser = mallocpy(dquad);
+
+  tp = strtok(loser, ".");
+  for (qcount = 0, saddr = 0; qcount < 4 && tp != NULL; qcount++) {
+    saddr = (saddr << 8) | (atoi(tp) & 0xFF);
+    tp = strtok(NULL, ".");
+  }
+  if (mask) {
+    *mask = 32;
+    strcpy(loser, dquad);
+    tp = strtok(loser, "/");
+    if (tp) {
+      tp = strtok(NULL, "/");
+      if (tp) *mask = atoi(tp);
+    }
+  }
+  free(loser);
+
+  sinp->sin_family = AF_INET;
+  sinp->sin_port = 0;		/* To be filled in later */
+  sinp->sin_addr.s_addr = htonl(saddr);
+}
+
+char *sockaddr2dquad(struct sockaddr_in *sinp) {
+  long saddr;
+  
+  saddr = ntohl(sinp->sin_addr.s_addr);
+  return hl2dquad(saddr);
+}
+
+char *hl2dquad(long addr) {
+  static char resout[16];
+
+  sprintf(resout, "%ld.%ld.%ld.%ld",
+	  (addr >> 24) & 0xFF, (addr >> 16) & 0xFF,
+	  (addr >> 8) & 0xFF, addr & 0xFF);
+  
+  return resout;
+}
diff --git a/genlib.h b/genlib.h
new file mode 100644
index 0000000..b176de6
--- /dev/null
+++ b/genlib.h
@@ -0,0 +1,75 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/genlib.h,v 1.3 1999/02/28 20:05:35 ghn Exp $
+ * PURPOSE:     Define general library interface
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-05-09
+ *
+ * REVISED:
+ * $Log: genlib.h,v $
+ * Revision 1.3  1999/02/28 20:05:35  ghn
+ * Version 5.1: Changed dquad2sockaddr interface to support ip/mm mask,
+ * created hl2dquad to translate host-long to dotted quad, and modified
+ * sockaddr2dquad to use this.
+ *
+ * Revision 1.2  1998/12/31 22:11:05  ghn
+ *  Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.1  1998/07/21 11:38:04  ghn
+ * Initial revision
+ *
+ * Copyright 1998 - Greg Nelson
+ */
+
+#ifndef _GENLIB_H
+
+#include <unistd.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include "global.h"
+
+#define MAX_PARSE	20
+
+#ifdef OBSOLETE
+/* This is actually 366 * 24 * 60 * 60, as opposed the actual length
+   of the mean solar year which is about 365.2524 days.  */
+#define SEC_PER_YEAR    31622400L
+#endif
+
+/* Get time in GMT reference frame.  If ztv is NULL, simply returns
+   seconds.  Otherwise, returns complete timeval in ztv as well. */
+extern int32 getzulutime(struct timeval *ztv);
+
+/* Get difference in msec between two tvs. */
+extern int32 deltams(struct timeval *tv1, struct timeval *tv2);
+
+/* Look up an EGG id. */
+extern uint16 GetID(void);
+
+/* Create a proper checksummed and packetized byte stream from the raw
+   data in memory.  Return result is malloc'ed, so should be freed by
+   caller. */
+extern char *Packetize(EggCarton *src);
+
+extern int32 Unpacketize(EggCarton *dst, char *src);
+
+/* Compute CRC16 checksum given block and length (from crc16.c) */
+extern uint16 BlockCRC16(byte *block, uint32 len);
+
+extern void Parse(char *input, int *argc, char *argv[]);
+extern char *mallocpy(char *input);
+extern void dquad2sockaddr(struct sockaddr_in *sinp, int16 *mask, char *dquad);
+extern char *sockaddr2dquad(struct sockaddr_in *sinp); /* Static buffer! */
+extern char *hl2dquad(long addr);	/* Static buffer! */
+
+
+/* Access to system or emulated usleep(). */
+
+#ifdef USLEEP
+extern void sf_usleep(unsigned t);
+#define Usleep sf_usleep
+#else
+#define Usleep usleep
+#endif
+
+#define _GENLIB_H
+#endif /* _GENLIB_H */
diff --git a/global.h b/global.h
new file mode 100644
index 0000000..d85b156
--- /dev/null
+++ b/global.h
@@ -0,0 +1,186 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/global.h,v 1.5 1999/02/28 20:10:29 ghn Exp $
+ * PURPOSE:     Declare global types, constants, and variables
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-04-12
+ *
+ * REVISED:
+ * $Log: global.h,v $
+ * Revision 1.5  1999/02/28 20:10:29  ghn
+ * Version 5.1: Added netmask field for egg.
+ *
+ * Revision 1.4  1998/12/31 22:11:05  ghn
+ *  Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.3  1998/08/01 18:51:25  ghn
+ * Added John's byte-order-independence changes.
+ *
+ * Revision 1.2  1998/08/01 17:08:20  ghn
+ * Added upcmd and dncmd for DND.
+ *
+ * Revision 1.1  1998/07/21 11:37:56  ghn
+ * Initial revision
+ *
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#ifndef _GLOBAL_H
+
+#include <netinet/in.h>
+
+#include "byteorder.h"		/* Build byte-order independent version */
+
+/* Good for i386, but be careful... */
+typedef unsigned char byte;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned long uint32;
+typedef char int8;
+typedef short int16;
+typedef long int32;
+
+/* Some fixed assumptions:
+   Trial type is always bitsum.
+   Bit spacing method does not need to be communicated, since we'll
+     choose something at compile time. 
+   Record size ranges from one to MAXSAMP_REC trials, which are assumed to
+     be evenly spaced starting at timestamp.
+   Records always begin on round seconds divisible by sec_rec, which
+     can range from one to MAXSEC_REC.
+*/
+
+/* Some adjustable assumptions: */
+
+#define MINBITS		32	/* Minimum bits per trial */
+#define MAXBITS		253	/* Maximum bits per trial */
+#define MAXSAMP_REC	10	/* Maximum samples/record */
+#define MAXSEC_REC	3000	/* Maximum seconds/record */	
+
+#define SEC_PKT		60	/* Desired number of seconds per packet */
+#define MAXREC_PKT	60	/* Maximum number of records per packet
+				   For 1-second records (typ) this is 1 min */
+
+#define EGG_MISSING_DATA 254    /* Value used to represent missing data in trials array. */
+
+#if MAXBITS < 256
+typedef uint8 trial;
+#else
+#error "Can't represent MAXBITS in a byte value."
+#endif
+
+#if MAXBITS >= EGG_MISSING_DATA
+#error "MAXBITS is >= EGG_MISSING_DATA: ambiguous trial data possible."
+#endif
+
+typedef struct eggrec {
+  uint32 timestamp;	/* Seconds since the epoch (19700101000000Z) */
+  trial trials[MAXSAMP_REC]; /* Trial values */
+} EggRec;		/* Normally 16 bytes total */
+
+/* Make sure type field of packet is non-zero so that CRC works. */
+
+typedef struct genpacket {
+  uint16 type;
+  uint16 pktsize;
+} GenPacket;
+
+#define DATA_PACKET	0x0101
+typedef struct eggheader {
+  uint16 type;		/* type */
+  uint16 pktsize;	/* Number of bytes in packet */
+  uint16 eggid;		/* Identifying number for device */
+  uint16 samp_rec;	/* Number of samples per record */
+  uint16 sec_rec;	/* Number of seconds per record */
+  uint16 rec_pkt;	/* Number of records per packet */
+  trial trialsz;	/* Number of bits per trial */
+  uint16 numrec;	/* Number of valid records */
+} EggHeader;
+
+#define REQ_PACKET	0x0202
+typedef struct reqpacket {
+  uint16 type;		/* type */
+  uint16 pktsize;	/* Number of bytes in packet */
+  uint16 eggid;		/* Identifying number for device */
+  uint32 starttm;	/* Time for first record to send */
+  uint16 cksum;		/* No data, checksum goes inside */
+} ReqPacket;
+
+#define AWAKE_PACKET	0x0303
+typedef struct awakepacket {
+  uint16 type;		/* type */
+  uint16 pktsize;	/* Number of bytes in packet */
+  uint16 eggid;		/* Identifying number for device */
+  uint32 nowtm;		/* Egg's identification of "now" (zulu) */
+  uint16 cksum;		/* No data, checksum goes inside */
+} AwakePacket;
+
+#define SETTINGS_PACKET	0x0404
+typedef struct setpacket {
+  uint16 type;		/* type */
+  uint16 pktsize;	/* Number of bytes in packet */
+  uint16 eggid;		/* Identifying number for device */
+  uint32 nowtm;		/* Egg's identification of "now" (zulu) */
+  uint16 samp_rec;	/* Number of samples per record */
+  uint16 sec_rec;	/* Number of seconds per record */
+  uint16 rec_pkt;	/* Number of records per packet */
+  trial trialsz;	/* Number of bits per trial */
+  uint16 cksum;		/* No data, checksum goes inside */
+} SettingsPacket;
+
+/*  An EggCarton is the in-memory representation of a data
+    packet.  Fields in it are thus in host byte order,
+    being translated, as appropriate, when transferred
+    to and from a DATA_PACKET by Packetize() and
+    Unpacketize().  */
+
+typedef struct eggpkt {
+  EggHeader hdr;	/* Header (type = DATA_PACKET) */
+  EggRec records[MAXREC_PKT];
+} EggCarton;
+
+typedef struct collect {
+  EggHeader opts;
+  EggRec data;
+  uint16 sampct;		/* Count of completed samples in rec */
+  int32 dd;			/* Device handle */
+} CollectRecord;
+
+#define CONN_PERM	0
+#define CONN_DND	1
+
+typedef struct eggentry {
+  char *name;
+  int16 id;
+  struct sockaddr_in ipaddr;
+  int16 netmask;	/* Number of significant bits, default 32. */
+  char *primbasket;
+  int16 conntype;
+  int16 connival;	/* Connect interval in minutes */
+  int32 lastupd;	/* Zulutime of last update received */
+  int16 setup;		/* Does setup match config file? */
+  char *upcmd;		/* Command to bring net up (req if conntype == DND) */
+  char *dncmd;		/* Command to bring net down */
+  char *url;		/* URL describing basket or NULL */
+} EggEntry;
+
+typedef struct basketentry {
+  char *name;
+  struct sockaddr_in ipaddr;
+} BasketEntry;
+
+#define MAX_EGGS	100
+#define MAX_BASKETS	5
+
+extern EggEntry eggtable[MAX_EGGS];
+extern BasketEntry baskettable[MAX_BASKETS];
+extern short numeggs, numbaskets;
+extern EggHeader protocol;
+
+extern char *pgmname;	/* For error messages to announce program name */
+
+#define TRUE	-1
+#define FALSE	0
+
+#define _GLOBAL_H
+#endif /* _GLOBAL_H */
diff --git a/hw_pear.c b/hw_pear.c
new file mode 100644
index 0000000..401d307
--- /dev/null
+++ b/hw_pear.c
@@ -0,0 +1,241 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/hw_pear.c,v 1.3 1998/08/01 18:50:39 ghn Exp $
+ * PURPOSE:     PEAR (Bradish box/micro-REG) hardware interface
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-04-12
+ *
+ * REVISED:     $Log: hw_pear.c,v $
+ * REVISED:     Revision 1.3  1998/08/01 18:50:39  ghn
+ * REVISED:     Added John's byte-order-independence changes and PSEUDO support.
+ * REVISED:
+ * REVISED:     Revision 1.2  1998/08/01 17:13:51  ghn
+ * REVISED:     Added John's Solaris support and DUMPREG option.
+ * REVISED:
+ * REVISED:     Revision 1.1  1998/07/21 11:37:41  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+/* Define this to dump samples from the REG which we actually use into
+   a file named dumpreg.dat.  This can be used to debug serial port
+   mode problems (for example, setting the character frame to 7 bits,
+   or telling it to ignore breaks, which will lose all zero bytes. */
+/* #define DUMPREG */
+
+#include <stdio.h>
+#define __USE_BSD
+#include <termios.h>
+#undef __USE_BSD
+#include <unistd.h>
+#include <fcntl.h>
+#define __USE_BSD
+#include <errno.h>
+#undef __USE_BSD
+
+#include "global.h"
+#include "genlib.h"
+#include "hwapi.h"
+
+#define MAXDEV	20
+
+int32 oldbits[MAXDEV], bitsleft[MAXDEV];
+
+#ifdef DUMPREG
+static FILE *dumpfile;		      /* REG dump file handle */
+static unsigned char dumpbuf[1024];   /* REG dump buffer */
+static int dumpptr = 0; 	      /* Pointer into dump buffer */
+#endif
+
+#ifdef PSEUDORANDOM_TEST
+#include <stdlib.h>
+static int pseudo = FALSE;	      /* Nonzero if using pseudo-REG */
+#endif
+
+int32 OpenDev(DevOpts *opts) {
+  char ttydev[30];
+  speed_t baudcon;
+  struct termios tt;
+  int32 TTY_fd, res;
+
+#ifdef DUMPREG
+  dumpfile = fopen("dumpreg.dat", "w");
+  setbuf(dumpfile, NULL);
+  dumpptr = 0;
+#endif
+
+#ifdef PSEUDORANDOM_TEST
+  if (opts->type == 0xFF) {
+    TTY_fd = 1;
+    oldbits[TTY_fd] = bitsleft[TTY_fd] = 0;
+    srandom(time(NULL));
+    pseudo = TRUE;
+    fprintf(stderr, "**** WARNING!  This egg has been configured to\n\
+               use a pseudorandom sequence generator to\n\
+               permit testing on machines not equipped\n\
+               with an REG.  Data from this egg should not\n\
+               be used for analysis.\n");
+    return TTY_fd;
+  }
+#endif
+
+#ifdef Solaris
+  /* Serial ports (at least built-in ones) have names of
+     /dev/term/a, /dev/term/b, etc.  Map the port numbers
+     from the RC file into this nomenclature, with "1"
+     designating /dev/term/a. */
+  sprintf(ttydev, "/dev/term/%c", 'a' + (opts->port - 1));
+#else
+  sprintf(ttydev, "/dev/ttyS%d", opts->port);
+#endif
+
+  switch(opts->baud) {
+  case 1200: baudcon = B1200; break;
+  case 2400: baudcon = B2400; break;
+  case 4800: baudcon = B4800; break;
+  case 9600: baudcon = B9600; break;
+  case 19200: baudcon = B19200; break;
+  case 38400: baudcon = B38400; break;
+#ifndef Irix
+  case 115200: baudcon = B115200; break;
+#endif
+  default:
+    printf("%s: Baud rate %ld not supported.\n", pgmname, opts->baud);
+    return -1;
+  }
+
+  fprintf(stderr, "Opening %s at %ld\n", ttydev, opts->baud);
+  if ((TTY_fd = open(ttydev, O_RDWR | O_NDELAY)) < 0) {
+    perror(pgmname);
+    return -1;
+  }
+
+  if (TTY_fd >= MAXDEV) {
+    fprintf(stderr, "%s: Too many devices open.\n", pgmname);
+    close(TTY_fd);
+    return -1;
+  }
+
+  res = tcgetattr(TTY_fd, &tt);
+#ifdef Solaris
+  tt.c_iflag = 0;
+  tt.c_oflag = 0;
+  tt.c_cflag = baudcon | CS8 | CREAD | CLOCAL;
+  tt.c_lflag = 0;
+  tt.c_cc[VMIN] = 1;	/* This many chars satisfies reads */
+  tt.c_cc[VTIME] = 0;	/* or in this many tenths of seconds */
+#else
+  res = cfsetospeed(&tt, baudcon); 
+  cfmakeraw(&tt);
+  tt.c_oflag &= (~(TABDLY | ONLCR));
+#endif
+  res = tcsetattr(TTY_fd, TCSANOW, &tt);
+
+  oldbits[TTY_fd] = bitsleft[TTY_fd] = 0;
+  return TTY_fd;
+}
+
+#define SAMP_PERIOD	1000	/* msec */
+#define MARGIN		.95	/* how much to headroom to allow in
+				   speed measurement */
+
+int32 EvalSpeed(int32 dd) {
+  struct timeval start, end;
+  int32 bitct, samp;
+
+  if (dd < 0) return -1;
+
+#ifdef PSEUDORANDOM_TEST
+  if (pseudo) {
+    return 500;
+  }
+#endif
+
+  gettimeofday(&start, NULL);
+  bitct = 0;
+  while (1) {
+    gettimeofday(&end, NULL);
+    if (deltams(&end, &start) >= SAMP_PERIOD) break;
+    samp = Sample(dd, 1);
+    bitct++;
+  }
+
+  return (int32)(bitct * MARGIN);
+}
+
+int32 Sample(int32 dd, uint16 bits) {
+  int32 bc, sum, n1;
+  uint8 c1;
+
+  if (dd < 0) return -1;
+
+  sum = bc = 0;
+  while (bc < bits) {
+    if (bitsleft[dd]) {
+      sum += (oldbits[dd] & 0x01);
+      oldbits[dd] >>= 1;
+      bitsleft[dd]--;
+      bc++;
+    } else {
+      do {
+#ifdef PSEUDORANDOM_TEST
+	if (pseudo) {
+	    n1 = 1;
+	    c1 = (uint8) ((random() >> 5) & 0xFF);
+	} else
+#endif
+	n1 = read(dd, &c1, 1);
+      } while (n1 == 0 || (n1 == -1 && errno == EAGAIN));
+      if (n1 == -1) {
+	/* Fatal error occurred, die now? */
+	return -1;
+      }
+#ifdef DUMPREG
+      dumpbuf[dumpptr++] = c1;
+      if (dumpptr >= sizeof(dumpbuf)) {
+	fwrite(dumpbuf, sizeof(dumpbuf), 1, dumpfile);
+	dumpptr = 0;
+      }
+#endif
+      oldbits[dd] = c1;
+      bitsleft[dd] = 8;
+    }
+  }
+
+  return sum;
+}
+
+int32 Discard(int32 dd) {
+  int32 disc, n1;
+  uint8 c1;
+  
+  if (dd < 0) return -1;
+
+  disc = bitsleft[dd];
+  bitsleft[dd] = 0;
+
+#ifdef PSEUDORANDOM_TEST
+  if (pseudo) {
+    return 32;
+  }
+#endif
+
+  do {
+    n1 = read(dd, &c1, 1);
+    if (n1 == 1) disc++;
+  } while (n1 == 1);
+
+  return disc;
+}
+
+int32 CloseDev(int32 dd) {
+  if (dd < 0) return -1;
+
+#ifdef PSEUDORANDOM_TEST
+  if (!pseudo)
+#endif
+  close(dd);
+  return 0;
+}
+
diff --git a/hwapi.h b/hwapi.h
new file mode 100644
index 0000000..a9bfc62
--- /dev/null
+++ b/hwapi.h
@@ -0,0 +1,53 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/ghn/projects/PEAR/egg/eggsh/RCS/hwapi.h,v 1.1 1998/07/21 11:37:32 ghn Exp $
+ * PURPOSE:     Define interface to hardware layer
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-04-12
+ *
+ * REVISED:     $Log: hwapi.h,v $
+ * REVISED:     Revision 1.1  1998/07/21 11:37:32  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ */
+
+typedef struct devopts {
+  uint16 type;	/* 0 = PEAR */
+  uint16 port;
+  uint32 baud;
+} DevOpts;
+
+/* Open a device. 
+
+   DevOpts should contain any necessary information to determine how
+   this is to be done.  The return value, if >= 0, is a device handle.
+   Otherwise it indicated an error. */
+int32 OpenDev(DevOpts *opts);
+
+/* Evaluate speed.
+
+   dd is the device handle returned by opening the device.  The
+   function returns the estimated number of bits/second that the
+   device will produce, which should be used as a limit in setting the
+   data rate. */
+int32 EvalSpeed(int32 dd);
+
+/* Sample from a device.
+
+   dd is the device handle returned by opening the device.  The number
+   of bits requested will be sampled from the device immediately
+   (waiting as needed to collect the data, with no discards) and the
+   result will be returned. */
+int32 Sample(int32 dd, uint16 bits);
+
+/* Discard spare data from device.
+
+   dd is the device handle returned by opening the device.  The input
+   stream is consumed until a wait would be required.  The number of
+   bits discarded is returned. */
+int32 Discard(int32 dd);
+
+/* Close a device.
+
+   Closes a specified device handle. */
+int32 CloseDev(int32 dd);
diff --git a/ipproto.c b/ipproto.c
new file mode 100644
index 0000000..42b919c
--- /dev/null
+++ b/ipproto.c
@@ -0,0 +1,39 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/ipproto.c,v 1.1 1998/07/21 11:37:21 ghn Exp $
+ * PURPOSE:     Declarations/definitions of IP data protocols for Egg
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-04-12
+ *
+ * REVISED:     $Log: ipproto.c,v $
+ * REVISED:     Revision 1.1  1998/07/21 11:37:21  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#include <string.h>
+#include "global.h"
+#include "crc16.h"
+
+int32 PackPacket(char *buf, uint32 bufsize, EggCarton *cart) {
+  int32 rec, ntrl, llen;
+  uint16 crc;
+
+  if (bufsize < sizeof(EggHeader)) return -1;
+
+  memcpy(buf, &(cart->hdr), sizeof(EggHeader));
+  buf += sizeof(EggHeader);
+
+  ntrl = card->hdr.reclen;
+  llen = sizeof(uint32) + ntrl * sizeof(trial);
+
+  for (rec = 0; rec < cart->hdr.numrec; rec++) {
+    memcpy(buf, &(card->records[rec].timestamp), sizeof(uint32));
+    memcpy(buf + sizeof(uint32),
+	   &(card->records[rec].trials), ntrl * sizeof(trial));
+    crc = BlockCRC16((byte *)buf, llen);
+    memcpy(buf + llen, &crc, sizeof(uint16));
+    buf += llen + sizeof(uint16);
+  }
+}
diff --git a/ipproto.h b/ipproto.h
new file mode 100644
index 0000000..4994a11
--- /dev/null
+++ b/ipproto.h
@@ -0,0 +1,17 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/ghn/projects/PEAR/egg/eggsh/RCS/ipproto.h,v 1.1 1998/07/21 11:37:06 ghn Exp $
+ * PURPOSE:     Declarations/definitions of IP data protocols for Egg
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-04-12
+ *
+ * REVISED:     $Log: ipproto.h,v $
+ * REVISED:     Revision 1.1  1998/07/21 11:37:06  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#include "global.h"
+
+uint32 PackPacket(char *buf, uint32 bufsize, EggCarton *cart);
diff --git a/lecuyer.c b/lecuyer.c
new file mode 100644
index 0000000..2df4403
--- /dev/null
+++ b/lecuyer.c
@@ -0,0 +1,135 @@
+/*
+
+    L'Ecuyer's two-sequence pseudorandom generator with a 32 cell
+    Bays-Durham shuffle on the back end.
+
+    When updating the individual generators, an intermediate value as
+    large as 64 bits is required.  Many modern C compilers provide a
+    "long long" 64-bit integer type.  If this type is available,
+    compile this file with LONGLONG defined and it will be used,
+    generally improving execution speed.  If the compiler does not
+    implement "long long", compile without LONGLONG and Schrage's
+    algorithm will be used to perform the computation using only
+    32 bit arithmetic.
+
+    For additional details, see L'Ecuyer's paper:
+
+        L'Ecuyer, P. "Communications of the ACM", Vol. 31, p. 742 (1988).
+
+    and that of Bays and Durham:
+
+        Bays, Carter, and S.D. Durham.  "ACM Transactions on
+            Mathematical Software", Vol. 2, p. 59 (1976).
+
+    Schrage's multiple-precision modular algorithm is described in:
+
+        Schrage, P.  "ACM Transactions on Mathematical Software",
+	    Vol. 5, p. 132 (1979).
+
+*/
+
+#include <stdio.h>
+#include <assert.h>
+
+#define LONGLONG
+
+#ifdef LONGLONG
+#define int64 long long
+#else
+#define int64 long
+#endif
+#define int32 long
+
+/* L'Ecuyer's recommended multiplier and modulus for the two
+   multiplicative congruential generators.  Even though the
+   values fit in 32 bits, we declare them as int64 so that the
+   arithmetic in calculating the next value will be automatically
+   done in int64 without need for casting when LONGLONG is defined.
+   In a non-LONGLONG build int64 is defined as long, so these values
+   participate correctly in the Schrage algorithm computation. */
+
+#define mul1 ((int64) 40014)
+#define mod1 ((int64) 2147483563)
+#define mul2 ((int64) 40692)
+#define mod2 ((int64) 2147483399)
+
+#define shuffleSize 32		      /* Shuffle table size */
+#define warmup 19                     /* Number of initial warmup results to "burn" */
+
+static int32 gen1, gen2, state;
+static int32 shuffle[shuffleSize];    /* Bays-Durham shuffle table */
+
+/*  Update generator which, using either long long arithmetic or
+    Schrage's algorithm depending on whether LONGLONG is defined.
+    The definition for Schrage's algorithm relies, for efficiency,
+    on the C compiler performing compile-time constant arithmetic
+    for the quotient and remainder of the modulus and multiplier.
+    If you're porting this to a language which lacks that feature,
+    you'll want to predefine the quotient and remainder for each
+    generator and use the explicit values.  */
+
+#ifdef LONGLONG
+#define updgen(which)	gen##which = (int32) ((gen##which * mul##which) % mod##which)
+#else
+#define updgen(which) {                                                               \
+        int32 t = gen##which / (mod##which / mul##which);                             \
+                                                                                      \
+        gen##which = mul##which * (gen##which - (t * (mod##which / mul##which))) -    \
+                     t * ((mod##which % mul##which));                                 \
+        if (gen##which < 0) {                                                         \
+            gen##which += mod##which;                                                 \
+        }                                                                             \
+    }
+#endif
+
+/*  LEsetSeed  --  Set seed for generator.  Subsequent values will be based
+		   on the given nonzero seed.  */
+
+void LEsetSeed(int32 seed)
+{
+    int32 i;
+
+    assert(seed != 0);
+
+    gen1 = gen2 = (int32) (seed & 0x7FFFFFFFL);
+
+    /* "Warm up" the generator for a number of rounds to eliminate
+       any residual inflence of the seed. */
+
+    for (i = 0; i < warmup; i++) {
+	updgen(1);
+    }
+
+    /* Fill the shuffle table with values.  */
+
+    for (i = 0; i < shuffleSize; i++) {
+	updgen(1);
+	shuffle[(shuffleSize - 1) - i] = gen1;
+    }
+    state = shuffle[0];
+}
+
+/*  LEnextByte	--  Get next byte from generator.  */
+
+unsigned char LEnextByte(void)
+{
+    int i;
+
+    updgen(1);
+    updgen(2);
+
+    /* Extract shuffle table index from most significant part
+       of the previous result. */
+
+    i = state / (1 + (((int32) mod1) - 1) / shuffleSize);
+
+    /* New state is sum of generators modulo one of their moduli.  */
+
+    state = (int32) (((shuffle[i]) + ((unsigned int32) gen2)) % mod1);
+
+    /* Replace value in shuffle table with generator 1 result.	*/
+
+    shuffle[i] = gen1;
+
+    return (unsigned char) (state / (1 + (((int32) mod1) - 1) / 256));
+}
diff --git a/lecuyer.h b/lecuyer.h
new file mode 100644
index 0000000..118c128
--- /dev/null
+++ b/lecuyer.h
@@ -0,0 +1,8 @@
+/*
+
+    Definitions for L'Ecuyer pseudorandom sequence generator.
+
+*/
+
+extern void LEsetSeed(long seed);
+extern unsigned char LEnextByte(void);
diff --git a/network.c b/network.c
new file mode 100644
index 0000000..b266358
--- /dev/null
+++ b/network.c
@@ -0,0 +1,368 @@
+/* PROGRAM:	eggsh
+ * FILE:	$Header: /home/egg/src/RCS/network.c,v 1.7 1999/02/28 20:14:20 ghn Exp $
+ * PURPOSE:	Network communication functions
+ * AUTHOR:	Greg Nelson
+ * DATE:	98-05-09
+ *
+ * REVISED:
+ * $Log: network.c,v $
+ * Revision 1.7  1999/02/28 20:14:20  ghn
+ * Version 5.1: Modified InitNetwork to take interface (addr) argument as
+ * well as port, and handle various cases of interface (NULL, IP,
+ * hostname) gracefully.  Modified NetUp to call this new version.
+ *
+ * Revision 1.6  1999/01/02 00:01:01  ghn
+ * Socket and sockaddr_in corrections suggested by Mike Cheponis
+ * incorporated.
+ * perror() turned off for ENETUNREACH/EHOSTUNREACH unless app specifies
+ * "gripe" argument to NetTalk.
+ *
+ * Revision 1.5  1998/12/31 22:07:56  ghn
+ * Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.4  1998/08/03 20:39:03  kelvin
+ * inet_ntoa warning fix, bad packet diagnostics.
+ *
+ * Revision 1.3  1998/08/01  18:51:25  ghn
+ * Added John's byte-order-independence changes.
+ *
+ * Revision 1.2  1998/08/01 17:16:39  ghn
+ * Added DND support and John's typecasts.
+ *
+ * Revision 1.1  1998/07/21 11:36:45  ghn
+ * Initial revision
+ *
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/utsname.h>
+#include <string.h>
+#include "global.h"
+#include "genlib.h"
+#include "network.h"
+#include "errnos.h"
+
+#define MAXBUFSIZE	512
+char		buffer[MAXBUFSIZE];
+
+/* Eventually, these might deal with encryption and decryption or
+   validation processes, but until such time as we actually do
+   something with these, they are no-ops. */
+#define PktEncrypt(buf, len)	ERR_NONE
+#define PktDecrypt(buf, len)	ERR_NONE
+
+#ifdef HEXDUMP
+extern void xd(FILE *out, void *bub, int bufl, int dochar);
+#endif
+
+int32 InitNetwork(char *addr, int32 port) {
+  struct protoent	*pp;
+  struct hostent	*hp;
+  struct sockaddr_in	sin;
+  struct utsname	uts;
+  int32 		sd;
+  int32 		argp;
+
+  if ((pp = getprotobyname("udp")) == NULL) {
+    perror("getprotobyname");
+    exit(-1);
+  }
+
+  /* Optimistically: */
+  memset(&sin, 0, sizeof(struct sockaddr_in));
+  sin.sin_port = htons(port);
+  sin.sin_family = AF_INET;
+
+  /* Try to convert dotted quad.  Hope this is okay for null addr? */
+  if (!addr || !inet_aton(addr, &(sin.sin_addr))) {
+    /* Nope, so try to gethostbyname */
+    if (!addr) {
+      /* No addr at all, use host name from uname */
+      if (uname(&uts) < 0) {
+	perror("uname");
+	exit(-1);
+      }
+    } else {
+      strcpy(uts.nodename, addr);
+    }
+    
+    if ((hp = gethostbyname(uts.nodename)) == NULL) {
+      fprintf(stderr, "gethostbyname(%s): %s", uts.nodename, strerror(errno));
+      exit(-1);
+    }
+
+    if (hp->h_addrtype != AF_INET) {
+      fprintf(stderr, "Host is not on the internet!\n");
+      exit(-1);
+    }
+
+    memcpy(&(sin.sin_addr), hp->h_addr, hp->h_length);
+  }
+
+  if ((sd = socket(PF_INET, SOCK_DGRAM, 0)) <= 0) {
+    printf("Could not make socket\n");
+    exit(-1);
+  }
+  
+  if (bind(sd, (struct sockaddr *)(&sin), sizeof(sin)) != 0) {
+    if (errno == EADDRNOTAVAIL) {
+      /* Network probably not up yet. */
+      close(sd);	/* Error pointed out my Mike Cheponis */
+      return ERR_NOREPLY;
+    }
+    perror("bind");
+    exit(-1);
+  }
+
+  argp = 1;
+#ifndef Solaris
+  if (ioctl(sd, FIONBIO, (char *)&argp) != 0) {
+    perror("ioctl FIONBIO");
+    exit(-1);
+  }
+#endif
+   
+  return sd;
+}
+
+/* Bring net up with command */
+int32 NetUp(char *cmd, char *addr, int32 port) {
+  int res;
+
+  res = system(cmd);
+  /* 0x7e00 = perm denied
+     0x7f00 = command not found
+     256 * cmd if command runs */
+  if (res != 0) return ERR_OTHER;
+
+  return InitNetwork(addr, port);
+}
+
+/* Bring net down with command */
+int NetDown(char *cmd, int32 oldsd) {
+  int res;
+
+  /* Close existing connection */
+  if (oldsd >= 0) close(oldsd);
+
+  res = system(cmd);
+  if (res != 0) return ERR_OTHER;
+
+  return ERR_NONE;
+}
+
+int NetGetAddr(struct sockaddr_in *sin, char *host, uint16 port) {
+  struct hostent	*hp;
+
+  if ((hp = gethostbyname(host)) == NULL) {
+    fprintf(stderr, "gethostbyname(%s): %s", host, strerror(errno));
+    return ERR_INRANGE;
+  }
+
+  if (hp->h_addrtype != AF_INET) {
+    fprintf(stderr, "Host is not on the internet!\n");
+    return ERR_INRANGE;
+  }
+
+  memset(sin, 0, sizeof(struct sockaddr_in));
+  sin->sin_port = htons(port);
+  sin->sin_family = AF_INET;
+  memcpy(&(sin->sin_addr), hp->h_addr, hp->h_length);
+  
+  return ERR_NONE;
+}
+
+/* Listen for a data request.
+
+   Listen on specified socket sd.  When one is received, validate the
+   checksum, and, if successful, allocate memory and stuff it as a
+   character array.  Return the remote sockaddr_in, if the sin pointer
+   is not null, and block until something interesting happens if block
+   is true. */
+int NetListen(int sd, char **pktbuf, 
+	      struct sockaddr_in *sin,
+	      int block) {
+  fd_set		fdset;
+  struct timeval	timeout, *top;
+  int32 		nfound;
+  int32 		size;
+  int32 		count;
+  int32 		res;
+  short 		pktsize;
+  uint16		pkttype, cksumt, cksumc;
+
+  if (sd < 0) return ERR_INRANGE;
+
+  FD_ZERO(&fdset);
+  FD_SET(sd, &fdset);
+  timeout.tv_sec = timeout.tv_usec = 0;
+
+  /* Wait for an incoming connection.
+     If block is true, we wait indefinitely; otherwise, we
+     return immediately because of zero timeout. */
+
+  if (block) top = NULL; else top = &timeout;
+  nfound = select(FD_SETSIZE, &fdset, 0, 0, top);
+
+  if (nfound < 0) {
+    if (errno == EWOULDBLOCK) return ERR_COMM_TMOUT;
+    perror("select");
+    return ERR_OTHER;
+  }
+
+  /* No connections, go back to main loop. */
+  if (nfound == 0) return ERR_COMM_TMOUT;
+
+#ifdef DEBUG
+  fprintf(stderr, "Net port got a request!\n");
+#endif
+
+  if (!FD_ISSET(sd, &fdset)) {
+    fprintf(stderr, "Confused condition -- FD not part of set.\n");
+    return 0;
+  }
+
+  size = sizeof(*sin);
+  count = recvfrom(sd, buffer, MAXBUFSIZE, 0,
+		   (struct sockaddr *)sin, (int *)&size);
+  if (count < 0) {
+    /* Don't wait for it. */
+    if (errno == EWOULDBLOCK) return ERR_COMM_TMOUT;
+    perror("recvfrom");
+    return ERR_OTHER;
+  }
+
+#ifdef HEXDUMP
+  fprintf(stderr, "Received %ld bytes from %s\n", count,
+    inet_ntoa(sin->sin_addr));
+  xd(stderr, buffer, count, FALSE);
+#endif
+
+  /* Mangle buffer as needed */
+  if ((res = PktDecrypt(buffer, count)) < 0) {
+    fprintf(stderr, "Packet decryption failed with %d.\n", (int)res);
+    return res;
+  }
+
+  /* Verify length and CRC of packet.  In making these
+     protocol-level sanity checks, we transform the relevant
+     fields in the packet from network to host byte order
+     as required.  Note, however, that the packet returned
+     to the caller remains, in its entirety, in network
+     byte order and even references to protocol-common
+     fields, if made, must be converted by the code which
+     invokes this function. */
+
+  { uint16 rpkttype, rpktsize, rcrc;
+
+    memcpy(&rpkttype, buffer, sizeof rpkttype);
+    memcpy(&rpktsize, buffer + 2, sizeof rpktsize);
+    memcpy(&rcrc, buffer + (count - 2), sizeof rcrc);
+    pktsize = ntohs(rpktsize);
+    if (pktsize != count) {
+#ifdef DEBUG
+        fprintf(stderr, "** Bad packet length: pktsize = %d, count = %ld.\n",
+	    pktsize, count);
+#endif
+	return ERR_PKT_BADLEN;
+    }
+    cksumt = ntohs(rcrc);
+    cksumc = BlockCRC16((byte *) buffer, count - 2);
+    if (cksumc != cksumt) {
+#ifdef DEBUG
+        fprintf(stderr, "** Bad packet CRC: packet = %04X, computed = %04X.\n",
+	    cksumt, cksumc);
+#endif
+	return ERR_PKT_CKSUM;
+    }
+    pkttype = ntohs(rpkttype);
+  }
+
+#ifdef DEBUG
+  fprintf(stderr, "Recv packet type %04x, %d bytes (hdr), cks = %04x\n",
+	  pkttype, pktsize, cksumt);
+#endif /* DEBUG */
+  
+  /* Hand back the packet */
+  *pktbuf = (char *)malloc(count);
+  memcpy(*pktbuf, buffer, count);
+
+  return ERR_NONE;
+}
+
+/* Send a data packet.
+
+   Checksum the packet, create a socket, and send it to the specified
+   port of the specified host.	Length of packet to be extracted from
+   packet header. */
+
+  /* The entire contents of the packet passed to NetTalk must
+     be in network byte order.	Fields within the packet used
+     to append the CRC, determine the number of bytes to send,
+     etc. are converted to host byte order as needed. */
+
+int NetTalk(struct sockaddr_in *sin, char *pkt, int gripe) {
+  uint16		pktsize, cksum;
+  static struct protoent *pp = NULL;
+  int			i, out_sock;
+
+  memcpy(&pktsize, pkt + 2, 2);
+  pktsize = ntohs(pktsize);
+#ifdef DEBUG
+  if (pktsize > 1500) {
+    fprintf(stderr, "Bogus packet size of %ud bytes.  Suspect byte alignment bug.\n", pktsize);
+    abort();
+  }
+#endif
+  cksum = htons(BlockCRC16((byte *) pkt, pktsize - sizeof(uint16)));
+  memcpy(pkt+pktsize-sizeof(uint16), &cksum, sizeof(uint16));
+
+  if (pp == NULL) {		      /* Only get protocol code the first time */
+    if ((pp = getprotobyname("udp")) == NULL) {
+      perror("getprotobyname");
+      return ERR_OTHER;
+    }
+  }
+
+  if ((out_sock = socket(AF_INET, SOCK_DGRAM, pp->p_proto)) < 0) {
+    perror("socket");
+    return ERR_OTHER;
+  }
+	
+  i = sendto(out_sock, pkt, pktsize, 
+	     0, (struct sockaddr *)sin,
+	     sizeof(struct sockaddr));
+  if (i == -1) {
+    /* We only report on certain errors if told to "gripe", because
+       it is a normal occurence if in PERM mode with a variably
+       available net connection. */
+    if ((errno != ENETUNREACH && errno != EHOSTUNREACH) || gripe) perror("sendto");
+    close(out_sock);
+    return ERR_OTHER;
+  }
+
+#ifdef HEXDUMP
+  fprintf(stderr, "Sent %d bytes to %s\n", pktsize, inet_ntoa(sin->sin_addr));
+  xd(stderr, pkt, pktsize, FALSE);
+#endif
+
+  i = close(out_sock);
+  if (i < 0) {
+    perror("close");
+  }
+  
+  return ERR_NONE;
+}
diff --git a/network.h b/network.h
new file mode 100644
index 0000000..d8b8102
--- /dev/null
+++ b/network.h
@@ -0,0 +1,76 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/network.h,v 1.6 1999/02/28 20:14:26 ghn Exp $
+ * PURPOSE:     Definitions for network communication functions
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-05-09
+ *
+ * REVISED:
+ * $Log: network.h,v $
+ * Revision 1.6  1999/02/28 20:14:26  ghn
+ * Version 5.1: Modified InitNetwork to take interface (addr) argument as
+ * well as port, and handle various cases of interface (NULL, IP,
+ * hostname) gracefully.  Modified NetUp to call this new version.
+ *
+ * Revision 1.5  1999/01/02 00:02:24  ghn
+ * Modified NetTalk() api to offer "gripe" argument to silence some perror()s.
+ *
+ * Revision 1.4  1998/12/31 22:11:05  ghn
+ *  Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.3  1998/08/01 18:51:25  ghn
+ * Added John's byte-order-independence changes.
+ *
+ * Revision 1.2  1998/08/01 17:17:40  ghn
+ * Added DND support.
+ *
+ * Revision 1.1  1998/07/21 11:36:34  ghn
+ * Initial revision
+ *
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#ifndef _NETWORK_H
+#define _NETWORK_H
+
+#include <netinet/in.h>
+
+#ifdef TESTPORT
+#define EGGPORT         2074
+#define BASKETPORT      2075
+#else
+#define	EGGPORT		1105
+#define	BASKETPORT	2510
+#endif
+
+/* Initialize network subsystem, returning socket descriptor */
+extern int32 InitNetwork(char *addr, int32 port);
+
+/* Bring net up with command */
+extern int32 NetUp(char *cmd, char *addr, int32 port);
+
+/* Bring net down with command */
+extern int NetDown(char *cmd, int32 oldsd);
+
+/* Get a sockaddr given a host and port */
+extern int NetGetAddr(struct sockaddr_in *sin, char *host, uint16 port);
+
+/* Listen for a data request.
+
+   Listen on specified socket sd.  When one is received, validate the
+   checksum, and, if successful, allocate memory and stuff it as a
+   character array.  Return the remote sockaddr_in, if the sin pointer
+   is not null, and block until something interesting happens if block
+   is true. */
+extern int NetListen(int sd, char **pktbuf, 
+		     struct sockaddr_in *sin,
+		     int block);
+
+/* Send a data packet.
+
+   Create a socket, checksum the packet, and send it to the specified
+   addr in sin.  Length of packet to be extracted from packet
+   header. */
+extern int NetTalk(struct sockaddr_in *sin, char *pkt, int gripe);
+
+#endif /* !_NETWORK_H */
diff --git a/reg.h b/reg.h
new file mode 100644
index 0000000..608fdbb
--- /dev/null
+++ b/reg.h
@@ -0,0 +1,76 @@
+/*
+
+	Random event generator definitions
+
+	This file contains definitions common to all random
+	event generators.  All implement the interface defined
+	here.
+
+*/
+
+
+typedef struct {
+    uint16 type;		      /* Device type code (allows supporting
+					 multiple devices with common driver
+					 code). */
+    uint16 port;		      /* Port ID.  Meaning depends on nature
+					 of hardware, and may mean nothing at
+					 all. */
+    uint32 baud;		      /* Baud rate for devices connected to
+					 a serial port.  This may have a
+					 different meaning for devices
+					 connected to, for example, a
+					 parallel port or SCSI string. */
+} DevOpts;
+
+typedef struct {
+    char *reg_name;		      /* Name of REG, corresponding to
+					 the name on the REG statement
+					 in .eggrc */
+    uint16 reg_type;		      /* REG type code, corresponding
+					 to type field in the DevOpts
+					 structure. */
+
+    /* The following functions are used to call the methods
+       of the REG device driver. */
+
+    /* Open a device. 
+
+       DevOpts should contain any necessary information to determine how
+       this is to be done.  The return value, if >= 0, is a device handle.
+       Otherwise it indicates an error. */
+
+    int32 (*reg_OpenDev)(DevOpts *opts);
+
+    /* Evaluate speed.
+
+       dd is the device handle returned by opening the device.	The
+       function returns the estimated number of bits/second that the
+       device will produce, which should be used as a limit in setting the
+       data rate. */
+
+    int32 (*reg_EvalSpeed)(int32 dd);
+
+    /* Sample from a device.
+
+       dd is the device handle returned by opening the device.	The number
+       of bits requested will be sampled from the device immediately
+       (waiting as needed to collect the data, with no discards) and the
+       result will be returned. */
+
+    int32 (*reg_Sample)(int32 dd, uint16 bits);
+
+    /* Discard spare data from device.
+
+       dd is the device handle returned by opening the device.	The input
+       stream is consumed until a wait would be required.  The number of
+       bits discarded is returned. */
+
+    int32 (*reg_Discard)(int32 dd);
+
+    /* Close a device.
+
+       Closes a specified device handle. */
+
+    int32 (*reg_CloseDev)(int32 dd);
+} REG_driver;
diff --git a/reg_orion.c b/reg_orion.c
new file mode 100644
index 0000000..d6938ef
--- /dev/null
+++ b/reg_orion.c
@@ -0,0 +1,306 @@
+/* PROGRAM:	eggsh
+ * FILE:	$Header: /home/egg/src/RCS/reg_orion.c,v 1.1 1998/12/31 22:04:39 ghn Exp $
+ * PURPOSE:	PEAR (Bradish box/micro-REG) hardware interface
+ * AUTHOR:	Greg Nelson
+ * DATE:	98-04-12
+ *
+ * REVISED:	$Log: reg_orion.c,v $
+ * REVISED:	Revision 1.1  1998/12/31 22:04:39  ghn
+ * REVISED:	Initial revision
+ * REVISED:
+ * REVISED:	Revision 1.3  1998/08/01 18:50:39  ghn
+ * REVISED:     Added John's byte-order-independence changes and PSEUDO support.
+ * REVISED:
+ * REVISED:	Revision 1.2  1998/08/01 17:13:51  ghn
+ * REVISED:     Added John's Solaris support and DUMPREG option.
+ * REVISED:
+ * REVISED:	Revision 1.1  1998/07/21 11:37:41  ghn
+ * REVISED:	Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+/* Define this to dump samples from the REG which we actually use into
+   a file named dumpreg.dat.  This can be used to debug serial port
+   mode problems (for example, setting the character frame to 7 bits,
+   or telling it to ignore breaks, which will lose all zero bytes. */
+/* #define DUMPREG */
+
+#include <stdio.h>
+#ifdef __USE_BSD
+#undef __USE_BSD
+#endif
+#define __USE_BSD
+#include <termios.h>
+#undef __USE_BSD
+#include <unistd.h>
+#include <fcntl.h>
+#define __USE_BSD
+#include <errno.h>
+#undef __USE_BSD
+
+#include "global.h"
+#include "genlib.h"
+#include "reg.h"
+
+#define MAXDEV	20
+
+/*  The Orion REG is powered by the serial port into which
+    it is plugged.  If the port is not providing power to
+    the REG before we initialise it, the REG may deliver
+    garbage data as the power comes up.  To guard against
+    this we take two precautions.  First of all, we sleep
+    REG_INIT seconds after initialising the serial port to
+    let the REG start up and stabilise after power is
+    turned on, and we further discard REG_DISCARD initial
+    samples which may have been queued as the REG was
+    powering up.  If either of these symbols is not defined
+    or zero, the corresponding start-up action will not
+    be taken.  */
+
+#define REG_INIT	10	      /* REG power on delay */
+#define REG_DISCARD	1024	      /* Bytes to discard at start-up */
+
+static int32 oldbits[MAXDEV], bitsleft[MAXDEV];
+
+#ifdef DUMPREG
+static FILE *dumpfile;		      /* REG dump file handle */
+static unsigned char dumpbuf[1024];   /* REG dump buffer */
+static int dumpptr = 0; 	      /* Pointer into dump buffer */
+#endif
+
+#ifdef FLUSH
+extern int flush_fd;		      /* File descriptor for auto-flush */
+#endif
+
+static int32 OpenDev(DevOpts *opts) {
+  char ttydev[30];
+  speed_t baudcon;
+  struct termios tt;
+  int32 TTY_fd, res;
+
+#ifdef DUMPREG
+  dumpfile = fopen("dumpreg.dat", "w");
+  setbuf(dumpfile, NULL);
+  dumpptr = 0;
+#endif
+
+#ifdef Solaris
+  /* Serial ports (at least built-in ones) have names of
+     /dev/term/a, /dev/term/b, etc.  Map the port numbers
+     from the RC file into this nomenclature, with "1"
+     designating /dev/term/a. */
+#ifdef Irix
+  sprintf(ttydev, "/dev/ttyd%d", opts->port);
+#else
+  sprintf(ttydev, "/dev/term/%c", 'a' + (opts->port - 1));
+#endif
+#else
+  sprintf(ttydev, "/dev/ttyS%d", opts->port);
+#endif
+
+  switch(opts->baud) {
+  case 1200: baudcon = B1200; break;
+  case 2400: baudcon = B2400; break;
+  case 4800: baudcon = B4800; break;
+  case 9600: baudcon = B9600; break;
+  case 19200: baudcon = B19200; break;
+  case 38400: baudcon = B38400; break;
+#ifndef Irix
+  case 115200: baudcon = B115200; break;
+#endif
+  default:
+    printf("%s: Baud rate %ld not supported.\n", pgmname, opts->baud);
+    return -1;
+  }
+
+  fprintf(stderr, "Opening %s at %ld\n", ttydev, opts->baud);
+  if ((TTY_fd = open(ttydev, O_RDONLY
+#ifdef CPU_BOUND
+				    | O_NDELAY
+#endif
+      )) < 0) {
+    perror(pgmname);
+fprintf(stderr, "Error in open(%s)\n", ttydev);
+    return -1;
+  }
+
+  if (TTY_fd >= MAXDEV) {
+    fprintf(stderr, "%s: Too many devices open.\n", pgmname);
+    close(TTY_fd);
+    return -1;
+  }
+
+  res = tcgetattr(TTY_fd, &tt);
+#ifdef Solaris
+  tt.c_iflag = 0;
+  tt.c_oflag = 0;
+#ifdef SWITCH_READ
+  tt.c_cflag = baudcon | CS8 | CLOCAL;
+#else
+  tt.c_cflag = baudcon | CS8 | CREAD | CLOCAL;
+#endif
+  tt.c_lflag = 0;
+  tt.c_cc[VMIN] = 1;	/* This many chars satisfies reads */
+  tt.c_cc[VTIME] = 0;	/* or in this many tenths of seconds */
+#else
+  res = cfsetospeed(&tt, baudcon); 
+  cfmakeraw(&tt);
+  tt.c_oflag &= (~(TABDLY | ONLCR));
+#endif
+  res = tcsetattr(TTY_fd, TCSANOW, &tt);
+
+  oldbits[TTY_fd] = bitsleft[TTY_fd] = 0;
+
+  /* Perform start-up power on delay and data flush. */
+
+#ifdef REG_INIT
+  if (REG_INIT > 0) {
+    sleep(REG_INIT);
+  }
+#endif
+
+#ifdef REG_DISCARD
+  if (REG_DISCARD > 0) {
+    int d, n1;
+    char c1;
+
+    for (d = 0; d < REG_DISCARD; d++) {
+      do {
+	n1 = read(TTY_fd, &c1, 1);
+      } while (n1 == 0 || (n1 == -1 && errno == EAGAIN));
+    }
+  }
+#endif
+
+#ifdef FLUSH
+  flush_fd = TTY_fd;
+#endif
+
+  return TTY_fd;
+}
+
+static int32 Sample(int32 dd, uint16 bits) {
+  int32 bc, sum, n1;
+  uint8 c1;
+
+#ifdef Solaris
+#ifdef SWITCH_READ
+  struct termios tt;
+
+  tcgetattr(dd, &tt);
+  tt.c_cflag |= CREAD;
+  tcsetattr(dd, TCSANOW, &tt);
+#endif
+#endif
+
+  if (dd < 0) return -1;
+
+  sum = bc = 0;
+  while (bc < bits) {
+    if (bitsleft[dd]) {
+      sum += (oldbits[dd] & 0x01);
+      oldbits[dd] >>= 1;
+      bitsleft[dd]--;
+      bc++;
+    } else {
+      do {
+	n1 = read(dd, &c1, 1);
+      } while (n1 == 0 || (n1 == -1 && errno == EAGAIN));
+      if (n1 == -1) {
+	/* Fatal error occurred, die now? */
+	return -1;
+      }
+
+      /* Orion REG does not compensate for first order bias.  XOR
+	 each sample with 01010101b to invert the sense of
+	 alternate bits in the samples. */
+
+      c1 ^= 0x55;
+#ifdef DUMPREG
+      dumpbuf[dumpptr++] = c1;
+      if (dumpptr >= sizeof(dumpbuf)) {
+	fwrite(dumpbuf, sizeof(dumpbuf), 1, dumpfile);
+	dumpptr = 0;
+      }
+#endif
+      oldbits[dd] = c1;
+      bitsleft[dd] = 8;
+    }
+  }
+
+#ifdef Solaris
+#ifdef SWITCH_READ
+  tcgetattr(dd, &tt);
+  tt.c_cflag &= ~CREAD;
+  tcsetattr(dd, TCSANOW, &tt);
+#endif
+#endif
+  return sum;
+}
+
+#define SAMP_PERIOD	1000	/* msec */
+#define MARGIN		.95	/* how much to headroom to allow in
+				   speed measurement */
+
+static int32 EvalSpeed(int32 dd) {
+  struct timeval start, end;
+  int32 bitct, samp;
+
+  if (dd < 0) return -1;
+
+  gettimeofday(&start, NULL);
+  bitct = 0;
+  while (1) {
+    gettimeofday(&end, NULL);
+    if (deltams(&end, &start) >= SAMP_PERIOD) break;
+    samp = Sample(dd, 1);
+    bitct++;
+  }
+
+  return (int32)(bitct * MARGIN);
+}
+
+static int32 Discard(int32 dd) {
+  int32 disc;
+#ifdef CPU_BOUND
+  int32  n1;
+  uint8 c1;
+#endif
+  
+  if (dd < 0) return -1;
+
+  disc = bitsleft[dd];
+  bitsleft[dd] = 0;
+
+#ifdef CPU_BOUND
+  do {
+    n1 = read(dd, &c1, 1);
+    if (n1 == 1) disc++;
+  } while (n1 == 1);
+#else
+  tcflush(dd, TCIFLUSH);
+#endif
+
+  return disc;
+}
+
+static int32 CloseDev(int32 dd) {
+  if (dd < 0) return -1;
+
+  close(dd);
+  return 0;
+}
+
+/*  Driver description table.  */
+
+REG_driver REG_orion = {
+                        "ORION", 
+			1000,
+			OpenDev,
+			EvalSpeed,
+			Sample,
+			Discard,
+			CloseDev
+		      };
diff --git a/reg_pear.c b/reg_pear.c
new file mode 100644
index 0000000..bc79bb7
--- /dev/null
+++ b/reg_pear.c
@@ -0,0 +1,232 @@
+/* PROGRAM:	eggsh
+ * FILE:	$Header: /home/egg/src/RCS/reg_pear.c,v 1.1 1998/12/31 22:04:39 ghn Exp $
+ * PURPOSE:	PEAR (Bradish box/micro-REG) hardware interface
+ * AUTHOR:	Greg Nelson
+ * DATE:	98-04-12
+ *
+ * REVISED:	$Log: reg_pear.c,v $
+ * REVISED:	Revision 1.1  1998/12/31 22:04:39  ghn
+ * REVISED:	Initial revision
+ * REVISED:
+ * REVISED:	Revision 1.3  1998/08/01 18:50:39  ghn
+ * REVISED:     Added John's byte-order-independence changes and PSEUDO support.
+ * REVISED:
+ * REVISED:	Revision 1.2  1998/08/01 17:13:51  ghn
+ * REVISED:     Added John's Solaris support and DUMPREG option.
+ * REVISED:
+ * REVISED:	Revision 1.1  1998/07/21 11:37:41  ghn
+ * REVISED:	Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+/* Define this to dump samples from the REG which we actually use into
+   a file named dumpreg.dat.  This can be used to debug serial port
+   mode problems (for example, setting the character frame to 7 bits,
+   or telling it to ignore breaks, which will lose all zero bytes. */
+/* #define DUMPREG */
+
+#include <stdio.h>
+#ifdef __USE_BSD
+#undef __USE_BSD
+#endif
+#define __USE_BSD
+#include <termios.h>
+#undef __USE_BSD
+#include <unistd.h>
+#include <fcntl.h>
+#define __USE_BSD
+#include <errno.h>
+#undef __USE_BSD
+
+#include "global.h"
+#include "genlib.h"
+#include "reg.h"
+
+#define MAXDEV	20
+
+static int32 oldbits[MAXDEV], bitsleft[MAXDEV];
+
+#ifdef DUMPREG
+static FILE *dumpfile;		      /* REG dump file handle */
+static unsigned char dumpbuf[1024];   /* REG dump buffer */
+static int dumpptr = 0; 	      /* Pointer into dump buffer */
+#endif
+
+static int32 OpenDev(DevOpts *opts) {
+  char ttydev[30];
+  speed_t baudcon;
+  struct termios tt;
+  int32 TTY_fd, res;
+
+#ifdef DUMPREG
+  dumpfile = fopen("dumpreg.dat", "w");
+  setbuf(dumpfile, NULL);
+  dumpptr = 0;
+#endif
+
+#ifdef Solaris
+  /* Serial ports (at least built-in ones) have names of
+     /dev/term/a, /dev/term/b, etc.  Map the port numbers
+     from the RC file into this nomenclature, with "1"
+     designating /dev/term/a. */
+#ifdef Irix
+  sprintf(ttydev, "/dev/ttyd%d", opts->port);
+#else
+  sprintf(ttydev, "/dev/term/%c", 'a' + (opts->port - 1));
+#endif
+#else
+  sprintf(ttydev, "/dev/ttyS%d", opts->port);
+#endif
+
+  switch(opts->baud) {
+  case 1200: baudcon = B1200; break;
+  case 2400: baudcon = B2400; break;
+  case 4800: baudcon = B4800; break;
+  case 9600: baudcon = B9600; break;
+  case 19200: baudcon = B19200; break;
+  case 38400: baudcon = B38400; break;
+#ifndef Irix
+  case 115200: baudcon = B115200; break;
+#endif
+  default:
+    printf("%s: Baud rate %ld not supported.\n", pgmname, opts->baud);
+    return -1;
+  }
+
+  fprintf(stderr, "Opening %s at %ld\n", ttydev, opts->baud);
+  if ((TTY_fd = open(ttydev, O_RDONLY
+#ifdef CPU_BOUND
+				    | O_NDELAY
+#endif
+      )) < 0) {
+    perror(pgmname);
+    return -1;
+  }
+
+  if (TTY_fd >= MAXDEV) {
+    fprintf(stderr, "%s: Too many devices open.\n", pgmname);
+    close(TTY_fd);
+    return -1;
+  }
+
+  res = tcgetattr(TTY_fd, &tt);
+#ifdef Solaris
+  tt.c_iflag = 0;
+  tt.c_oflag = 0;
+  tt.c_cflag = baudcon | CS8 | CREAD | CLOCAL;
+  tt.c_lflag = 0;
+  tt.c_cc[VMIN] = 1;	/* This many chars satisfies reads */
+  tt.c_cc[VTIME] = 0;	/* or in this many tenths of seconds */
+#else
+  res = cfsetospeed(&tt, baudcon); 
+  cfmakeraw(&tt);
+  tt.c_oflag &= (~(TABDLY | ONLCR));
+#endif
+  res = tcsetattr(TTY_fd, TCSANOW, &tt);
+
+  oldbits[TTY_fd] = bitsleft[TTY_fd] = 0;
+  return TTY_fd;
+}
+
+static int32 Sample(int32 dd, uint16 bits) {
+  int32 bc, sum, n1;
+  uint8 c1;
+
+  if (dd < 0) return -1;
+
+  sum = bc = 0;
+  while (bc < bits) {
+    if (bitsleft[dd]) {
+      sum += (oldbits[dd] & 0x01);
+      oldbits[dd] >>= 1;
+      bitsleft[dd]--;
+      bc++;
+    } else {
+      do {
+	n1 = read(dd, &c1, 1);
+      } while (n1 == 0 || (n1 == -1 && errno == EAGAIN));
+      if (n1 == -1) {
+	/* Fatal error occurred, die now? */
+	return -1;
+      }
+#ifdef DUMPREG
+      dumpbuf[dumpptr++] = c1;
+      if (dumpptr >= sizeof(dumpbuf)) {
+	fwrite(dumpbuf, sizeof(dumpbuf), 1, dumpfile);
+	dumpptr = 0;
+      }
+#endif
+      oldbits[dd] = c1;
+      bitsleft[dd] = 8;
+    }
+  }
+
+  return sum;
+}
+
+#define SAMP_PERIOD	1000	/* msec */
+#define MARGIN		.95	/* how much to headroom to allow in
+				   speed measurement */
+
+static int32 EvalSpeed(int32 dd) {
+  struct timeval start, end;
+  int32 bitct, samp;
+
+  if (dd < 0) return -1;
+
+  gettimeofday(&start, NULL);
+  bitct = 0;
+  while (1) {
+    gettimeofday(&end, NULL);
+    if (deltams(&end, &start) >= SAMP_PERIOD) break;
+    samp = Sample(dd, 1);
+    bitct++;
+  }
+
+  return (int32)(bitct * MARGIN);
+}
+
+static int32 Discard(int32 dd) {
+  int32 disc;
+#ifdef CPU_BOUND
+  int32  n1;
+  uint8 c1;
+#endif
+  
+  if (dd < 0) return -1;
+
+  disc = bitsleft[dd];
+  bitsleft[dd] = 0;
+
+#ifdef CPU_BOUND
+  do {
+    n1 = read(dd, &c1, 1);
+    if (n1 == 1) disc++;
+  } while (n1 == 1);
+#else
+  tcflush(dd, TCIFLUSH);
+#endif
+
+  return disc;
+}
+
+static int32 CloseDev(int32 dd) {
+  if (dd < 0) return -1;
+
+  close(dd);
+  return 0;
+}
+
+/*  Driver description table.  */
+
+REG_driver REG_pear = {
+                        "PEAR", 
+			0,
+			OpenDev,
+			EvalSpeed,
+			Sample,
+			Discard,
+			CloseDev
+		      };
diff --git a/reg_pseudo.c b/reg_pseudo.c
new file mode 100644
index 0000000..bd35883
--- /dev/null
+++ b/reg_pseudo.c
@@ -0,0 +1,134 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/reg_pseudo.c,v 1.1 1998/12/31 22:04:39 ghn Exp $
+ * PURPOSE:     PEAR (Bradish box/micro-REG) hardware interface
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-04-12
+ *
+ * REVISED:     $Log: reg_pseudo.c,v $
+ * REVISED:     Revision 1.1  1998/12/31 22:04:39  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * REVISED:     Revision 1.3  1998/08/01 18:50:39  ghn
+ * REVISED:     Added John's byte-order-independence changes and PSEUDO support.
+ * REVISED:
+ * REVISED:     Revision 1.2  1998/08/01 17:13:51  ghn
+ * REVISED:     Added John's Solaris support and DUMPREG option.
+ * REVISED:
+ * REVISED:     Revision 1.1  1998/07/21 11:37:41  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+/* Define this to dump samples from the REG which we actually use into
+   a file named dumpreg.dat.  */
+/* #define DUMPREG */
+
+#include <stdio.h>
+#include <unistd.h>
+
+#include "global.h"
+#include "genlib.h"
+#include "reg.h"
+#include "lecuyer.h"
+
+#define MAXDEV  20
+
+static int32 oldbits[MAXDEV], bitsleft[MAXDEV];
+
+#ifdef DUMPREG
+static FILE *dumpfile;                /* REG dump file handle */
+static unsigned char dumpbuf[1024];   /* REG dump buffer */
+static int dumpptr = 0;               /* Pointer into dump buffer */
+#endif
+
+static int32 OpenDev(DevOpts *opts) {
+    int32 seed;
+    int i;
+
+    seed = time(NULL);
+    LEsetSeed(seed);
+
+    for (i = 0; i < 37; i++) {
+        seed = (seed << 3) ^ LEnextByte();
+    }
+    LEsetSeed(seed);
+    seed = LEnextByte();
+    for (i = 0; i < (seed & 0x37); i++) {
+        (void) LEnextByte();
+    }
+    return 0;
+}
+
+static int32 Sample(int32 dd, uint16 bits) {
+  int32 bc, sum;
+  uint8 c1;
+
+  sum = bc = 0;
+  while (bc < bits) {
+    if (bitsleft[dd]) {
+      sum += (oldbits[dd] & 0x01);
+      oldbits[dd] >>= 1;
+      bitsleft[dd]--;
+      bc++;
+    } else {
+      c1 = LEnextByte();
+#ifdef DUMPREG
+      dumpbuf[dumpptr++] = c1;
+      if (dumpptr >= sizeof(dumpbuf)) {
+        fwrite(dumpbuf, sizeof(dumpbuf), 1, dumpfile);
+        dumpptr = 0;
+      }
+#endif
+      oldbits[dd] = c1;
+      bitsleft[dd] = 8;
+    }
+  }
+
+  return sum;
+}
+
+#define SAMP_PERIOD     1000    /* msec */
+#define MARGIN          .95     /* how much to headroom to allow in
+                                   speed measurement */
+
+static int32 EvalSpeed(int32 dd) {
+  struct timeval start, end;
+  int32 bitct, samp;
+
+  gettimeofday(&start, NULL);
+  bitct = 0;
+  while (1) {
+    gettimeofday(&end, NULL);
+    if (deltams(&end, &start) >= SAMP_PERIOD) break;
+    samp = Sample(dd, 1);
+    bitct++;
+  }
+
+  return (int32)(bitct * MARGIN);
+}
+
+static int32 Discard(int32 dd) {
+  int32 disc;
+  
+  disc = bitsleft[dd];
+  bitsleft[dd] = 0;
+  return disc;
+}
+
+static int32 CloseDev(int32 dd) {
+  return 0;
+}
+
+/*  Driver description table.  */
+
+REG_driver REG_pseudo = {
+                        "PSEUDO", 
+                        2000,
+                        OpenDev,
+                        EvalSpeed,
+                        Sample,
+                        Discard,
+                        CloseDev
+                      };
diff --git a/regs.h b/regs.h
new file mode 100644
index 0000000..8222ddd
--- /dev/null
+++ b/regs.h
@@ -0,0 +1,17 @@
+/*
+
+    Random event generator driver interface.
+
+*/
+
+#include "reg.h"
+
+extern REG_driver *configuredREG;     /* REG selected by .eggrc file */
+
+/*  Access to methods within the configured REG driver.  */
+
+#define OpenDev(opts) (*configuredREG->reg_OpenDev)(opts)
+#define EvalSpeed(dd) (*configuredREG->reg_EvalSpeed)(dd)
+#define Sample(dd, bits) (*configuredREG->reg_Sample)(dd, bits)
+#define Discard(dd) (*configuredREG->reg_Discard)(dd)
+#define CloseDev(dd) (*configuredREG->reg_CloseDev)(dd)
diff --git a/regtable.h b/regtable.h
new file mode 100644
index 0000000..b8ad192
--- /dev/null
+++ b/regtable.h
@@ -0,0 +1,13 @@
+/*
+
+    Table of available Random Event Generator drivers
+
+*/
+
+#define REGs(x)    x##pear, x##pseudo, x##orion
+
+extern REG_driver REGs(REG_);
+
+static REG_driver *reg_table[] = {
+    REGs(&REG_), NULL
+};
diff --git a/regtest.c b/regtest.c
new file mode 100644
index 0000000..e4b5123
--- /dev/null
+++ b/regtest.c
@@ -0,0 +1,120 @@
+#include <stdio.h>
+#ifdef __USE_BSD
+#undef __USE_BSD
+#endif
+#define __USE_BSD
+#include <termios.h>
+#undef __USE_BSD
+#include <unistd.h>
+#include <fcntl.h>
+#define __USE_BSD
+#include <errno.h>
+#undef __USE_BSD
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <time.h>
+#include <string.h>
+#include <utmp.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <syslog.h>
+#include "paths.h"
+
+int Sample(int fd, int bits);
+
+int main(int argc, char *argv[]) {
+  int TTY_fd;
+  int i, res, n1, mean;
+  struct termios tt;
+  speed_t baud;
+
+  if (argc != 3) {
+    printf("Usage: %s <tty> <baud>\n", argv[0]);
+    exit(-1);
+  }
+
+  switch(atoi(argv[2])) {
+  case 1200: baud = B1200; break;
+  case 2400: baud = B2400; break;
+  case 4800: baud = B4800; break;
+  case 9600: baud = B9600; break;
+  case 19200: baud = B19200; break;
+  case 38400: baud = B38400; break;
+  case 115200: baud = B115200; break;
+  default:
+    printf("%s: Baud rate %s not supported.\n", argv[0], argv[2]);
+    exit(-1);
+  }
+
+  if ((TTY_fd = open(argv[1], O_RDWR | O_NDELAY)) < 0) {
+    fprintf(stderr, "%s: %s\n", argv[1], sys_errlist[errno]);
+    exit(1);
+  }
+
+  res = tcgetattr(TTY_fd, &tt);
+  res = cfsetospeed(&tt, baud); 
+  cfmakeraw(&tt);
+  tt.c_oflag &= (~(TABDLY | ONLCR));
+  res = tcsetattr(TTY_fd, TCSANOW, &tt);
+
+  mean = 0;
+  for (i = 0; i < 100; i++) {
+    n1 = Sample(TTY_fd, 200);
+    printf("%3d ", n1);
+    fflush(stdout);
+    if (i % 20 == 19) printf("\n");
+    mean += n1;
+  }
+  printf("Mean of first 100 REG200 trials = %f\n", (double)mean / 100.0);
+
+  exit(0);
+  for (i = 100; i < 200; i++) {
+    n1 = Sample(TTY_fd, i);
+    printf("%3d: %3d\n", i, n1);
+  }
+  return 0;
+}
+
+static int oldbits = 0;
+static int bitsleft = 0;
+int Sample(int fd, int bits) {
+  int bc, sum, n1;
+  unsigned char c1;
+
+  sum = bc = 0;
+  while (bc < bits) {
+    if (bitsleft) {
+      sum += (oldbits & 0x01);
+      oldbits >>= 1;
+      bitsleft--;
+      bc++;
+    } else {
+      do {
+	n1 = read(fd, &c1, 1);
+      } while (n1 == 0 || (n1 == -1 && errno == EAGAIN));
+      if (n1 == -1) {
+	/* Fatal error occurred, die now? */
+	exit(-errno);
+      }
+      oldbits = c1;
+      bitsleft = 8;
+#if 0
+      printf("Sampled %c%c%c%c%c%c%c%c\n",
+	     ((oldbits & 0x80)?'1':'0'),
+	     ((oldbits & 0x40)?'1':'0'),
+	     ((oldbits & 0x20)?'1':'0'),
+	     ((oldbits & 0x10)?'1':'0'),
+	     ((oldbits & 0x08)?'1':'0'),
+	     ((oldbits & 0x04)?'1':'0'),
+	     ((oldbits & 0x02)?'1':'0'),
+	     ((oldbits & 0x01)?'1':'0'));
+#endif
+    }
+  }
+
+  return sum;
+}
+
+  
diff --git a/sample.basketrc b/sample.basketrc
new file mode 100644
index 0000000..09da1e6
--- /dev/null
+++ b/sample.basketrc
@@ -0,0 +1,10 @@
+#BASKET diesse 193.8.230.134
+#BASKET jura 193.8.230.130
+BASKET noosphere 128.112.35.133
+EGG diesse 37 193.8.230.134 diesse PERM 1 http://www.fourmilab.ch/
+EGG noosphere 28 128.112.35.133 noosphere PERM 1 http://noosphere.princeton.edu/
+EGG throop 1003 193.8.230.132 throop PERM 1
+EGG jura 1004 193.8.230.130 jura PERM 1
+EGG dicklnx.psy.uva.nl 1000 145.18.117.41 diesse PERM 1 http://www.psy.uva.nl/bierman
+PROTOCOL 10 10 6 200
+HTML 60 /ftp/entrenous/k/basket.html
diff --git a/sample.eggrc b/sample.eggrc
new file mode 100644
index 0000000..b8c44bc
--- /dev/null
+++ b/sample.eggrc
@@ -0,0 +1,86 @@
+# Configuration file for egg collection software
+# This specifies the egg configuration information, the contact
+# information for its basket(s), and initial data acquisition parameters.
+
+# Each line consists of a case-sensitive keyword and a series of
+# options.  Defined keywords are: 
+#
+#   EGG <name> <id> <ip addr> <primbasket> <conntype> <connival> <url>
+#
+# The primary basket <primbasket> is the name of the basket (defined
+# below) that should be contacted retrieve data from this Egg.
+# The connection type <conntype> is "PERM" (permanent) or "DND"
+# (dial-and-drop).  So far the code does not support the DND option.
+# The connection interval <connival> determines the time (in minutes)
+# between transmission attempts.  If specified, and not equal to
+# ".", <url> gives a URL (for example http://www.somesite.net/page.html)
+# which will be linked to the egg <name> in status reports.  Note that
+# this specification has meaning only in the .basketrc file.  For
+# compatibility, it is permitted in an .eggrc file, but is ignored.
+#
+#   BASKET <name> <ip addr>
+#
+# This entry tells us about the existence of a set of baskets.  The
+# basket named as primary is the one which will be contacted
+# initially. 
+#
+#   PROTOCOL <samprec> <secrec> <recpkt> <trialsz>
+#
+# Specify the default data collection protocol.  The arguments are 
+# <samprec> samples per record (1-10, though this should always be 5-10),
+# <secrec> seconds per records (1-3000),
+# <recpkt> records per packet (1-60), and 
+# <trialsz> bits per sample (32-255).
+#
+#   REG <type> <port> <baud>
+#
+# Specify hardware device.  Supported types include "PEAR" only at
+# this time.  Port is serial port number (e.g. 1 for /dev/ttyS1);
+# <baud> is baud rate.
+#
+#   NETUP <script> <args> ...
+#   NETDOWN <script> <args> ...
+#
+# Provide script files to be run to bring up and tear down the network
+# connection on demand.  These will only be used if connection type is
+# DND.
+
+#EGG halley 1 10.0.0.111 halley PERM 1
+#BASKET halley 10.0.0.111
+#EGG halley 1 10.0.0.111 mercury DND 3
+#BASKET mercury 10.0.0.125
+
+#EGG noosphere 28 128.112.35.133 noosphere PERM 1
+#BASKET noosphere 128.112.35.133
+
+#   diesse -> diesse
+#EGG diesse 37 193.8.230.134 diesse PERM 1
+#BASKET diesse 193.8.230.134
+
+#   noosphere -> diesse
+EGG noosphere 28 128.112.35.133 diesse PERM 1
+BASKET diesse 193.8.230.134
+
+#   throop -> diesse
+#EGG throop 1003 193.8.230.132 diesse PERM 1 http://www.fourmilab.ch/
+#BASKET diesse 193.8.230.134
+
+#   jura -> jura
+#EGG jura 1004 193.8.230.130 jura PERM 1 http://www.fourmilab.ch/
+#BASKET jura 193.8.230.130
+
+#   diesse -> noosphere
+#EGG diesse.fourmilab.ch 37 193.8.230.134 noosphere PERM 1
+#BASKET noosphere 128.112.35.133
+
+#EGG diesse 37 193.8.230.134 jura PERM 1
+#BASKET jura 193.8.230.130
+
+#BASKET tonga 209.157.90.137
+#BASKET tonga1 209.157.90.138
+PROTOCOL 10 10 6 200
+#REG PEAR 2 9600
+REG PSEUDO 1 9600
+#REG ORION 1 9600
+NETUP pppscript up
+NETDOWN pppscript down
diff --git a/sample.pppscript b/sample.pppscript
new file mode 100755
index 0000000..355a50f
--- /dev/null
+++ b/sample.pppscript
@@ -0,0 +1,30 @@
+#!/bin/csh
+
+if ("$1" == "up") then
+  echo "Bringing net up"
+
+  /usr/sbin/pppd connect '/usr/sbin/chat -v ABORT BUSY ABORT "NO CARRIER" "" ATZ OK ATS71=1 OK ATS80=1 OK ATDT4828060 CONNECT ""' /dev/cua0 115200 name halebopp remotename whitehole debug crtscts modem defaultroute 10.0.0.111:10.0.0.116
+
+  # Wait for connection success
+  set timer = 8
+  while ($timer > 0) 
+    if (-e "/var/run/ppp0.pid") exit 0
+    sleep 1
+    @ timer = $timer - 1
+  end
+
+  echo "Couldn't get it up!"
+  exit -1
+endif
+
+if ("$1" == "down") then
+  echo "Bringing net down"
+  if (! -e "/var/run/ppp0.pid") exit 0
+  set pid = `cat /var/run/ppp0.pid`
+  kill $pid
+
+  exit 0
+endif
+
+echo "Usage: pppscript up down"
+exit 1
diff --git a/storage.c b/storage.c
new file mode 100644
index 0000000..ac36436
--- /dev/null
+++ b/storage.c
@@ -0,0 +1,599 @@
+/* PROGRAM:	eggsh
+ * FILE:	$Header: /home/egg/src/RCS/storage.c,v 1.4 1998/12/31 22:07:56 ghn Exp $
+ * PURPOSE:	Data storage functions
+ * AUTHOR:	Greg Nelson
+ * DATE:	98-05-09
+ *
+ * REVISED:
+ * $Log: storage.c,v $
+ * Revision 1.4  1998/12/31 22:07:56  ghn
+ * Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.3  1998/08/03 20:32:46  kelvin
+ * File byte-order independence, STORAGE_DEBUG
+ *
+ * Revision 1.2  1998/08/01  17:18:45  ghn
+ * Fixes to prevent core dumps and make "database" engine work correctly.
+ *
+ * Revision 1.1  1998/07/21 11:36:21  ghn
+ * Initial revision
+ *
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include "global.h"
+#include "genlib.h"
+#include "storage.h"
+#include "errnos.h"
+
+/* Some systems (e.g. Linux) implement strdup but don't define
+   it by default in string.h.  Define it explicitly here, which
+   doesn't seem to do any harm on other systems.  If you encounter
+   an error on the following declaration, disable it for your
+   platform. */
+
+extern char *strdup (const char *s1);
+
+/* Eventually, these might deal with making a safe copy or mounting
+   and unmounting a partition. Until such time as we actually do
+   something with these, they are no-ops. */
+#define Protect(x)
+#define Unprotect(x)
+
+#define DATAFMT         "%Y%m/%%e"
+#define PROJSTART	901947600L
+
+static char *datafmt;		      /* Data file format string */
+
+/*  Prototypes for forward functions.  */
+
+static int32 FileLoadPacket(FILE *fp, EggCarton *cart);
+static int32 next_filename(char *fn, uint32 tindex, int16 eggid,
+			   int16 *lastind, int16 mustexist);
+static int32 next_poss_fn(char *fn, uint32 tindex, int16 eggid);
+
+/* The seek optimisation table saves the file name, last
+   packet returned, and corresponding file of the next
+   packet (if any) in the file, for the last SEEK_OPT_MAX
+   requests.  This allows LoadNextPacket to avoid searching
+   the entire database for the next packet if the request
+   matches one in the seek optimisation table.
+
+*/
+
+#define SEEK_OPT_MAX MAX_BASKETS
+
+struct seekopt {
+    char filename[256];
+    uint32 last_time;
+    long next_packet;
+};
+
+static struct seekopt seekOpt[SEEK_OPT_MAX];
+static int seekOptIndex = 0;
+
+/* The initialization provides a way to specify a format for the
+   database file names.  If the argument is null, it uses a default
+   from the environment, or it takes the default given above.  This
+   string is used as an argument to strftime(3) which replaces certain
+   characters with corresponding fields of the date and time.  This
+   provides an automatic way of generating a logical new filename on a
+   periodic basis.  Note that you can call InitStorage as many times
+   as you wish to change the format for file names opened
+   subsequently. */
+
+int32 InitStorage(char *path) {
+  char *p, *np;
+  char ns[256], pa[12];
+  int changed = 0;
+
+  /* First, take this opportunity to clear the seek optimisation
+     table.  If we're changing the file name format, none of the
+     items in it will be valid in any case. */
+
+  memset(seekOpt, 0, sizeof seekOpt);
+
+  /* Set the path based on the environment variable, argument,
+     or default. */
+
+  if (path == NULL) {
+    if ((path = getenv("EGG_DATA")) == NULL) {
+      path = DATAFMT;
+    }
+  }
+
+  /* If the path contains any of our special "$" editing
+     codes, interpolate the requested text into the string.
+     Strftime "%" editing codes are left intact. */
+
+  ns[0] = 0;
+  p = path;
+  while ((np = strchr(p, '$')) != NULL) {
+    char *phrargs = np + 1;
+
+    /* Copy portion of string prior to phrase to output. */
+
+    if (np > p) {
+	int l = strlen(ns);
+
+	memcpy(ns + l, p, np - p);
+	ns[l + (np - p)] = 0;
+    }
+
+    /* Parse format phrase and possible arguments. */
+
+    while ((*phrargs != 0) && !isalpha(*phrargs)) {
+	phrargs++;
+    }
+    if (*phrargs == 0) {
+        fprintf(stderr, "Data format string error in:\n    %s\nunterminated $ phrase.\n", path);
+	exit(-1);
+    }
+
+    /* Copy arguments, if any, to second character of arguments
+       string for possible use by phrase interpreters in
+       sprintf. */
+
+    pa[0] = '%';                      /* Start editing phrase */
+    pa[1] = 0;
+    if (phrargs > (np + 1)) {
+	memcpy(pa + 1, np + 1, phrargs - (np + 1));
+	pa[1 + (phrargs - (np + 1))] = 0;
+    }
+/*fprintf(stderr, "Phrase arguments = <%s>\n", pa);*/
+
+    /* Now interpret the specific format phrase letters.
+       The value selected by each phrase should be concatenated
+       to the output string ns.  Available format phrases
+       are:
+
+	   $b	       Basket name
+	   $e	       Egg name
+	   $[0][n]E    Egg number, right justified,
+		       optionally zero filled in n characters
+
+    */
+
+
+    switch (*phrargs) {
+
+        case 'b':                     /* Basket name */
+	    strcat(ns, baskettable[0].name);
+	    break;
+
+        case 'e':                     /* Egg name */
+	    strcat(ns, eggtable[0].name);
+	    break;
+
+        case 'E':                     /* Egg number, edited decimal number */
+            strcat(pa, "d");
+	    sprintf(ns + strlen(ns), pa, eggtable[0].id);
+	    break;
+
+	default:
+            fprintf(stderr, "Data format string error in:\n    %s\nunknown phrase $%c.\n",
+		    path, *phrargs);
+	    exit(-1);
+    }
+
+    /* Adjust pointer to resume scan following the phrase
+       in the source string. */
+
+    p = phrargs + 1;
+    changed++;
+  }
+
+  if (changed) {
+    strcat(ns, p);		      /* Concatenate balance of string */
+    path = strdup(ns);
+    if (path == NULL) {
+        fprintf(stderr, "Cannot allocate memory for file name format string.\n");
+	exit(-1);
+    }
+/*printf("Expanded path name phrase = <%s>\n", path); exit(0);*/
+  }
+
+  datafmt = path;
+  return 0;
+}
+
+/* Save packet is the basic save function.  It does not take a
+   filename, relying on the datafmt variable created during
+   initialization to generate an appropriate filename.	The
+   date for the saved data is based on the timestamp of the packet's
+   first record. */
+
+int32 SavePacket(EggCarton *cart) {
+  FILE		*fp;
+  char		*packet, datatmp[255], datafile[255], *sp;
+  int32 	pktime, res;
+
+  pktime = cart->records[0].timestamp;
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "SavePacket for %lu: %s", pktime, asctime(gmtime((time_t *) &pktime)));
+#endif
+
+  /* Generate the file name corresponding to the date of
+     the first record in the packet.  Since we know the
+     date, there's no need to use next_filename. */
+
+  res = next_poss_fn(datafile, pktime, cart->hdr.eggid);
+
+  /* Open the file for appending. */
+
+  Unprotect(datafile);
+  fp = fopen(datafile, "a");
+
+  /* If we can't open the file, the odds are it's because
+     the file is in a directory we've yet to create. */
+
+  if (fp == NULL) {
+#ifdef STORAGE_DEBUG
+    fprintf(stderr, "SavePacket: no such file %s\n", datafile);
+#endif
+    sp = strrchr(datafile, '/');
+    while (sp) {
+      strncpy(datatmp, datafile, sp - datafile);
+      datatmp[sp - datafile] = 0;
+      mkdir(datatmp, 0777);
+#ifdef STORAGE_DEBUG
+      fprintf(stderr, "SavePacket: mkdir %s\n", datatmp);
+#endif
+      sp = strchr(sp + 1, '/');
+    }
+
+    /* Now try re-opening the file.  */
+
+    Unprotect(datafile);
+    if ((fp = fopen(datafile, "a")) == NULL) {
+      fprintf(stderr, "SavePacket: cannot create database file %s.\n", datafile);
+      exit(-1);
+    }
+  }
+  
+  if (!fp) {
+#ifdef STORAGE_DEBUG
+    fprintf(stderr, "SavePacket: error opening %s\n", datafile);
+#endif
+    return -2;
+  }
+  packet = Packetize(cart);
+  if (!packet) return -1;
+  fwrite(packet, sizeof(char), cart->hdr.pktsize, fp);
+  free(packet);
+  fclose(fp);
+  Protect(datafile);
+  cart->hdr.numrec = 0;
+
+  return 1;
+}
+
+/* Open database for reading, positioning to specified location.
+   If eggid is less than zero, it will load any packet. */
+int32 OpenDatabase(DBRec *dbp, uint32 tindex, int16 eggid) {
+  int32 	res;
+
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "OpenDatabase: Egg = %d, tindex = %ld %s",
+    eggid, tindex, asctime(gmtime((time_t *) &tindex)));
+#endif
+  dbp->eggind = 0;
+  dbp->fp = NULL;
+  if ((res = next_filename(dbp->fn, tindex, eggid, &(dbp->eggind), TRUE)) < 0)
+    return res;
+    
+  Unprotect(dbp->fn);
+  dbp->fp = fopen(dbp->fn, "r");
+  if (dbp->fp == NULL) {
+    Protect(dbp->fn);
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "OpenDatabase -- EOF\n");
+#endif
+    return ERR_EOF;
+  } else {
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "OpenDatabase -- Opened %s\n", dbp->fn);
+#endif
+    return ERR_NONE;
+  }
+}
+
+/* Close database */
+int32 CloseDatabase(DBRec *dbp) {
+  fclose(dbp->fp);
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "CloseDatabase -- Closed %s\n", dbp->fn);
+#endif
+  Protect(dbp->fn);
+  dbp->fp = NULL;
+  /* We preserve file name; this lets us not open the same
+     file name again unless we want to. */
+  return ERR_NONE;
+}
+
+/* Reset database allows us to open same file name again. */
+int32 ResetDatabase(DBRec *dbp) {
+  *(dbp->fn) = 0;
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "ResetDatabase\n");
+#endif
+  return ERR_NONE;
+}
+
+/* Load next packet fitting specified time index and egg id.
+   If eggid is less than zero, it will load any packet. */
+
+static int32 LoadNextPacket(DBRec *dbp, uint32 tindex, int16 eggid, EggCarton *cart) {
+  EggCarton	pktbuf;
+  int32 	res, i;
+  uint32	findex = tindex, now;
+
+  now = getzulutime(NULL);
+  if (findex < PROJSTART) {
+    findex = PROJSTART;
+  }
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "LoadNextPacket(%s, %lu, %d)\n", dbp->fn, tindex, eggid);
+#endif
+
+  /* See if the start address for this request is present
+     in the seek optimisation table.  If so, seek directly
+     to the address to avoid having to read through all
+     earlier packets in the database. */
+
+  i = seekOptIndex;
+  /* Conditioning while on tindex > 0 causes seek optimisation to be
+     skipped when a request for any packet is received. */
+  while (tindex > 0) { 
+      i--;
+      if (i < 0) {
+	  i = SEEK_OPT_MAX - 1;
+      }
+      if (strcmp(seekOpt[i].filename, dbp->fn) == 0 &&
+	  seekOpt[i].last_time == tindex) {
+	  fseek(dbp->fp, seekOpt[i].next_packet, SEEK_SET);
+#ifdef STORAGE_DEBUG
+          fprintf(stderr, "LoadNextPacket; Seek optimised [%ld] to %ld for\n    file %s at %lu %s",
+	      i,
+	      seekOpt[i].next_packet, 
+	      seekOpt[i].filename,
+	      seekOpt[i].last_time,
+	      asctime(gmtime((time_t *) &(seekOpt[i].last_time))));
+
+#endif
+	  break;
+      }
+      if (i == seekOptIndex) {
+#ifdef STORAGE_DEBUG
+          fprintf(stderr, "LoadNextPacket; Cannot optimise seek in file %s\n    at %lu %s",
+	      dbp->fn, tindex, asctime(gmtime((time_t *) &(tindex))));
+#endif
+	  break;		      /* Search wrapped table--cannot optimise */
+      }
+  }
+  
+  while (1) {
+    res = FileLoadPacket(dbp->fp, &pktbuf);
+    if (res == ERR_EOF) {
+      /* File is finished.  Close and open the next.  We assume
+	 that tindex and eggid have been tracking appropriately. */
+      CloseDatabase(dbp);
+
+      /* Advance findex to start of next day after the one we've
+	 just exhausted. */
+
+#define SECONDS_PER_DAY (24L * 60 * 60)
+      findex = ((findex / SECONDS_PER_DAY) + 1) * SECONDS_PER_DAY;
+#ifdef STORAGE_DEBUG
+      fprintf(stderr, "LoadNextPacket; EOF, CloseDatabase, findex = %lu: %s",
+	  findex, asctime(gmtime((time_t *) &findex)));
+#endif
+      if (findex > now) {
+#ifdef STORAGE_DEBUG
+          fprintf(stderr, "LoadNextPacket; EOF findex = %lu > now = %lu %s",
+	  findex, now, asctime(gmtime((time_t *) &now)));
+#endif
+	return ERR_EOF;
+      }
+      /* Do not reset database; we won't open same one again. */
+      if ((res = OpenDatabase(dbp, findex, eggid)) < 0) return res;
+      continue;
+    }
+/*
+fprintf(stderr, "Eggid = %d Packet.eggid = %d\n", eggid, pktbuf.hdr.eggid);
+*/
+    if (eggid >= 0 && pktbuf.hdr.eggid != eggid) continue;
+    for (i = 0; i < pktbuf.hdr.numrec; i++) {
+/*fprintf(stderr, " Rec %ld timestamp = %lu  tindex = %lu\n", i, pktbuf.records[i].timestamp, tindex);
+*/
+      if (pktbuf.records[i].timestamp > tindex) {
+	memcpy(cart, &pktbuf, sizeof(EggCarton));
+
+	/* Save the location of the packet following this one
+	   in the seek optimisation table. */
+
+	strcpy(seekOpt[seekOptIndex].filename, dbp->fn);
+	seekOpt[seekOptIndex].last_time = pktbuf.records[pktbuf.hdr.numrec - 1].timestamp;
+	seekOpt[seekOptIndex].next_packet = ftell(dbp->fp);
+#ifdef STORAGE_DEBUG
+        fprintf(stderr, "LoadNextPacket; Seek optimisation[%d] for %s\n    to address %ld for time %lu %s",
+	    seekOptIndex,
+	    seekOpt[seekOptIndex].filename,
+	    seekOpt[seekOptIndex].next_packet, 
+	    seekOpt[seekOptIndex].last_time,
+	    asctime(gmtime((time_t *) &(seekOpt[seekOptIndex].last_time))));
+#endif
+	seekOptIndex = (seekOptIndex + 1) % SEEK_OPT_MAX;
+	return ERR_NONE;
+      }
+    }
+  }
+}
+
+/* Load next packet following a particular time index and egg id */
+
+int32 LoadPacket(uint32 tindex, int16 eggid, EggCarton *cart) {
+  DBRec db;
+  int32 res;
+
+  ResetDatabase(&db);	/* Here we need to be able to open same db as
+			   last time. */
+  if ((res = OpenDatabase(&db, tindex, eggid)) < 0) return res;
+  if ((res = LoadNextPacket(&db, tindex, eggid, cart)) < 0) return res;
+  return CloseDatabase(&db);
+}
+
+static int32 FileLoadPacket(FILE *fp, EggCarton *cart) {
+  char *rbuf;
+  int32 res;
+  uint16 pksize;
+
+  if (feof(fp)) return ERR_EOF;
+
+  if (fread(&(cart->hdr.type), sizeof(uint16), 1, fp) != 1) {
+    if (feof(fp)) return ERR_EOF; else return ERR_CNREAD;
+  }
+  if (fread(&(cart->hdr.pktsize), sizeof(uint16), 1, fp) != 1) {
+    if (feof(fp)) return ERR_EOF; else return ERR_CNREAD;
+  }
+
+  /* Since the file packet is in network byte order, we need to
+     be sure the length field is in host order before using
+     it to allocate and read the balance of the packet from the
+     file.  Once that's done, Unpacketize will take responsibility
+     for getting all the packet fields into host order. */
+  pksize = ntohs(cart->hdr.pktsize);
+
+  rbuf = (char *)malloc(pksize);
+  if (!rbuf) return ERR_NOMEM;
+
+  memcpy(rbuf, &(cart->hdr), 2*sizeof(uint16));
+  if (fread(rbuf+4, pksize - 4, 1, fp) != 1) return ERR_CNREAD;
+  
+  res = Unpacketize(cart, rbuf);
+  free(rbuf);
+
+  return res;
+}
+
+static int32 next_filename(char *fn, uint32 tindex, int16 eggid,
+		    int16 *lastind, int16 mustexist) {
+  struct stat	statbuf;
+  uint32	findex, now;
+  int32 	res;
+  char		ldf[255];
+
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "next_filename: egg = %d, mustexist = %d, tindex = %lu %s",
+    eggid, mustexist, tindex, asctime(gmtime((time_t *) &tindex)));
+#endif
+  if (eggid < 0 && !mustexist) {
+#ifdef STORAGE_DEBUG
+    fprintf(stderr, "next_filename: egg ID out of range.\n");
+#endif
+    return ERR_INRANGE;
+  }
+
+  /* Can't go back before project began. */
+  now = getzulutime(NULL);
+  if (tindex < PROJSTART) {
+    findex = PROJSTART;
+  } else {
+    findex = tindex;
+  }
+
+  /* Search possible file names until one is found.  We jump by days,
+     assuming files don't have a greater granularity than that.  In
+     the existence-testing process, we are checking to make sure the
+     file name is different each time. */
+
+  if (lastind == NULL) eggid = eggtable[0].id;
+  else {
+    if (eggid < 0) eggid = eggtable[(*lastind)++].id;
+    if (*lastind == numeggs) *lastind = 0;
+  }
+
+  strcpy(ldf, fn);
+  do {
+    res = next_poss_fn(fn, findex, eggid);
+    findex += 86400L;
+    if (!strcmp(fn, ldf)) continue;
+    strcpy(ldf, fn);
+    /* Check for file.  If stat fails, reason is ENOENT, isn't it? */
+    if (stat(fn, &statbuf) >= 0) {
+#ifdef STORAGE_DEBUG
+      fprintf(stderr, "next_filename: Found file %s\n", fn);
+#endif
+	return ERR_NONE;
+    }
+    if (!mustexist) {
+#ifdef STORAGE_DEBUG
+        fprintf(stderr, "next_filename: File %s does not exist.\n", fn);
+#endif
+	return ERR_NOENT;
+    }
+  } while (findex < now+86400L);
+
+#ifdef STORAGE_DEBUG
+      fprintf(stderr, "next_filename: End of file.\n");
+#endif
+  return ERR_EOF;
+}
+
+/* tindex and eggid must be defined here */
+static int32 next_poss_fn(char *fn, uint32 tindex, int16 eggid) {
+  char		datatmp[255], *sp;
+  int16 	eggind;
+  struct tm	*tm;
+
+  tm = gmtime((time_t *) &tindex);
+  strftime(datatmp, 255, datafmt, tm);
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "next_poss_fn: egg = %d, tindex = %lu %s",
+    eggid, tindex, asctime(tm));
+#endif
+
+  /* If an %e phrase remains after processing by strftime
+     (it should be specified as %%e in the original
+     DATAFMT specification), interpolate the egg number
+     from this packet. */
+
+  if ((sp = strchr(datatmp, '%')) != NULL) {
+    if (sp[1] == 'e') {
+      for (eggind = 0;
+	   eggind < numeggs && eggtable[eggind].id != eggid;
+	   eggind++);
+      if (eggind == numeggs) {
+#ifdef STORAGE_DEBUG
+        fprintf(stderr, "next_poss_fn: Egg number out of range.\n");
+#endif
+	return ERR_INRANGE;
+      }
+      *sp = 0;
+      strcpy(fn, datatmp);
+      strcat(fn, eggtable[eggind].name);
+      strcat(fn, sp + 2);
+    } else {
+      fprintf(stderr, "Bad file format expr: %%%c\n", sp[1]);
+      strcpy(fn, datatmp);
+      return ERR_INRANGE;
+    }
+  } else {
+    strcpy(fn, datatmp);
+  }
+#ifdef STORAGE_DEBUG
+  fprintf(stderr, "next_poss_fn: File name = %s\n", fn);
+#endif
+  return ERR_NONE;
+}
diff --git a/storage.h b/storage.h
new file mode 100644
index 0000000..fc88960
--- /dev/null
+++ b/storage.h
@@ -0,0 +1,63 @@
+/* PROGRAM:     eggsh
+ * FILE:        $Header: /home/egg/src/RCS/storage.h,v 1.3 1998/12/31 22:11:05 ghn Exp $
+ * PURPOSE:     Definitions for data storage functions
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-05-09
+ *
+ * REVISED:
+ * $Log: storage.h,v $
+ * Revision 1.3  1998/12/31 22:11:05  ghn
+ *  Rev 5 code: includes multi-reg support, HTML, etc.
+ *
+ * Revision 1.2  1998/08/01 17:19:48  ghn
+ * Added ResetDatabase function.
+ *
+ * Revision 1.1  1998/07/21 11:35:10  ghn
+ * Initial revision
+ *
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+typedef struct dbase {
+  FILE *fp;
+  int16 eggind;
+  char fn[256];
+} DBRec;
+
+/* The initialization provides a way to specify a format for the
+   database file names.  If the argument is null, it uses a default
+   from the environment, or a compiled default.  This string is used
+   as an argument to strftime(3) which replaces certain characters
+   with corresponding fields of the date and time.  This provides an
+   automatic way of generating a logical new filename on a periodic
+   basis.
+
+   The other function of the initialization is to clear static
+   variable used to incrementally collect records for SaveRecord until
+   a complete packet is available for storage to disk. */ 
+extern int32 InitStorage(char *path);
+
+/* Save packet is the basic save function.  It does not take a
+   filename, relying on the datafmt variable created during
+   initialization to generate an appropriate filename.  The
+   date for the saved data is based on the timestamp of the packet's
+   first record. */
+extern int32 SavePacket(EggCarton *cart);
+
+/* Open database for reading, positioning to specified location.
+   If eggid is less than zero, it will load any packet. */
+extern int32 OpenDatabase(DBRec *db, uint32 tindex, int16 eggid);
+
+/* Close database */
+extern int32 CloseDatabase(DBRec *db);
+
+/* Reset database allows us to open same file name again. */
+extern int32 ResetDatabase(DBRec *dbp);
+
+/* Load next packet following a particular time index and egg id.  If
+   eggid is less than zero, it will load any packet.  This is
+   essentially a shortcut for getting one packet. */
+
+extern int32 LoadPacket(uint32 tindex, int16 eggid, EggCarton *cart);
+
diff --git a/testmain.c b/testmain.c
new file mode 100644
index 0000000..d8cd3a8
--- /dev/null
+++ b/testmain.c
@@ -0,0 +1,220 @@
+/* PROGRAM:     testmain
+ * FILE:        $Header: /home/egg/src/RCS/testmain.c,v 1.1 1998/07/21 11:34:11 ghn Exp $
+ * PURPOSE:     First draft eggsh
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-05-09
+ *
+ * REVISED:     $Log: testmain.c,v $
+ * REVISED:     Revision 1.1  1998/07/21 11:34:11  ghn
+ * REVISED:     Initial revision
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "global.h"
+#include "genlib.h"
+#include "hwapi.h"
+#include "collect.h"
+#include "storage.h"
+#include "network.h"
+#include "errnos.h"
+
+#define BASKETHOST	"halebopp.qtmsys.com"
+
+char *baskethost = BASKETHOST;
+
+void MakeAwake(AwakePacket *pkt);
+void MakeDataPkt(char **pkt, EggCarton *src);
+
+int main(int argc, char *argv[]) {
+  int 			res, cdres, i;
+  int32 sdlisten;
+  double sps;
+  int32 collyes, collno, alignover, alignwait;
+  DevOpts devopts;
+  CollectRecord		coll;
+  EggCarton		retrcart;
+  AwakePacket		awake;
+  ReqPacket		*rpktp;
+  struct sockaddr_in	rhost, bhost;
+  char			*pktbuf, *outpktbuf;
+  uint16		pkttype, pktsize;
+
+  pgmname = argv[0];
+
+  if (argc != 6) {
+    printf("Usage: %s <ttynum> <baud> <trialsz> <sec_rec> <samp_rec>\n", pgmname);
+    exit(-1);
+  }
+
+  devopts.port = atoi(argv[1]);
+  devopts.baud = atoi(argv[2]);
+  coll.opts.trialsz = atoi(argv[3]);
+  coll.opts.sec_rec = atoi(argv[4]);
+  coll.opts.samp_rec = atoi(argv[5]);
+  coll.opts.eggid = GetID();
+
+  coll.opts.rec_pkt = SEC_PKT / coll.opts.sec_rec;
+  if (coll.opts.rec_pkt < 1) coll.opts.rec_pkt = 1;
+  if (coll.opts.rec_pkt > MAXREC_PKT) coll.opts.rec_pkt = MAXREC_PKT;
+
+  if (coll.opts.trialsz < MINBITS || coll.opts.trialsz > MAXBITS) {
+    fprintf(stderr, "Trial size must be between %d and %d.\n",
+	    MINBITS, MAXBITS);
+    exit(-1);
+  }
+
+  if (coll.opts.sec_rec < 1 || coll.opts.sec_rec > MAXSEC_REC) {
+    fprintf(stderr, "Seconds/record must be between 1 and %d.\n", MAXSEC_REC);
+    exit(-1);
+  }
+
+  if (coll.opts.samp_rec < 1 || coll.opts.samp_rec > MAXSAMP_REC) {
+    fprintf(stderr, "Samples/record must be between 1 and %d.\n", MAXSAMP_REC);
+    exit(-1);
+  }
+
+  sps = (double)coll.opts.samp_rec / (double)coll.opts.sec_rec;
+
+  printf("Effective sample rate is about %f samp/sec or %f bits/sec\n",
+	 sps, coll.opts.trialsz * sps);
+  printf("Packets contain %d records\n", coll.opts.rec_pkt);
+
+  if ((coll.dd = OpenDev(&devopts)) < 0) exit(1);
+  if (EvalSpeed(coll.dd) < coll.opts.trialsz * sps) {
+    fprintf(stderr, "Requested speed exceeds device capabilities.\n");
+    exit(-1);
+  }
+
+  coll.sampct = 0;
+  collyes = collno = 0;
+  alignover = alignwait = 0;
+
+  InitStorage(NULL);
+  sdlisten = InitNetwork(EGGPORT);
+
+  /* Get us aligned for the first time */
+  while(AlignRecord(&coll, TRUE) < 0);
+
+  while(1) {
+    res = NetListen(sdlisten, &pktbuf, &rhost, FALSE);
+    if (res < 0 && res != ERR_COMM_TMOUT) {
+      fprintf(stderr, "NetListen error: %d\n", res);
+      continue;
+    }
+    if (res == ERR_NONE) {
+      pkttype = ((GenPacket *)pktbuf)->type;
+      pktsize = ((GenPacket *)pktbuf)->pktsize;
+      switch(pkttype) {
+      case DATA_PACKET:
+	fprintf(stderr, "Egg received data?\n");
+	break;
+      case REQ_PACKET:
+	/* Basket wants data! */
+	rpktp = (ReqPacket *)pktbuf;
+	
+	/* Find the desired data. */
+	res = LoadNextPacket(rpktp->starttm, &retrcart);
+
+	if (res == ERR_NONE) {
+	  /* NetPacketize it */
+	  MakeDataPkt(&outpktbuf, &retrcart);
+	  rhost.sin_port = htons(BASKETPORT);
+	  res = NetTalk(&rhost, outpktbuf);
+	  if (res < 0) {
+	    fprintf(stderr, "NetTalk failed (%d)\n", res);
+	  }
+	  free(outpktbuf);
+	}
+	break;
+      case AWAKE_PACKET:
+	fprintf(stderr, "Egg received awake?\n");
+	break;
+      case SETTINGS_PACKET:
+	/* Install new settings! */
+	break;
+      }
+      free(pktbuf);
+    }
+    
+    if (coll.sampct == 0) {
+      cdres = AlignRecord(&coll, FALSE);
+      if (cdres < 0) {
+	if (cdres == -3) alignover++; else alignwait++;
+	continue;
+      }
+    }
+    cdres = CollectData(&coll);
+    if (cdres < 0) {
+      collno++;
+      continue;
+    }
+    collyes++;
+    if (cdres == 1) {
+      SaveRecord(&coll);
+      MakeAwake(&awake);
+      i = NetGetAddr(&bhost, baskethost, BASKETPORT);
+      i = NetTalk(&bhost, (char *)&awake);
+      printf(" collect:nodata over:wait = %ld:%ld %ld:%ld\n",
+	     collyes, collno, alignover, alignwait);
+      printf("Record: %d points (transmission %d)\n  %ld: ",
+	     coll.sampct, i, coll.data.timestamp);
+      for (i = 0; i < coll.sampct; i++)
+	printf("%3d ", coll.data.trials[i]);
+      printf("\n");
+      coll.sampct = 0;
+    }
+  }
+
+  return 0;
+}
+
+
+void MakeAwake(AwakePacket *pkt) {
+  struct timeval now;
+
+  pkt->type = AWAKE_PACKET;
+  pkt->pktsize = sizeof(AwakePacket);
+  pkt->eggid = GetID();
+  getzulutime(&now);
+  pkt->nowtm = now.tv_sec;
+}
+
+void MakeDataPkt(char **pkt, EggCarton *src) {
+  uint16 pktsize, offset, rec, sbuf;
+  uint32 lbuf;
+
+  pktsize = sizeof(EggHeader);
+  pktsize += src->hdr.numrec * (sizeof(uint32) + 
+			        src->hdr.samp_rec * sizeof(trial));
+  pktsize += sizeof(uint16);	/* Checksum */
+
+  src->hdr.type = DATA_PACKET;
+  src->hdr.pktsize = pktsize;
+
+  *pkt = (char *)malloc(pktsize);
+  memcpy(*pkt, &(src->hdr), sizeof(EggHeader));
+  offset = sizeof(EggHeader);
+
+  for (rec = 0; rec < src->hdr.numrec; rec++) {
+    lbuf = src->records[rec].timestamp;
+    memcpy((*pkt)+offset, &lbuf, sizeof(uint32));
+    offset += sizeof(uint32);
+    /* Assumes sizeof(trial) = 1 */
+    memcpy((*pkt)+offset, &(src->records[rec].trials), src->hdr.samp_rec);
+    offset += src->hdr.samp_rec;
+  }
+
+  /* Normal CRC */
+  sbuf = BlockCRC16(*pkt, offset);
+  memcpy((*pkt)+offset, &sbuf, sizeof(uint16));
+  offset += sizeof(uint16);
+
+  if (offset != pktsize) {
+    fprintf(stderr, "Error in packet generation!\n");
+  }
+}
+
diff --git a/testudp.c b/testudp.c
new file mode 100644
index 0000000..d13b01e
--- /dev/null
+++ b/testudp.c
@@ -0,0 +1,89 @@
+/* PROGRAM:     testudp
+ * FILE:        $Header: /home/egg/src/RCS/testudp.c,v 1.2 1998/07/21 11:34:48 ghn Exp $
+ * PURPOSE:     Testing UDP communications (fake basket)
+ * AUTHOR:      Greg Nelson
+ * DATE:        98-05-09
+ *
+ * REVISED:     $Log: testudp.c,v $
+ * REVISED:     Revision 1.2  1998/07/21 11:34:48  ghn
+ * REVISED:     Testing UDP communications (fake basket)
+ * REVISED:
+ * Copyright 1998 - Greg Nelson
+ * Redistributable under the terms of the GNU Public Licence (GPL)
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include "global.h"
+#include "genlib.h"
+#include "hwapi.h"
+#include "collect.h"
+#include "storage.h"
+#include "network.h"
+
+int main(int argc, char *argv[]) {
+  ReqHeader		rhdr;
+  struct protoent 	*pp;
+  struct hostent	*hp;
+  struct sockaddr_in	rhost;
+  int32			i;
+  int32			out_sock;
+
+  pgmname = argv[0];
+
+  if (argc != 2) {
+    printf("Usage: %s <host>\n", pgmname);
+    exit(-1);
+  }
+
+  if ((pp = getprotobyname("udp")) == NULL) {
+    perror("getprotobyname");
+    exit(-1);
+  }
+
+  if ((hp = gethostbyname(argv[1])) == NULL) {
+    fprintf(stderr, "gethostbyname(%s): %s", argv[1], strerror(errno));
+    exit(-1);
+  }
+
+  if (hp->h_addrtype != AF_INET) {
+    fprintf(stderr, "Host is not on the internet!\n");
+    exit(-1);
+  }
+
+  rhost.sin_port = htons(EGGPORT);
+  rhost.sin_family = AF_INET;
+  memcpy(&(rhost.sin_addr), hp->h_addr, hp->h_length);
+
+  rhdr.type = REQ_PACKET;
+  rhdr.pktsize = sizeof(ReqHeader);
+  rhdr.eggid = 30800;	/* halebopp! */
+  rhdr.samp_rec = 10;
+  rhdr.sec_rec = 10;
+  rhdr.rec_pkt = 6;
+  rhdr.trialsz = 200;
+  rhdr.starttm = 0;
+  rhdr.cksum = BlockCRC16((byte *)&rhdr, sizeof(ReqHeader)-2);
+
+  if ((out_sock = socket(AF_INET, SOCK_DGRAM, pp->p_proto)) < 0) {
+    perror("socket");
+    exit(-1);
+  }
+	
+  i = sendto(out_sock, &rhdr, rhdr.pktsize, 
+	     0, (struct sockaddr *)&rhost,
+	     sizeof(struct sockaddr));
+  if (i == -1) {
+    perror("sendto");
+    exit(-1);
+  }
+  if (i != rhdr.pktsize) {
+    fprintf(stderr, "Failed to send complete packet (%ld/%d)\n",
+	    i, rhdr.pktsize);
+    exit(-1);
+  }
+  
+  exit(0);
+}
diff --git a/usleep.c b/usleep.c
new file mode 100644
index 0000000..1895616
--- /dev/null
+++ b/usleep.c
@@ -0,0 +1,77 @@
+/*
+
+    Emulation of BSD usleep()
+
+    Note that this is not a complete emulation in that
+    it destroys any pre-existing setitimer(), but it's
+    good enough for programs which don't have interval
+    timers running across calls on usleep().  It does
+    save and restore an existing SIGALRM handler.
+
+*/
+
+#ifdef USLEEP
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/signal.h>
+#include <sys/time.h>
+
+#ifdef Solaris
+typedef void (*signalFUNC)(int);
+#define signal(a, b)	sigset(a, (signalFUNC) b)
+#define signalFUNCreturn (signalFUNC)
+#endif
+
+#ifndef signalFUNCreturn
+#define signalFUNCreturn
+#endif
+
+#ifdef FLUSH
+#include <termios.h>
+int flush_fd = -1;		      /* File descriptor for auto-flush */
+#endif
+
+volatile static int waiting;
+
+static void getalrm(int i)
+{
+    waiting = 0;
+}
+
+void sf_usleep(unsigned t)
+{
+    static struct itimerval it;
+    void (*oldsig)();
+
+    oldsig = signalFUNCreturn signal(SIGALRM, getalrm);
+#ifdef FLUSH
+#define FLUSHTIME 100000	      /* Flush interval in microseconds */
+    if (flush_fd != -1) {
+	while (t > FLUSHTIME) {
+	    it.it_value.tv_sec = 0;
+	    it.it_value.tv_usec = FLUSHTIME;
+	    t -= FLUSHTIME;
+	    tcflush(flush_fd, TCIFLUSH);
+	    waiting = 1;
+	    if (setitimer(ITIMER_REAL, &it, NULL))
+		return /*error*/;
+	    while (waiting) {
+		pause();
+	    }
+	    (void) signal(SIGALRM, getalrm);
+	}
+    }
+#endif
+
+    it.it_value.tv_sec = t / 1000000;
+    it.it_value.tv_usec = t % 1000000;
+    waiting = 1;    
+    if (setitimer(ITIMER_REAL, &it, NULL))
+	return /*error*/;
+    while (waiting) {
+	pause();
+    }
+    signal(SIGALRM, oldsig);
+}
+#endif
diff --git a/version.h b/version.h
new file mode 100644
index 0000000..636b0f1
--- /dev/null
+++ b/version.h
@@ -0,0 +1,7 @@
+/*
+
+        Egg and basket version information.
+
+*/
+
+#define Version     "Release 5.1 (1999-02-28 Dynamic Eggs)"
diff --git a/xdsub.c b/xdsub.c
new file mode 100644
index 0000000..3bcd022
--- /dev/null
+++ b/xdsub.c
@@ -0,0 +1,107 @@
+/*
+
+			   Hex dump utility
+
+			    by John Walker
+	       WWW home page: http://www.fourmilab.ch/
+
+		This program is in the public domain.
+
+*/
+
+#ifdef HEXDUMP
+
+#include <stdio.h>
+#include <string.h>
+
+#define EOS     '\0'
+
+static char addrformat[80] = "%6X";
+static char dataformat1[80] = "%02X";
+static int bytesperline = 16, doublechar = 0,
+	   dflen = 2;
+static unsigned long fileaddr;
+static unsigned char lineecho[32];
+
+/*  OUTLINE  --  Edit a line of binary data into the selected output
+		 format.  */
+
+static void outline(FILE *out, unsigned char *dat, int len)
+{
+    char oline[132];
+    int i;
+
+    sprintf(oline, addrformat, fileaddr);
+    strcat(oline, ":");
+    for (i = 0; i < len; i++) {
+	char outedit[80];
+
+	sprintf(outedit, dataformat1, dat[i]);
+        strcat(oline, (i == (bytesperline / 2)) ? "  " : " ");
+	strcat(oline, outedit);
+    }
+
+    if (doublechar) {
+	char oc[2];
+	int shortfall = ((bytesperline - len) * (dflen + 1)) +
+			(len <= (bytesperline / 2) ? 1 : 0);
+
+	while (shortfall-- > 0) {
+            strcat(oline, " ");
+	}
+	oc[1] = EOS;
+        strcat(oline, " | ");
+	for (i = 0; i < len; i++) {
+	    int b = dat[i];
+
+            /* Map non-printing characters to "." according to the
+	       definitions for ISO 8859/1 Latin-1. */
+
+            if (b < ' ' || (b > '~' && b < 145)
+			|| (b > 146 && b < 160)) {
+                b = '.';
+	    }
+	    oc[0] = b;
+	    strcat(oline, oc);
+	}
+    }
+    strcat(oline, "\n");
+    fputs(oline, out);
+}
+
+/*  XD	--  Dump a buffer.
+
+	    xd(out, buf, bufl, dochar);
+
+	    out     FILE * to which output is sent.
+	    buf     Address of buffer to dump.
+	    bufl    Buffer length in bytes.
+	    dochar  If nonzero, show ASCII/ISO characters
+		    as well as hexadecimal.
+
+*/
+
+void xd(FILE *out, void *bub, int bufl, int dochar)
+{
+    int b, bp;
+    unsigned char *buf = (unsigned char *) bub;
+
+    bp = 0;
+    fileaddr = 0;
+    doublechar = dochar;
+
+    while (bufl-- > 0) {
+	b = *buf++;
+	if (bp >= bytesperline) {
+	    outline(out, lineecho, bp);
+	    bp = 0;
+	    fileaddr += bytesperline;
+	}
+	lineecho[bp++] = b;
+    }
+
+    if (bp > 0) {
+	outline(out, lineecho, bp);
+    }
+}
+#endif 
-- 
2.30.2