Initial commit

1 files changed, 1278 insertions, 0 deletions

diff --git a/vendor/voclient/voapps/vosession.c b/vendor/voclient/voapps/vosession.c
new file mode 100644
index 00000000..958f1787
--- /dev/null
+++ b/vendor/voclient/voapps/vosession.c
@@ -0,0 +1,1278 @@
+/**
+ *  VOSESSION -- Inter-Desktop Session Manager for the VOSAMP task.
+ *
+ *  Usage:
+ *
+ *	vosession [<opts>]
+ *
+ *  Where	
+ *  	-%,--test			run unit tests
+ *  	-h,--help			print help summary
+ *  	-d,--debug			debug output
+ *  	-v,--verbose			verbose output
+ *
+ *  Subcommands:
+ *
+ *    status 				    print Hub availability
+ *    list 				    list all registered clients
+ *
+ *
+ *  @file       vosession.c
+ *  @author     Mike Fitzpatrick
+ *  @date       6/03/12
+ *
+ *  @brief      Session Manager for the VOSAMP task.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <time.h>
+
+#include <netdb.h>
+#include <sys/errno.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+
+#include "samp.h"			/* LIBSAMP interface	        */
+#include "voApps.h"			/* voApps interface	        */
+
+
+#define	SZ_BUF		128
+#define	SZ_MTYPE	 64
+#define	SZ_HOSTIP	 16
+
+#define	MAX_ARGS 	  8		/* Max args in a command	*/
+#define MAX_SESSIONS     64             /* Max sessions to manage       */
+#define MAX_PORTS       128             /* Max ports to manage          */
+
+#define	SESS_SELWIDTH	 32		/* select fd width		*/
+#define	SESS_TIMEOUT   3600		/* 1-hr timeout 	        */
+#define	SESS_DISCONNECT 309             /* Session Mgr command timeout  */
+
+#define MATCH(s)        (strcasecmp(cmd,s)==0)
+
+
+/*  Connected session client.
+ */
+typedef struct {
+    int    sock;                        /* socket descriptor            */
+    int    port;                        /* connection port              */
+    char   hostIP[SZ_HOSTIP];           /* host IP address              */
+    char   session[SZ_LINE];            /* session name                 */
+
+    void   *back;			/* linked-list back ptr		*/
+    void   *next;			/* linked-list next ptr		*/
+} Node, *NodeP;
+
+
+/*  Session structure.
+ */
+typedef struct {
+    int     nclients;                   /* number of clients            */
+    Node   *clients;       		/* clients in session           */
+    char    name[SZ_LINE];         	/* session name			*/
+    char    dataCache[SZ_LINE];         /* path to local data cache     */
+
+    int     ncmds;			/* Number of commands sent	*/
+    int     nfiles;			/* Number of files uploaded	*/
+    long    nbytes;			/* Number of files uploaded	*/
+    time_t  start_time;         	/* session start time		*/
+    time_t  end_time;         		/* session end time		*/
+    time_t  last_cmd;         		/* session last command		*/
+
+    void   *back;			/* linked-list back ptr		*/
+    void   *next;			/* linked-list next ptr		*/
+} Session, *SessionP;
+
+
+static int  nSessions	  	= 0;
+static Session* sessHead  	= NULL;
+static Session* sessTail  	= NULL;
+
+static int   nClients	  	= 0;
+static Node* clientHead		= NULL;
+static Node* clientTail  	= NULL;
+
+static int  verbose	= FALSE;	/* verbose output		*/
+static int  debug	= FALSE;	/* verbose output		*/
+static int  interactive	= FALSE;	/* interactive mode		*/
+static int  xml_trace 	= FALSE;	/* trace XML_RPC		*/
+static int  timeout 	= SESS_TIMEOUT;	/* select() doesn't timeout	*/
+static int  svr_port 	= SESS_DEFPORT;	/* connection port		*/
+static int  selwidth	= SESS_SELWIDTH;/* select() width		*/
+
+static int  keep_alive  = TRUE;		/* lingering connection		*/
+static int  svr_sock 	= FALSE;	/* server socket descriptor	*/
+static int  cb_sock 	= 0;		/* callback socket descriptor	*/
+static int  cb_port 	= 0;		/* callback port number		*/
+static int  socks[MAX_PORTS];		/* available sockets		*/
+
+
+static char *to		= NULL;		/* message recipient		*/
+static char *session	= NULL;		/* session name			*/
+static char  cmd[SZ_CMD];		/* command name			*/
+static char *args[MAX_ARGS];		/* command args buffer  	*/
+static char  data_file[SZ_URL];		/* uploaded data file		*/
+
+
+static fd_set allset, rfds;
+static struct timeval tm;
+
+
+#define NOAO
+#ifdef NOAO
+static	char *sessionData	= "/iraf/web/vosession";
+static	char *sessionUrlBase	= "http://iraf.noao.edu/vosession";
+#else
+static	char *sessionData	= "/tmp/vosession";
+static	char *sessionUrlBase	= "file:///tmp/vosession";
+#endif
+static char  logfile[SZ_LINE];
+static char  statfile[SZ_LINE];
+
+
+
+/*  Utility socket routines.
+ */
+extern int   vos_openServerSocket (int port);
+extern int   vos_openClientSocket (char *host, int port, int retry);
+extern int   vos_sockRead (int fd, void *vptr, int nbytes);
+extern int   vos_sockWrite (int fd, void *vptr, int nbytes);
+extern void  vos_setNonBlock (int sock);
+extern int   vos_sockWriteHdr (int fd, int len, char *name, int type, 
+				int mode, char *to);
+extern int   vos_sockReadHdr (int fd, int *len, char *name, int *type, 
+				int *mode);
+extern int   vos_recvFile (int sock, int size, char *fname);
+extern int   vot_atoi (char *v);
+extern char *vo_logtime (void);
+extern char *vos_typeName (int type);
+
+
+
+/*  Task specific option declarations.
+ */
+static char  *opts      = "h%:dikp:tuvS:T:";
+static struct option long_opts[] = {
+        { "help",         2, 0,   'h'},         /* required             */
+        { "test",         1, 0,   '%'},         /* required             */
+        { "debug",        2, 0,   'd'},         /* debug		*/
+        { "interactive",  2, 0,   'i'},         /* interactive mode	*/
+        { "keepalive",    2, 0,   'k'},         /* keep connection 	*/
+        { "port",         1, 0,   'p'},         /* server port		*/
+        { "trace",        2, 0,   't'},         /* trace cmds		*/
+        { "url",          2, 0,   'u'},         /* upload data base URL */
+        { "verbose",      2, 0,   'v'},         /* verbose		*/
+        { "session",      1, 0,   'S'},         /* session name		*/
+        { "timeout",      1, 0,   'T'},         /* connection timeout  	*/
+        { NULL,           0, 0,    0 }
+};
+
+static void Usage (void);
+static void Tests (char *input);
+
+		    
+static int   sess_procCmd (int sock, int msgtype, int nbytes, char *fname);
+static int   sess_forwardMessage (int sender, char *msg);
+static int   sess_connectClient (int sock);
+static int   sess_disconnectClient (int sock);
+static int   sess_disconnectAllClients (void);
+static int   sess_joinSession (int sock, char *session_name);
+static int   sess_leaveSession (int sock, char *session_name);
+
+static Session *sess_newSession (char *name);
+static int   sess_freeSession (Session *s);
+
+static Node *sess_newNode (int sock);
+static int   sess_freeNode (Node *n);
+
+static Session *sess_byName (char *name);
+static Session *sess_bySock (int sock);
+static Node *sess_clientBySock (int sock);
+
+#ifdef SESSION_EXTRAS
+static Session *sess_byPort (int port);
+static Node *sess_clientByPort (int port);
+static int   sess_portToSock (int port);
+#endif
+
+static int   sess_newPort (void);
+static int   sess_freePort (int port);
+static int   sess_sockToPort (int sock);
+
+static char *sess_tok (char *str, int tok);
+static void  sess_rewriteCmd (char *line, char *session, char *fname);
+static void  sessLog (char *formtat, ...);
+static void  sess_writeStats (Session *session);
+static void  sess_printSessions (void);
+static void  sess_printClients (void);
+
+
+
+
+/****************************************************************************
+ *  Program entry point.
+ ***************************************************************************/
+int
+main (int argc, char **argv)
+{
+    char  **pargv, optval[SZ_FNAME], ch;
+    int	    i, rc, pos = 0;
+
+
+
+    /*  Initialize.
+     */
+    memset (logfile, 0, SZ_LINE);
+    memset (data_file, 0, SZ_URL);
+    svr_port = SESS_DEFPORT;
+    for (i=0; i < MAX_ARGS; i++) 
+	args[i] = calloc (1, SZ_LINE);
+
+
+    /*  Parse the argument list.
+     */
+    pargv = vo_paramInit (argc, argv, opts, long_opts);
+    i = 0;
+    while ((ch = vo_paramNext (opts,long_opts,argc,pargv,optval,&pos)) != 0) {
+	i++;
+        if (ch > 0) {
+            switch (ch) {
+            case '%':  Tests (optval);                  return (OK);
+            case 'h':  Usage ();                        return (OK);
+
+            case 'd':  debug++;   			break;
+            case 'v':  verbose++;			break;
+            case 'k':  keep_alive=0;			break;
+
+            case 'p':  svr_port = vot_atoi(optval);	break;
+            case 't':  xml_trace=1;			break;
+
+            case 'S':  session  = strdup (optval);  	break;
+            case 'T':  timeout 	= vot_atoi (optval);	break;
+
+            default:
+                fprintf (stderr, "Invalid option '%s'\n", optval);
+                return (1);
+            }
+
+        } else if (ch == PARG_ERR) {
+            return (ERR);
+
+        } else {
+	    /*  There is no other cmdline arg.
+	     */
+            fprintf (stderr, "Invalid option '%s'\n", argv[i]);
+            return (1);
+        }
+    }
+
+
+    /*  Sanity checks.
+     */
+    if (to == NULL)
+	to = strdup ("all");
+
+    /*  Create the working session directory.
+     */
+    if (access (sessionData, F_OK) < 0) {
+	if (mkdir (sessionData, 0755) < 0) {
+	    fprintf (stderr, "Cannot create session directory '%s'\n",
+		sessionData);
+	    return (1);
+	}
+    }
+    sprintf (logfile, "%s/Log", sessionData);
+    sprintf (statfile, "%s/Stats", sessionData);
+
+
+    /*  Initialize the socket interface and timeouts.
+    */
+    tm.tv_sec  = timeout;
+    tm.tv_usec = 0;
+
+    if ((svr_sock = vos_openServerSocket (svr_port)) < 0) {
+        sessLog ("Cannot open server connection port %d\n", svr_port);
+	return (1);
+    } else if (debug) {
+	sessLog ("=======================================\n");
+	sessLog ("VOSession server started on port %4d\n", svr_port);
+	sessLog ("=======================================\n");
+    }
+
+    FD_ZERO (&allset);
+    FD_SET (svr_sock, &allset);
+    vos_setNonBlock (svr_sock);
+    if (interactive) {
+        FD_SET (fileno(stdin), &allset);
+	vos_setNonBlock (fileno(stdin));
+    }
+
+
+    /*  Begin processing.
+     */
+    while (1) {
+        /*  Initialize the input file descriptor set.
+         */
+	memcpy (&rfds, &allset, sizeof(allset));
+        rc = select (selwidth, &rfds, NULL, NULL, &tm);
+        if (rc == 0) {
+            time_t now = time (NULL);
+            Session *s = (Session *) NULL;
+            Node *n = (Node *) NULL;
+
+            /*  Send a disconnect to all subscribed clients that have been
+             *  inactive for more than SESS_DISCONNECT seconds (1-hr);
+             */
+            for (s=sessHead; s; s=s->next) {
+                if ((now - s->last_cmd) >= SESS_DISCONNECT) {
+                    sessLog ("Session timeout for '%s'\n", s->name);
+		    for (n=s->clients; n; n=n->next) {
+			sess_disconnectClient (n->sock);
+			sess_leaveSession (n->sock, s->name);
+		    }
+                }
+            }
+            continue;
+        }
+
+	/*  Loop over the active descriptors to process input.
+	 */
+	for (i=0; i < selwidth+1; i++) {
+	    if (FD_ISSET(i, &rfds)) {
+		if (i == svr_sock) {
+                    /* Accept a new connection on the port.
+                     */
+		    if (sess_connectClient (svr_sock) != 0)
+                        sessLog ("Cannot connect Client: ", strerror(errno));
+
+	        } else {
+		    /*  Handle input from existing client-node connection.
+		     */
+		    int  nread=0, nbytes=0, type=0, mode=0;
+		    char fname[SZ_FNAME];
+
+		    memset (fname, 0, SZ_FNAME);
+		    if (debug > 1) sessLog ("Input on fd %d ....\n", i);
+
+		    /*  Read the length of the message and type.
+		     */
+           	    nread = vos_sockReadHdr (i, &nbytes, fname, &type, &mode);
+		    if (nread <= 0) {
+			/*  Error on the socket or client closed connection. 
+			 */
+			sess_disconnectClient (i);
+		    } else {
+			/*  Read the command.
+			 */
+			sess_procCmd (i, type, nbytes, fname);
+		    }
+	        }  /* end is server socket */
+	    }  /* end FD_ISSET */
+	}  /* end for */
+    }  /* end while */
+
+
+    /*  Clean up.  Note, we should never actually get here....
+     */
+    if (to)          free ((void *) to);
+    if (session)     free ((void *) session);
+    sess_disconnectAllClients ();
+
+    /*  Close the the connection socket.
+     */
+    if (svr_sock)
+	close (svr_sock);
+
+    return (OK);
+}
+
+
+
+
+/***************************************************************************
+****  		     Client Handling Procedures			  	****
+***************************************************************************/
+
+/**
+ *  SESS_PROCCMD -- Process a command message.
+ */
+static int
+sess_procCmd (int sock, int msgtype, int nbytes, char *fname)
+{
+
+    int   i, len, nsent, type=0, mode=0, nread=0;
+    char  line[SZ_LINE], path[SZ_LINE];
+    Session *s = (Session *) sess_bySock (sock);
+    
+
+    memset (line, 0, SZ_LINE);		/* initialize		*/
+    memset (path, 0, SZ_LINE);
+
+    /*  Read the command header.  This will either be a SAMP_DATA
+     *  message in which case we get a filename, or SAMP_CMD where 
+     *  we ignore the fname value and then read the command string.
+     */
+    switch (msgtype) {
+    case SAMP_DATA:
+	sprintf (path, "%s/%s", s->dataCache, fname);
+
+        if (vos_recvFile (sock, nbytes, path) != OK) {
+            if (debug)
+                sessLog ("Error receiving file '%s'\n", fname);
+        }
+        strcpy (data_file, fname);
+
+        vos_sockReadHdr (sock, &nbytes, fname, &type, &mode);
+        nread = vos_sockRead (sock, line, nbytes);
+	if (debug) sessLog ("SAMP_DATA: '%s' '%s'\n", line, fname);
+        sess_rewriteCmd (line, s->name, data_file);
+        memset (data_file, 0, SZ_FNAME);
+
+	s->nfiles++;
+	s->nbytes += nbytes;
+
+	/*  Forward to other connected clients.
+	 */
+	s->ncmds++;
+	s->last_cmd = time (NULL);
+	nsent = sess_forwardMessage (sock, line);
+	if (debug)
+	    sessLog ("Forwarded to %d clients in '%s'\n", nsent, s->name);
+
+        break;
+
+    case SAMP_CMD:
+    case SAMP_RELAY:
+        nread = vos_sockRead (sock, line, nbytes);
+
+        if (debug)
+	    sessLog ("%s[%d][%s]: '%s'\n", vos_typeName (msgtype), nread,
+		(s ? s->name : ""), line);
+        if (s && line[0] && data_file[0]) {
+            sess_rewriteCmd (line, s->name, data_file);
+            memset (data_file, 0, SZ_FNAME);
+        }
+
+	if (strncasecmp (line, "quit", 4) == 0) {		/*  QUIT      */
+	    sess_disconnectClient (sock);
+
+	} else if (strncasecmp (line, "list", 4) == 0) {	/*  LIST      */
+	    Node *n = (Node *) NULL;
+	    char  buf[(4*SZ_LINE)], line[SZ_LINE];
+
+	    memset (buf, 0, (4 * SZ_LINE));
+	    sprintf (buf, "Clients in session '%s':\n", s->name);
+	    for (i=0,n=clientHead; n; n=n->next,i++) {
+	        memset (line, 0, SZ_LINE);
+		sprintf (line, "    [%d]: host: %16.16s  port: %d\n",
+		    i, n->hostIP, n->port);
+		strcat (buf, line);
+	    }
+
+	    /*  Write the result string back to the client.
+	     */
+	    len = strlen (buf);
+            if (vos_sockWriteHdr (sock, len, NULL, SAMP_RESULT, 
+		SAMP_NOTIFY, "all"))
+            	    nread = vos_sockWrite (sock, buf, strlen (buf));
+
+	} else if (strncasecmp (line, "connect", 4) == 0) {	/*  JOIN      */
+	    sess_joinSession (sock,  sess_tok (line, 2));
+
+	} else if (strncasecmp (line, "leave", 4) == 0) {	/*  LEAVE     */
+	    sess_leaveSession (sock, s->name);
+
+	} else {						/*  ELSE .... */
+	    if (line[0] && msgtype == SAMP_CMD) {
+	        nsent = sess_forwardMessage (sock, line);
+	        if (debug)
+		    sessLog ("Forward to %d clients in '%s'\n", nsent, s->name);
+	    }
+	}
+	if (s) {
+	    s->ncmds++;
+	    s->last_cmd = time (NULL);
+	}
+        break;
+
+    case SAMP_RESULT:
+	if (debug) 
+	    sessLog ("%s[%s]: '%s'\n", vos_typeName (msgtype), 
+		(s ? s->name : ""), " ");
+        break; /*  Not yet implemented  */
+
+    case SAMP_QUIT:
+	sess_leaveSession (sock, NULL);
+	sess_disconnectClient (sock);
+        break;
+		
+    default:
+	sessLog ("cmd: '%s'\n", cmd);
+    }
+
+    return (0);
+}
+
+	    
+/**
+ *  SESS_FORWARDMESSAGE -- Forward the message to all clients in the session
+ *  other than the one which originated it.
+ */
+static int
+sess_forwardMessage (int sender, char *msg)
+{
+    Session *s = sess_bySock (sender);
+    Node *n = (Node *) NULL;
+    int   len, nw, sock, nsent = 0;
+
+
+    for (n=s->clients; n; n=n->next) {
+	sock = n->sock;
+	if (sock != sender) {
+	    if (debug) fprintf (stderr, "forward to '%s'\n", n->hostIP);
+            len = strlen (msg);
+            if (vos_sockWriteHdr (sock, len, NULL, SAMP_RELAY, 0, "all"))
+                nw = vos_sockWrite (sock, msg, len);
+	    nsent++;
+	}
+    }
+
+    return (nsent);
+}
+
+
+/**
+ *  SESS_CONNECTCLIENT -- Connect a client on the named socket.
+ */
+static int
+sess_connectClient (int sock) 
+{
+    int     new, nr;
+    short   ready, sport;
+    struct  sockaddr_in client;
+    size_t  size = sizeof (client);
+    char  sname[SZ_LINE];
+
+
+    memset (sname, 0, SZ_LINE);
+
+    if ((new = accept (sock, (struct sockaddr *) &client, 
+	(socklen_t *) &size)) < 0) {
+             sessLog ("svr_sock accept() errno %d: %s", errno, strerror(errno));
+
+     } else {
+	char *host = inet_ntoa (client.sin_addr);
+	int   port = ntohs (client.sin_port);
+	Node *node = (Node *) NULL;
+
+
+	/*  Attach the client to the list of connected hosts.
+	 */
+	node = sess_newNode (new);
+	node->port = port;
+	node->sock = new;
+	strcpy (node->hostIP, host);
+	if (clientHead) {
+	   clientTail->next = node;
+	   clientTail = node;
+	} else {
+	   clientHead = clientTail = node;
+	}
+	nClients++;
+	
+	/*  Open new server connection and send the callback
+	 *  port number over the connection.  After that, we
+	 *  don't need the initial connection so release it.
+	 */
+	cb_port = sport = sess_newPort ();
+	cb_sock = vos_openServerSocket (cb_port);
+	if (debug)
+	    sessLog ("Connect from host:%s, port:%d, fd:%d, cb_port: %d\n",
+		host, port, new, cb_port);
+	vos_sockWrite (new, &sport, sizeof(short));
+	cb_port = sport;
+	close (new);
+
+	/*  Waiting for callback to connect.
+	 */
+        if ((new = accept (cb_sock, NULL, NULL)) < 0)
+            sessLog ("cb_sock accept() errno %d: %s", errno, strerror(errno));
+	vos_setNonBlock (new);
+
+	/*  Wait for the callback ready message so we know
+	 *  we are connected to the client.
+	 */
+	nr = vos_sockRead (new, &ready, sizeof(short));
+	if (ready == SESS_READY) {
+#ifdef READ_CONNECT
+	    int  nbytes=0, type=0, mode=0;
+
+	    /*  Read the session name.
+	     */
+            vos_sockReadHdr (new, &nbytes, NULL, &type, &mode);
+            nr = vos_sockRead (new, sname, nbytes);
+
+	    if (verbose)
+	        sessLog ("Connect host %s:%d\n",
+                    inet_ntoa(client.sin_addr), ntohs(client.sin_port), sname);
+	    strcpy (node->session, sname);
+#else
+	    if (verbose)
+	        sessLog ("Connect host %s:%d\n", 
+                    inet_ntoa (client.sin_addr), ntohs (client.sin_port));
+#endif
+	}
+
+
+	/*  Add the client socket fd to the master set of
+	 *  active descriptors.
+	 */
+    	FD_SET (new, &allset);
+    }
+
+    return (0);
+}
+
+
+/**
+ *  SESS_DISCONNECTCLIENT -- Shutdown client on the named socket.
+ */
+static int
+sess_disconnectClient (int sock) 
+{
+    Node *client = sess_clientBySock (sock);
+
+    sessLog ("Disconnecting client %d....\n", sock);
+    FD_CLR (sock, &allset);
+    close (sock);
+
+    sess_freeNode (client);
+    sess_freePort (client->port);
+
+    return (0);
+}
+
+
+/**
+ *  SESS_DISCONNECTALLCLIENTS -- Shutdown all connected clients   
+ */
+static int
+sess_disconnectAllClients ()
+{
+    Session *s = (Session *) NULL;
+    Node *n = (Node *) NULL;
+
+    /*  Loop over all the session and their client lists and disconnect
+     *  the client.  We do it here rather than following the client list
+     *  since we'll also clean up the data cache when the session is closed.
+     */
+    for (s=sessHead; s; s=s->next) {
+        for (n=s->clients; n; n=n->next) {
+	    if (debug)
+		sessLog ("Disconnecting host %s on port %d from '%s'\n",
+		    n->hostIP, n->port, s->name);
+
+	    sess_leaveSession (n->sock, s->name);
+        }
+    }
+    return (0);
+}
+
+
+
+
+/***************************************************************************
+****  			  Session Procedures			  	****
+***************************************************************************/
+
+/**
+ *  SESS_JOINSESSION -- Join (or create) a session.
+ */
+static int   
+sess_joinSession (int sock, char *session_name)
+{
+    Session *s = (Session *) NULL;
+    Node    *n = (Node *) NULL;
+    int      found = 0;
+  
+
+    if (sessHead) {
+	s = sess_byName (session_name);
+	if (s == (Session *) NULL) {
+	    /*  Name not found, create a new session pointer.
+	     */
+	    s = sess_newSession (session_name);
+	    sessTail->next = s;
+	    sessTail = s;
+            nSessions++;
+	}
+
+    } else {
+	/*  No active sessions, create one.
+	 */
+	s = sessHead = sessTail = sess_newSession (session_name);
+
+        /*  Create the working session directory.
+	 */
+	sprintf (s->dataCache, "%s/%s", sessionData, session_name);
+        if (access (s->dataCache, F_OK) < 0) {
+	    if (debug) sessLog ("Making session cache directory '%s'\n",
+		s->dataCache);
+	    if (mkdir (s->dataCache, 0755) < 0) {
+	        fprintf (stderr, "Cannot create session cache directory '%s'\n",
+		    s->dataCache);
+	        return (1);
+	    }
+        }
+        nSessions++;
+    }
+
+    /*  Now attach the node the session list of clients, both the master
+     *  client list and the client list in each session.
+     */
+    for (n=clientHead; n; n=n->next) {	/* master client list		*/
+	if (sock == n->sock)
+	    strcpy (n->session, session_name);
+    }
+    found = 0;
+    for (n=s->clients; n && n->next; n=n->next) {
+	if (n->sock == sock) {		/* skip to end of client list	*/
+	    /*  client is already in session. 
+	     */
+	    found++;
+	}
+    }
+
+    /*  Add to client list if it isn't already found.
+     */
+    if (!found) {
+        if (n) {
+            n->next = sess_newNode (sock);
+	    strcpy (n->session, session_name);
+        } else {
+            s->clients = sess_newNode (sock);
+	    strcpy (s->clients->session, session_name);
+        }
+        s->nclients++;
+    }
+
+    if (debug > 1) { sess_printSessions (); sess_printClients (); }
+    return (0);
+}
+
+
+/**
+ *  SESS_LEAVESESSION -- Leave an open session.
+ */
+static int   
+sess_leaveSession (int sock, char *session_name)
+{
+    Session *s = (Session *) NULL;
+    int   port = sess_sockToPort (sock);
+
+
+    s = (session_name ? sess_byName (session_name) : sess_bySock (sock));
+    if (s) {
+	Node *n = s->clients;
+
+	while (n && n->port != port)
+	    n = n->next;
+    
+	if (n) { 
+            sessLog ("%s leaves session '%s'\n", n->hostIP, s->name);
+	    sess_freeNode (n);
+	    s->nclients--;
+	}
+
+	if (s->nclients == 0) {
+            /*  Remove the working session directory and its contents.
+	     */
+            if (access (s->dataCache, F_OK) == 0) {
+		char  cmd[SZ_LINE];
+
+		memset (cmd, 0, SZ_LINE);
+		sprintf (cmd, "/bin/rm -rf %s", s->dataCache);
+	        if (debug) sessLog ("Removing session cache directory '%s'\n",
+		    s->dataCache);
+
+		system (cmd);		/* FIXME	*/
+            }
+	    sess_freeSession (s);
+	}
+    }
+
+    if (debug > 1) sess_printSessions ();
+    return (0);
+}
+
+
+/**
+ *  SESS_BYNAME - Find a Session pointer by name.
+ */
+static Session *
+sess_byName (char *name)
+{
+    Session *s = (Session *) NULL;
+
+    for (s=sessHead; s; s=s->next)
+	if (strcasecmp (name, s->name) == 0)
+	    break;
+
+    return (s);
+}
+
+
+/**
+ *  SESS_BYSOCK - Find a Session socket descriptor.
+ */
+static Session *
+sess_bySock (int sock)
+{
+    Session *s = (Session *) NULL;
+    Node *n = (Node *) NULL;
+
+    for (n=clientHead; n; n=n->next) {
+	if (sock == n->sock)
+	    return (sess_byName (n->session));
+    }
+    return (s);
+}
+
+
+/**
+ *  SESS_CLIENTBYSOCK - Find a Node pointer by socket fd.
+ */
+static Node *
+sess_clientBySock (int sock)
+{
+    Node *n = (Node *) NULL;
+
+    for (n=clientHead; n; n=n->next) {
+	if (n->sock == sock)
+	    return (n);
+    }
+
+    return ((Node *) NULL);
+}
+
+
+/**
+ *  SESS_SOCKTOPORT - Lookup a port number by the socket fd.
+ */
+static int 
+sess_sockToPort (int sock)
+{
+    Node *n = (Node *) NULL;
+
+    for (n=clientHead; n; n=n->next) {
+	if (n->sock == sock)
+	    return (n->port);
+    }
+
+    return (-1);
+}
+
+
+#ifdef SESSION_EXTRAS
+/**
+ *  SESS_CLIENTBYPORT - Find a Node pointer by port number.
+ */
+static Node *
+sess_clientByPort (int port)
+{
+    Node *n = (Node *) NULL;
+
+    for (n=clientHead; n; n=n->next) {
+	if (n->port == port)
+	    return (n);
+    }
+
+    return ((Node *) NULL);
+}
+
+
+/**
+ *  SESS_BYPORT - Find a Session port number.
+ */
+static Session *
+sess_byPort (int port)
+{
+    Session *s = (Session *) NULL;
+    Node *n = (Node *) NULL;
+
+    for (n=clientHead; n; n=n->next) {
+	if (port == n->port)
+	    return (sess_byName (n->session));
+    }
+    return (s);
+}
+
+
+/**
+ *  SESS_PORTTOSOCK - Lookup a socket fd by the client port number.
+ */
+static int 
+sess_portToSock (int port)
+{
+    Node *n = clientHead;
+
+    for (n=clientHead; n; n=n->next)
+	if (n->port == port)
+	    return (n->sock);
+
+    return (-1);
+}
+#endif
+
+
+/**
+ *  SESS_NEWSESSION - Create a new Session structure.
+ */
+static Session *
+sess_newSession (char *name)
+{
+    Session *s = (Session *) calloc (1, sizeof (Session));
+
+    strcpy (s->name, name);
+    s->start_time = time (NULL);
+    return (s);
+}
+
+
+/**
+ *  SESS_FREESESSION - Release a Session structure.
+ */
+static int
+sess_freeSession (Session *s)
+{
+    Session *back = (Session *) (s ? s->back : NULL);
+    Session *next = (Session *) (s ? s->next : NULL);
+
+    if (s == sessHead)
+	sessHead = (Session *) next; 	/* head of the list 		*/
+    else if (s->next == (Session *) NULL)
+	sessHead = (Session *) back; 	/* tail of the list 		*/
+    else
+	back->next = (void *) s->next; 	/* middle of the list 		*/
+
+    if (s->nclients == 0) {
+	fprintf (stderr, "Free up session resources for '%s'\n", s->name);
+    }
+    nSessions--;
+	    
+    s->end_time = time (NULL);
+
+    sess_writeStats (s);		/* log the session stats	*/
+
+    free ((void *) s);
+    if (debug > 1) sess_printSessions ();
+    return (0);
+}
+
+
+/**
+ *  SESS_NEWNODE - Create a new Node structure.
+ */
+static Node *
+sess_newNode (int sock)
+{
+    Node *n = (Node *) calloc (1, sizeof (Node));
+    Node *client = sess_clientBySock (sock);
+
+    if (client) {
+        n->sock = client->sock;
+        n->port = client->port;
+        strcpy (n->hostIP, client->hostIP);
+    }
+
+    return (n);
+}
+
+
+/**
+ *  SESS_FREENODE - Free a Node structure.
+ */
+static int
+sess_freeNode (Node *node)
+{
+    if (node->back) {
+	Node *back = node->back;
+	back->next = node->next;
+    }
+    if (node->next) {
+	Node *next = node->next;
+	next->back = node->back;
+    }
+
+    free ((void *) node);
+    return (0);
+}
+
+
+/**
+ *  SESS_PRINTSESSIONS - Utility to print the session list.
+ */
+static void
+sess_printSessions (void)
+{
+    Session *s = sessHead;
+    Node    *n = (Node *) NULL;
+    int   i, j;
+
+    if (!s) {
+	fprintf (stderr, "No active sessions\n");
+
+    } else {
+	for (s=sessHead,i=0; s; s=s->next, i++) {
+	    fprintf (stderr, "Session[%d]: session '%s' has %d client%c\n", 
+		i, s->name, s->nclients, (s->nclients > 1 ? 's':' '));
+	    for (n=sessHead->clients,j=0; n; n=n->next, j++) {
+	        fprintf (stderr, "    Client[%d]: port: %d   host: %s\n", 
+		    j, n->port, n->hostIP);
+	    }
+	}
+    }
+}
+
+
+/**
+ *  SESS_PRINTCLIENTS - Utility to print the client list.
+ */
+static void
+sess_printClients (void)
+{
+    Node *n = (Node *) NULL;
+    int   i;
+
+    for (n=clientHead,i=0; n; n=n->next, i++) {
+	fprintf (stderr, "Client[%d]: port:%d  sock:%d  host:%s  session:%s\n", 
+	    i, n->port, n->sock, n->hostIP, n->session);
+    }
+}
+
+
+/***************************************************************************
+****  			   Utility Procedures			  	****
+***************************************************************************/
+
+/**
+ *  SESS_WRITESTATS -- Log the sessions statistics.
+ */
+static void
+sess_writeStats (Session *s)
+{
+    FILE   *fd;
+    char    buf[SZ_LINE];
+    double  nsec;
+
+
+    if (s) {
+        memset (buf, 0, SZ_LINE);
+	nsec = (s->end_time - s->start_time);
+        sprintf (buf, 
+	    "%s %16.16s ncmds: %d  nfiles: %d  nbytes: %ld time: %6.1f min\n",
+	    vo_logtime(), s->name, s->ncmds, s->nfiles, s->nbytes, (nsec/60.));
+
+        if ((fd = fopen (statfile, "w+"))) {
+	    if (debug)
+	        sessLog ("%s", buf);
+	    fprintf (fd, "%s", buf);
+	    fflush (fd); fclose (fd);
+        }
+    } else
+	sessLog ("Error: writeStats gets null session");
+}
+
+
+/**
+ *  SESSLOG -- Print a message to the logfile.
+ */
+static void
+sessLog (char *format, ...)
+{
+    FILE    *fd;
+    va_list  argp;
+    char *buf = calloc (1, 1024);
+    char *tstr = NULL;
+    int   len=0;
+    extern char *vo_encodeString ();
+
+
+    /*  Format the message.
+     */
+    va_start (argp,  format);
+    vo_encodeString (buf, format, &argp);
+    va_end (argp);
+
+    len = strlen (buf);                 /* ensure a newline             */
+    if (buf[len-1] != '\n')
+        strcat (buf, "\n");
+
+
+    /*  Log the message.
+     */
+    tstr = vo_logtime ();
+    if (logfile[0] == '-' || strcasecmp (logfile, "stdout") == 0) {
+	printf ("%s  %s", tstr, buf);
+
+    } else {
+        if ((fd = fopen (logfile, "w+"))) {
+	    if (debug)
+		fprintf (stderr, "%s  %s", tstr, buf);
+	    fprintf (fd, "%s  %s", tstr, buf);
+	    fflush (fd); fclose (fd);
+        }
+    }
+
+    free ((void *) buf);
+}
+
+
+/**
+ *  SESS_NEWPORT -- Get an open socket/port entry.
+ */
+static int
+sess_newPort ()
+{
+    int  i, p;
+
+    for (i=0; i < MAX_PORTS; i++) {
+	p = svr_port + i + 3;
+	if (socks[i] == 0) {
+	    socks[i] = p;
+	    return (p);
+	}
+    }
+
+    sessLog ("Error: No available client ports.\n");
+    return (-1);
+}
+
+
+/**
+ *  SESS_FREEPORT -- Free a socket/port entry.
+ */
+static int
+sess_freePort (int port)
+{
+    int  i, p;
+
+    for (i=0; i < MAX_PORTS; i++) {
+	p = svr_port + i + 3;
+	if (p == port) {
+	    close (socks[p]);
+	    socks[i] = 0;
+	}
+    }
+
+    return (0);
+}
+
+
+/**
+ *  SESS_TOK -- Get the specified (1-indexed) w/s delimited token from str.
+ */
+static char *
+sess_tok (char *str, int toknum)
+{
+    register int  i;
+    static char tok[SZ_FNAME];
+    char  *ip = str, *op = tok;
+
+
+    memset (tok, 0, SZ_FNAME);			/* initialize		    */
+
+    for (i=1; i < toknum; i++) { 		/* skip ahead to the token  */
+	while (!isspace ((int) (*ip)) && *ip) ip++;
+	while ( isspace ((int) (*ip)) && *ip) ip++;
+    }
+
+    do {
+	*op++ = *ip++;
+    } while (!isspace ((int) (*ip)) && *ip); 	/* copy the token 	    */
+
+    return (tok);
+}
+
+
+/**
+ *  SESS_REWRITECMD --  Rewrite the command string with filename substitution.
+ */
+static void
+sess_rewriteCmd (char *line, char *session, char *fname)
+{
+    char *ip, *op, buf[SZ_LINE], obuf[SZ_LINE], name[SZ_FNAME];
+
+
+    memset (obuf, 0, SZ_LINE);
+    for (ip=line; *ip; ) {
+        memset (buf, 0, SZ_LINE);
+        memset (name, 0, SZ_FNAME);
+
+        for (op=buf; *ip && !isspace(*ip); )    /* get token            */
+           *op++ = *ip++;
+
+#ifdef USE_FILE_URI
+        /*  Replace file-URI and absolute paths with the replacement filename.
+         */
+        if (strncmp ("file://", buf, 7) == 0 || buf[0] == '/')
+            strcat (obuf, fname);
+        else
+            strcat (obuf, buf);
+#else
+        /*  Replace 'SESSION_URL' with the session dataCache URL.
+         */
+        if (strncmp ("SESSION_URL", buf, 11) == 0) {
+	    strcpy (name, (buf[11] ? &buf[12] : fname));
+	    sprintf (buf, "%s/%s/%s", sessionUrlBase, session, name);
+	}
+        strcat (obuf, buf);
+#endif
+
+        while (*ip && isspace (*ip))            /* skip whitespace      */
+            strncat (obuf, ip++, 1);
+    }
+
+    memset (line, 0, SZ_LINE);
+    strcpy (line, obuf);
+}
+
+
+
+/**
+ *  USAGE --  Print a task usage summary.
+ */
+static void
+Usage (void)
+{ 
+ fprintf (stderr,
+   "  Usage:\n"
+   "\n" 
+   "	%% vosession [-hvd] [-p <port>]\n" 
+   "\n" 
+   "  	where	<cmd>			command to process\n" 
+   "  	     	-h			print help summary\n" 
+   "  	     	-v			verbose output\n" 
+   "  	     	-d			debug output\n" 
+   "\n" 
+   "  	     	-p <port>		server port\n"
+   "\n" 
+ );
+}
+
+
+/**
+ *  Tests -- Task unit tests.
+ */
+static void
+Tests (char *input)
+{
+   ; 	/*	 no-op		*/
+}