possible to:

	gmake client
	sudo gmake client-install

on a FBSD4, FBSD5, RHL7.3, and RHL9.0 client node.

There are still some dependencies that are not explicit and which would
prevent a build/install from working on a "clean" OS.  Two that I know of are:
you must install our version of the elvin libraries and you must install boost.

1. "make clean" will just remove stuff built in the process of a regular build
2. "make distclean" will also clean out configure generated files.

This is how it was always supposed to be, there was just some bitrot.

Now it installs from your source tree (rather than from /usr/testbed/lib,
which might not exist) into /usr/local/etc/emulab

the top level.  This will build all the necessary binaries and then install
them.  This works on FBSD4 and RHL7.3.  It still doesn't work on FBSD5
(newer compiler that no longer supports a style of use of _FUNCTION_ in the
event lib) or RHL9 (event lib needs SSL lib which has a bad dependency
on Kerberos).  Notes:

- requires that elvin libraries be installed on nodes (they are) to build
  event agents, requires linuxthreads be installed on FBSD (it is now) to
  build imagezip (which is installed, but is not strictly necessary)

- installed event-agents and other binaries are stripped

- added a few missing files to the source tree for bsd (healthd.conf)
  and linux (healthd.conf, rc.local)

- the only thing that doesn't get rebuilt in /usr/local/etc/emulab is
  healthd, I couldn't quickly find how it gets built

- uses a scaled down version of libtb with no DB functions (since mysql
  isn't installed on nodes).  N.B. DO NOT DO A CLIENT INSTALL FROM YOUR
  REGULAR OBJ TREE OR ELSE YOU MAY WIND UP WITH A NEUTERED VERSION OF
  libtb.a!

The build-as-well-as-install semantics are counter to the regular install
targets, but this is what we gotta do for now.  Once the TB source builds
under Linux and newer BSDs, we could undo this and just require that people
do a regular "make" followed by "make client-install"  OTOH, there should
be no reason to require installation of mysql and other server-side packages
just to build clients (or make them sit through the compilation of assign),
so maybe we will keep the client build special.

Note: more changes are pending for the makefile related to moving to standard makefile style/suppressing errors.

makefile needs to be fixed (remove fbsd/linux subdir cruft).

I am not using paperbag to run it on ops, but just installing the two
programs that are needed. Eventually should paperbag it.

This same script runs on both boss/ops and on experimental nodes to
fire off the linktest daemon on the nodes and wait. This is icky as
some crufty stuff has to be done so that it will run in both
environments. ltevent is of course not needed on boss, but do not want
to bother it now since it *is* needed on the nodes.

To run it on boss script needed severe cleanup and taint checking.
Also added the use of event keyfile, which is currently optional, but
needs to be mandatory once the images are updated.

The current problem is that run_linktest can hang waiting for the
clients to finish?. We can use quick mode in the experiment setup
path, but maybe we need a cancel operation?

Removed hardcoded "boss" from linktest.pl and run_linktest.pl
Changed historical log location.

and wait for linktest events, and integrated it into the perl scripts.

At this point I'm working on small potatoes such as the rc.setup script
to invoke linktest daemon and nailing down where to put platform-specific
stuff such as the ns-linktest build and the customized tb-compat.

Also am testing linktest in cases where I've deliberately inserted an error
to make sure it catches it.

This includes an updated client-install.

However, this is not yet ready for builds due to certain libraries not
present on the nodes and ops. For those I will be writing a static
linked c program to handle the linktest "done" event in both linktest.pl
and run_linktest.pl.

and addded parameter passing the daemon.

Also fixed up the makefile for compilation and installation (client).

described in my final project paper.

is to add HMACs to events to ensure they that events cannot be
injected into an experiment by an unauthorized client.

* The frontend now generates a secret key for each experiment and
  stores that into a file and in the DB.

* Each of the event clients, as well as the event producers
  (scheduler, tevc) have a new -k option to specify the name of the
  file. Two new event library functions were added for clients to give
  the key:

    event_handle_t
    event_register_withkeyfile(char *name, int threaded, char *keyfile);

    event_handle_t
    event_register_withkeydata(char *name, int threaded,
	   		       unsigned char *keydata, int keylen);

* When the library is in possesion of a key, it will generate an HMAC
  and attach it to outgoing notifications. A client receiving a
  notification will compute an HMAC and compare it against the HMAC in
  the notification. If they do not compare, the notification is
  dropped with a warning...

of stuff in the new image. Also added client side install targets
every place I could think of.

and reponds to PROGRAM events. Currently, just start and stop. Start
takes a COMMAND= argument, and allows arbitrary command lines since I
pass the whole thing off to the shell. Caveat; the agent runs as root
and starts the program as root. You can has as many program objects in
your NS file as you like, but each one can be started once; you have
to either stop or wait for the old one to finish before trying to
start again.

system programs. Build two versions of the event library, one for non
threaded programs and another (libevent_r.a) for threaded versions.
Remove all that -pthread goo from all of the makefiles, except for the
scheduler (which is threaded); it gets linked as before, but with
-levent_r instead. If you try and use the threaded API without the
proper link, the library will print an error message and quit.

tbsend.c and tbrecv.c, which are trivial examples of how to send
and receive a sample event.

Also several changes for building on FreeBSD. I've left the older
Makefiles in place so Ian can continue to build in his environmant
(Linux?).