This is a simple parallel demon that uses the message-passing system.
For now, I'm using it to develop these calls, so this README will describe how
the message-passing system establishes connections and send messages.

All communication is in a GROUP, defined by a MSG_Group structure.
Membership in a group is in relative rank terms from 0 to n_members - 1.
Sending data is done by using relative rank, which is converted into an
absolute rank by the l_to_g field of the MSG_Group.

The absolute rank refers to an abstract "connection".  These are in an 
array in a MSG_State structure, and indicate how to communicate with another
process.  IMPORTANT POINT: This system does NOT assume a direct route to 
every other process.  Thus, multiple "connections" may point at the same
socket.  

For each fd, there is another (set of) structures that describes the state of
the fd for a read and write operation.  Multiple connections may refer to the
same FDin/FDout structures.  These are saved separately in the MSG_State
structure. 

The operations involved in message passing are:

Connection:
   When processes are started, they specify a remote (host,port) to contact
   and an optional local port to provide.

   First, they setup the local port.  This installs a handler that, when
   contacted, 
	Sets up a handshake (to confirm connection).  When handshake succeeds,
	Creates the FDin/FDout structures
        Acquires the global rank information for the other side of
            the connection(see below)
        Creates and installs this connection in the MSG_State table.
	May add ADDITIONAL connections for processes known by this partner
	    (routing information)
	Installs the receive handler for this FD (see below)

Sending:
    Convert (group,rank) to absolute rank/connection.  Use FDout structure to
    send.  Possible problem: unsent message from previous send operation.
    We may set a handler for the WRITEFD to clear out the message as it
    can be written.

Receiving:
    This is an active message system.  For each group, a (tag, function,
extra_data) tuple is predefined.  When a message is read, the group and then
the tag is identified, and the indicated function is called.  The system uses
group 0 to predefine a number of support functions; these can be used as an
example.  


Basic functions supported (Group 0)
Group 0 is responsible for the initial connections and for creating new
groups. 

Tag               Function
MSG_0_SIGNAL      Deliver signal (in network signal name) to indicated process
                  (data is network-signal number and process id)
MSG_0_EXIT        Shut down demon (and all of its children)
MSG_O_PING        Request for heartbeat (an are you alive message.  Respond
                  with MSG_O_PING.
MSG_0_GRPINFO     Change information about a group.
MSG_0_STDOUT      Data for standard out      
MSG_0_STDERR      Data for standard error



