/**
 *  VOSAMP - Example task to send a single SAMP message for the cmdline.
 *
 *  Usage:
 *
 *	vosamp [<opts>] <cmd> [args ...]
 *
 *  Where	
 *	<cmd>				command to process
 *  	-%,--test			run unit tests
 *  	-h,--help			print help summary
 *  	-d,--debug			debug output
 *  	-v,--verbose			verbose output
 *  	-q,--quiet			suppress all output
 *
 *  	-i,--interactive		interactive mode
 *  	-m,--many			handle multiple messages
 *  	-s,--sender <sender>		handle only messages from <sender>
 *
 *  	-t,--to <to>			send to specified application (or all)
 *  	-p,--pattern <pattern>		message pattern:  sync|async|notify
 *  	-f,--file <file>		send all commands in the file
 *  	-n,--nokeepalive		disable keep_alive feature
 *
 *  	-P,--proxy <pattern>		proxy process connection
 *  	-T,--timeout <N>		keepalive timeout
 *  	-S,--session <name>		session name
 *
 *	-r,--return			return result to API
 *
 *
 *  Subcommands:
 *
 *    snoop 				    print all received messages
 *
 *    session list 			    list all nodes in current session
 *    session leave|exit|logout 	    leave the current session
 *    session <name> 			    join the named session
 *
 *    status 				    print Hub availability
 *    list 				    list all registered clients
 *    access <appName>			    print <appName> availability
 *    handle <mtype>			    wait for <mtype> message
 *
 *    send <mtype> [<args> ...]		    generalized <mtype> message send
 *    exec <cmd>			    execute a client command
 *    pointAt <ra> <dec>		    point at given coords
 *    setenv  <name> <value>		    set an environment value
 *    getenv  <name>			    get an environment value
 *    setparam <name> <value>		    set a parameter value
 *    getparam <name>			    get a parameter value
 *
 *    load <url>			    load the named image/table file
 *    loadImage <url>			    load the named image
 *    loadVOTable <url>			    load the named VOTable
 *    loadFITS <url>			    load the named FITS bintable
 *    showRow [<tblId>] [<url>] <row>	    highlight specified row
 *    selectRows [<tblId>] [<url>] <rows>   select specified rows
 *    bibcode <bibcode>			    load the named bibcode
 *
 *
 *  @file       vosamp.c
 *  @author     Mike Fitzpatrick
 *  @date       6/03/12
 *
 *  @brief      Desktop SAMP messaging utility.
 */

#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_MTYPE	64
#define	SZ_BUF		128
#define	SZ_HOSTIP	16
#define	SZ_APPNAME	16
#define	SZ_BLOCK	4096

#define HUB_TIMEOUT				/* allow timeout	    */

#define	ENV_PROXY	"VOSAMP_PROXY"


#define	MAX_ARGS	8
#define	VOS_TIMEOUT	600			/* 10-min proxy timeout     */
#define	VOS_DEFPORT	3999
#define	VOS_HUBWAIT	3

#define MATCH(s)        (strcasecmp(cmd,s)==0)


char     senderIP[SZ_HOSTIP]; 
char     fname[SZ_FNAME]; 
char    *to			= NULL;

static int	sampH		= 0;		/* samp struct handle	    */

						/* task options		    */
static int	verbose		= 0;		/* verbose output	    */
static int	quiet		= 0;		/* suppress all output	    */
static int	debug		= 0;		/* verbose output	    */
static int	interact	= 0;		/* interactive shell	    */
static int	multiple	= 0;		/* accept multiple msgs	    */
static int 	xml_trace 	= 0;		/* trace XML_RPC	    */
static int 	keep_alive 	= 1;		/* lingering connection	    */
static int 	proxy_pid	= 0;		/* proxy vosamp pid	    */
static int 	proxy_port	= VOS_DEFPORT;	/* proxy vosamp port	    */

static int	svr_sock	= 0;		/* child server socket	    */
static int	ipc_sock	= 0;		/* IPC sock (parent/child)  */
static int	session_sock	= 0;		/* session mgr socket       */
static int	input_sock	= 0;		/* cmd input socket         */
static int	use_ipc		= 1;		/* use IPC		    */
static int      have_dotfile 	= 0;		/* have a valid .vosamp?    */
static int	in_parent 	= 1;		/* are we parent process?   */
static int	do_return 	= 1;		/* return result to API     */
static int	return_stat 	= OK;		/* return status  	    */
static int  	numargs 	= 0;		/* number of cmdline args   */ 
static int	timeout 	= VOS_TIMEOUT;	/* child timeout	    */

static int	hub_connected	= 0;		/* connected to SAMP hub    */
static int	sess_connected	= 0;		/* connected to session mgr */

char  *session_host = SESS_DEFHOST;  		/* session manager host IP  */
int    session_port = SESS_DEFPORT;         	/* session manager port     */
    
static char    *proxy		= NULL;		/* proxy connection string  */
static char    *session		= NULL;		/* session name		    */
static char    *pattern		= NULL;		/* SAMP msg pattern	    */
static char    *cmdfile		= NULL;		/* input command file	    */
static char    *filt_mtype      = NULL;		/* snoop filter mtype	    */
static char    *filt_sender     = NULL;		/* snoop sender name	    */
static char     cmd[SZ_CMD];			/* command name	    	    */
static char     cmdline[SZ_CMD];		/* full command line	    */
static char     proxy_host[SZ_FNAME];		/* proxy vosamp host name   */
static char     dotfile[SZ_FNAME];		/* path to local dotfile    */
static char     psession[SZ_FNAME];		/* proxy file session name  */
static char    *args[MAX_ARGS];			/* command args buffer      */

static FILE   *fd		= (FILE *) NULL;
static fd_set allset, fds;
static struct timeval tm;


static int   vos_sendToProxy (char *cmdline);
static int   vos_startProxy (void);
static int   vos_sampInit (void);
static int   vos_sendCmd (int sock, char *cmdline);
static int   vos_invalidArg (int argc, char *argv[], int nargs, int exist);
static void  vos_sampShutdown (void);
static void  vos_cmdHelp (char *cmd);
static void  vos_procCmd(int sampH, char *to, char *cmd, char **argv, int argc);
static void  vos_handleCmdInput (void);
static void  vos_msgHandler (char *sender, char *mtype, char *msg_id, Map map);
static void  vos_sessionHandler (char *sender, char *mtype, char *id, Map map);
static void  vos_forwardCmd (char *sess_cmd);
static void  vos_printMessage (char *mtype, char *sender, Map map);

static void  vos_rewriteCmd (char *line, char *fname);
static void  vosDebug (char *format, ...);
static char *vos_rewriteURL (char *in);
static char *vos_dotFile ();

int   vos_uploadFiles (int fd, char *cmdline);
int   vos_recvFile (int sock, int size, char *fname);
int   vos_sendFile (int sock, char *path, char *fname);
int   vos_openSession (char *host, int port, char *session_name);
int   vos_closeSession (int sock);


extern char *vos_toURL (char *arg);
extern char *vos_optArg (char *arg);
extern char *vos_getLocalIP (void);
extern char *vos_getFName (char *url);
extern char *vos_typeName (int type);
extern int  *vos_toIntArray (char *arg, int *nrows);
extern int   vot_atoi (char *v);


/*  Utility socket routines.
 */
extern int  vos_fileRead (int fd, void *vptr, int nbytes);
extern int  vos_fileWrite (int fd, void *vptr, int nbytes);
extern int  vos_openServerSocket (int port);
extern int  vos_openClientSocket (char *host, int port, int retry);
extern int  vos_testClientSocket (char *host, int port);
extern int  vos_sockRead (int fd, void *vptr, int nbytes);
extern int  vos_sockWrite (int fd, void *vptr, int nbytes);
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_urlType (char *url);
extern int  vos_getURL (char *url, char *fname);

extern double vot_atof (char *v);

extern void vos_setNonBlock (int sock);
extern struct hostent *vos_getHostByName (char *lhost);
extern struct hostent *vos_dupHostent (struct hostent *hentry);



/*  Task specific option declarations.
 */
int  vosamp (int argc, char **argv, size_t *len, void **result);

static Task  self       = {  "vosamp",  vosamp,  0,  0,  0  };
static char  *opts      = "%:hnrdif:mps:t:vP:T:S:";
static struct option long_opts[] = {
        { "return",       0, 0,   'r'},         /* task option          */
        { "help",         2, 0,   'h'},         /* required             */
        { "test",         1, 0,   '%'},         /* required             */
        { "debug",        2, 0,   'd'},         /* debug		*/
        { "verbose",      2, 0,   'v'},         /* verbose output	*/
        { "quiet",        2, 0,   'q'},         /* suppress output	*/
        { "many",         2, 0,   'm'},         /* multiple msgs	*/
        { "sender",       1, 0,   's'},         /* sender filter	*/
        { "interactive",  2, 0,   'i'},         /* interactive mode	*/
        { "file",         1, 0,   'f'},         /* cmd file		*/
        { "pattern",      1, 0,   'p'},         /* msg pattern		*/
        { "proxy",        1, 0,   'P'},         /* proxy connection	*/
        { "session",      1, 0,   'S'},         /* session name		*/
        { "to",           1, 0,   't'},         /* recipient name	*/
        { "nokeepalive",  2, 0,   'n'},         /* keep connection 	*/
        { "timeout",      1, 0,   'T'},         /* connection timeout  	*/
        { NULL,           0, 0,    0 }
};

static void Usage (void);
static void Tests (char *input);



/****************************************************************************
 *  Program entry point.
 */
int
vosamp (int argc, char **argv, size_t *reslen, void **result)
{
    char **pargv, optval[SZ_FNAME], ch, *env_proxy = NULL;
    int	   i, pos = 0, len = 0;
    time_t expiry;


    /*  Initialize.
     */
    memset (cmd, 0, SZ_CMD);
    memset (cmdline, 0, SZ_CMD);
    memset (dotfile, 0, SZ_FNAME);
    memset (psession, 0, SZ_FNAME);
    memset (proxy_host, 0, SZ_FNAME);

    strcpy (proxy_host, vos_getLocalIP ());
    strcpy (dotfile, vos_dotFile ());
    for (i=0; i < MAX_ARGS; i++) 
	args[i] = calloc (1, SZ_LINE);

    *reslen     = 0;
    *result     = NULL;
    return_stat = OK;


    /*  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 (self.nfail);
            case 'h':  Usage ();                        return (OK);

            case 'd':  debug++;   				break;
            case 'v':  verbose++;				break;
            case 'q':  quiet++;					break;
            case 'n':  keep_alive = 0;				break;
            case 'm':  multiple++;     				break;
            case 'i':  interact++;  				break;

            case 's':  filt_sender = strdup (optval);  	i++; 	break;
            case 'f':  cmdfile     = strdup (optval);  	i++; 	break;
            case 't':  to          = strdup (optval);	i++; 	break;
            case 'p':  pattern     = strdup (optval);  	i++; 	break;
            case 'P':  proxy       = strdup (optval);  	i++; 	break;
            case 'S':  session     = strdup (optval);  	i++; 	break;
            case 'T':  timeout 	   = vot_atoi (optval);	i++; 	break;

            case 'r':  do_return=1;                     	break;
            default:
                fprintf (stderr, "Invalid option '%s'\n", optval);
                return (1);
            }

        } else if (ch == PARG_ERR) {
            return (ERR);

        } else {
	    /*  Remainder of argv is the subcommand and its arguments.
	     */
	    if (pargv[i] == NULL)
		break;
	    if (!cmd[0]) {
                strcpy (cmd, optval);
	    } else {
		if (strcasecmp (cmd, "exec") == 0 || 
		    strcasecmp (cmd, "echo") == 0) {
		        strcat (args[0], optval);
		        strcat (args[0], " ");
		} else {
		    char *ip;

		    while (pargv[i]) {
			if (strstr (pargv[i], "://") == NULL) {
			    /* replace ':' w/ '=' */
			    for (ip=pargv[i]; *ip; ip++)  
			        *ip = ((*ip == ':') ? '=' : *ip);
			}
                        strcpy (args[numargs++], pargv[i++]);
		    }
		    break;
		}
	    }
        }
    }


    /*  Print command help if that's all we're asked.
     */
    if (strncmp (cmd, "?", 1) == 0 || strncasecmp (cmd, "help", 4) == 0) {
	Usage ();
	return (OK);
    }
    if (strncmp(args[0], "?", 1) == 0 || strncasecmp(args[0], "help", 4) == 0) {
	vos_cmdHelp (cmd);
	return (OK);
    }
    if (strncmp(cmd, "access", 6) == 0 && strncasecmp(args[0], "hub", 3) == 0) {
	int hub_connected = vos_sampInit ();

	printf ("%s\n", (hub_connected ? "yes" : "no"));
	if (hub_connected) 
	    vos_sampShutdown ();
	return ( (hub_connected ? OK : ERR) );
    }
    if (strcmp (cmd, "handle") == 0 || strcmp (cmd, "snoop") == 0)
	keep_alive = 0;


    /*  Sanity checks.
     */
    if (interact || argc <= 1)
	cmdfile = strdup ("-");
    if (to == NULL)
	to = strdup ("all");
    if (pattern == NULL)
	pattern = strdup ("async");


    /*  Initialize the SAMP interface.
    tm.tv_sec    = VOS_HUBWAIT;
    */
    tm.tv_sec    = timeout;
    tm.tv_usec   = 0;
    session_sock = 0;


    /*  Check for environment definitions.
     */
    if ((env_proxy = getenv (ENV_PROXY)))
	proxy = strdup (env_proxy);

    if (proxy) {
	/*  We've been asked to send the command to a particular proxy, just
	 *  send the command line and any required data.
	 */
	char  *cp = strchr (proxy, (int)':');

	vosDebug ("Using proxy '%s'\n", proxy);
	if (cp) {
	    proxy_port = vot_atoi (cp+1);
	    *cp = '\0';
	    strcpy (proxy_host, proxy);
	} else {
	    proxy_port = VOS_DEFPORT;
	    strcpy (proxy_host, proxy);
	}
	use_ipc++;
	have_dotfile++;
	ipc_sock = vos_openClientSocket (proxy_host, proxy_port, 1);

    } else {
	/*  See if we have a local proxy running we can use instead of starting 
	 *  a new connection.  Data references remain local unless being
	 *  passed on to the session manager service.
	 */
	FILE  *fd = (FILE *) NULL;

	if (keep_alive && access (dotfile , R_OK) == 0) {
	    if ((fd = fopen (dotfile, "r+")) != (FILE *) NULL) {
		time_t  now = time ((time_t) 0);
		int  test = 0;

		/*  Read the dotfile contents.
		 */
		fscanf (fd, "%s  %d  %d  %ld  %s", 
		    proxy_host, &proxy_port, &proxy_pid, &expiry, psession);
		fclose (fd);


		/*  Make sure we can reach the running proxy, otherwise
 		 *  assume it is a stale dotfile.
		 */
		if ((test = vos_testClientSocket(proxy_host, proxy_port)) < 0) {
		    if (verbose)
			fprintf (stderr, "Removing stale .vosamp file ...\n");
		    unlink (dotfile);
            	    goto samp_init;
		} else {
    		    vos_sockWriteHdr (test, 0, NULL, SAMP_TEST, 0, "proxy");
		    close (test);
		}

		/*  Check for a stale dotfile. */
		if (now <= (expiry - 2)) {
		    use_ipc++;
		    have_dotfile++;
		} else {
		    if (verbose)
			fprintf (stderr, "Removing stale .vosamp file ...\n");
		    unlink (dotfile);
            	    goto samp_init;
		}
	    }
	} else {
	    /*  First do some sanity checks on the command.  If we're asked
	     *  to quit, then simply don't connect.
	     */
	    if (strncasecmp ("quit", cmd, 4) == 0) {
                return (OK);
	    }

	    /*  No remote command specified, no local connection, so connect to
	     *  the Hub as a new application.
	     * 
    	     *  Start the keep-alive proxy server.
     	     */
samp_init:
    	    if (keep_alive) {
    	        vos_startProxy ();
	        use_ipc = 1;
	    } else {
                if (! (hub_connected = vos_sampInit ())) {
		    fprintf (stderr, "Error: cannot connect to Hub.\n");
		    return (ERR);
		}
	        use_ipc = 0;
	    }
	}
    }


    /*  Process a single command if we're not in keep_alive mode.
     */
    if (!keep_alive) {
	vos_procCmd (sampH, to, cmd, args, numargs);
	goto cleanup_;
    }

    /*  Open an IPC socket to the proxy.
     */
    while (in_parent && ipc_sock <= 0) {
	vosDebug ("opening ipc socket to %s:%d\n", proxy_host, proxy_port);
        ipc_sock = vos_openClientSocket (proxy_host, proxy_port, 1);
        if (ipc_sock < 0) {
            if (verbose)
	        fprintf (stderr, "Cannot open client ipc_sock\n");
	    sleep (1);
        }
    }
    vosDebug ("ipc socket %d\n", ipc_sock);


    /*  Process the messages in the named file, or from the cmdline.  Since
     *  there is some overhead in connecting to the hub, this is an efficient
     *  way to send multiple messages from a single connection.
     */

    if (cmdfile) {
	fd = (cmdfile[0] == '-' ? stdin : fopen (cmdfile, "r"));

	/*  Send the command string from the stdin or the cmd file.
	 */
	fprintf (stderr, "vosamp> ");
#ifdef FGETS
	while (fgets (cmdline, SZ_CMD, fd) && !feof (fd) && !ferror (fd)) {
#else
    	FD_ZERO (&allset);
    	FD_SET (fileno (stdin), &allset);
	while (1) {
	    memcpy (&fds, &allset, sizeof(allset));
            if (select (8, &fds, NULL, NULL, NULL) == 0) 
		continue;
 
	    if (fgets (cmdline, SZ_CMD, stdin) == NULL)
		continue;
#endif
	    len = strlen (cmdline);
	    if (cmdline[len-1] == '\n')
	        cmdline[len-1] = '\0';
	    
	    if (strncasecmp (cmdline, "quit", 4) == 0 || 
	        strncasecmp (cmdline, "logo", 4) == 0)
		    break;
	    else if (cmdline[0]) {
	        vos_sendToProxy (cmdline);
		fprintf (stderr, "vosamp> ");
	    }
	}

        if (fd != stdin)
	    fclose (fd);

    } else if (cmd[0]) {
	/*  Send the command string from the commandline.
	 */
        int  i, len = 0;

        memset (cmdline, 0, SZ_CMD);
        sprintf (cmdline, "%s %s ", cmd, args[0]);
        for (i=1; i < numargs; i++) {
            strcat (cmdline, args[i]);
            strcat (cmdline, " ");
        }
        len = strlen (cmdline); cmdline[len-1] = '\0';

	vos_sendToProxy (cmdline);
    }
    close (ipc_sock);


    /*  Close down and clean up.
     */
cleanup_:
    if (!keep_alive)
        vos_sampShutdown ();

    if (to)          free ((void *) to);
    if (proxy)       free ((void *) proxy);
    if (cmdfile)     free ((void *) cmdfile);
    if (pattern)     free ((void *) pattern);
    if (session)     free ((void *) session);
    if (filt_sender) free ((void *) filt_sender);

    return (return_stat);
}


/**
 *  VOS_SENDTOPROXY -- Send a cmdline to the proxy.
 */
static int
vos_sendToProxy (char *cmdline)
{
    /*  See if we need to join a session before processing the cmd.
     */
    if (session && psession[0] != '\0') {
        /*  Have session param and running a proxy. 
         */
        memset (cmdline, 0, SZ_CMD);
        sprintf (cmdline, "session %s", session);

    } else if (strcasecmp (cmd, "session") == 0 && 
        (psession[0] && strcasecmp (psession, "none") == 0)) {
    	    /*  Have session command and not running a proxy. 
    	     */
            memset (cmdline, 0, SZ_CMD);
	    sprintf (cmdline, "session %s", args[0]);
    }

    if (strcasecmp (proxy_host, vos_getLocalIP())) {
        int  nfiles = vos_uploadFiles (ipc_sock, cmdline);
        vosDebug ("....sent %d data files....\n", nfiles);
    }


    if (strncmp (cmd, "?", 1) == 0 || strncmp (cmd, "help", 4) == 0) {
	vos_cmdHelp (cmd);
	return (0);
    }

    /*  Send the command string.
     */
    vosDebug ("sending to proxy: '%s'\n", cmdline);
    if (vos_sendCmd (ipc_sock, cmdline) == 0) {
        vosDebug ("sending to proxy fails: '%s'\n", cmdline);
        if (verbose)
    	    fprintf (stderr, "Error writing command '%s'\n", cmdline);

	return (0);

    } else {
        short  nread, len;

        vosDebug ("reading ipc response ....\n");
        nread = vos_sockRead (ipc_sock, &len, sizeof (short));
        vosDebug ("ipc response len = %d....\n", len);
        if (len > 0) {
            char *res = calloc (1, (len+1));
            nread = vos_sockRead (ipc_sock, res, len);
            vosDebug ("ipc response nread = %d....res = '%s'\n", nread, res);
            if ((nread > 0 && strcmp (res, "OK") != 0) || verbose)
                printf ("%s\n", res);
            if (res) free ((void *) res);
        }
	return (1);
    }

    return (0);
}


/**
 *  VOS_STARTPROXY -- Start the VOSAMP proxy process.
 */
static int
vos_startProxy (void)
{
    /*  Start the keep-alive proxy server.
     */
    if (keep_alive && in_parent && !have_dotfile) {
	switch ( fork() ) {
	case 0:					/* start child proxy 	*/
	    vosDebug ("child pid\n");

	    /*  Open server socket, read future input from socket.
	     */
	    vosDebug ("child opening server port %d...\n", proxy_port);
	    if ((svr_sock = vos_openServerSocket (proxy_port)) < 0) {
		fprintf (stderr, "Cannot open VOSAMP port %d\n", proxy_port);
		if (have_dotfile) unlink (dotfile);
	    }

    	    FD_ZERO (&allset);
    	    FD_SET (svr_sock, &allset); vos_setNonBlock (svr_sock);
	    vosDebug ("child svr_sock %d...\n", svr_sock);

	    if (session) {
    		/*  Open a client connection to the VOSAMP Session Manager.
    		 */
	        vosDebug ("initializing session '%s' on %s:%d\n", session,
		    session_host, session_port);
    		if ((session_sock = vos_openSession (session_host, 
		     session_port, session)) < 2) {
		    	vosDebug ("session open fails...\n");
        	        session_sock = 0;
		        session = NULL;
    		} else {
		    vosDebug ("child session sock %d...\n", session_sock);
    	            FD_SET (session_sock, &allset);
    	            vos_setNonBlock (session_sock);
		    sess_connected = 1;
		}
	    }

	    /*  Now initialize the SAMP interface.
	     */
	    vosDebug ("initializing SAMP connection\n");
#ifdef HUB_BLOCKS
            while (vos_sampInit () == 0) {
		/*  Wait for a Hub connection.
		 */
		if (debug || verbose) {
		    fprintf (stderr, "Waiting for Hub ....");
		    sleep (VOS_HUBWAIT);
		}
	    }
#else
            hub_connected = vos_sampInit ();
#endif

	    in_parent = 0;
	    vos_handleCmdInput ();

	    /*  Child never returns from this point ..... 
	     */
	    exit (0);
	    break;

	case -1:			/* fork fails 			*/ 
	    if (verbose && in_parent)
	        fprintf (stderr, "%d  proxy fork failure.\n", (int)getpid());
	    break;

	default:			/* parent exits 		*/
	    vosDebug ("parent pid\n");
	    sleep (2);			/* give child a chance to start */
	}
    }

    return (0);
}


/**
 *  VOS_SENDCMD -- Send a SAMP_CMD to the specified socket.
 */
static int
vos_sendCmd (int sock, char *cmdline)
{
    char res[SZ_LINE];
    int  nread = 0, nwrite = 0, len = (cmdline ? strlen (cmdline) : 0);


    vosDebug ("sendCmd: '%s'\n", cmdline);
    memset (res, 0, SZ_LINE);
		    
    if (vos_sockWriteHdr (sock, len, NULL, SAMP_CMD, SAMP_NOTIFY, to)) {
	vosDebug ("writing cmdline '%s'  fd=%d\n", cmdline, sock);
	nwrite = vos_sockWrite (sock, cmdline, len);

	/*  See if we have a result returned to us.  If so, it will be
	 *  a character string we should just print out.
	 */
	if (session && sock != session_sock) {
	    vosDebug ("reading response  fd=%d\n", sock);
	    nread = vos_sockRead (sock, &len, sizeof (int));
	    if (len > 0) {
	        char *res = calloc (1, (len+1));	

	        nread = vos_sockRead (sock, res, len);
	        if ((nread > 0 && strcmp (res, "OK") != 0) || verbose)
	            printf ("%s\n", res);
	        if (res) free ((void *) res);
	    }
	} else
	    return (1);
    }

    return (nread);
}


/**
 *  VOS_UPLOADFILES -- Upload any files on the commandline to the remote
 *  host.  The remote client is responsible for rewriting the commandline
 *  as appropriate, our job here is to suss out which are the file arguments.
 */
int
vos_uploadFiles (int sock, char *cmdline)
{
    char *ip, *op, buf[SZ_BUF], fname[SZ_FNAME];
    int   nfiles = 0;


    for (ip=cmdline; *ip; ) {
	memset (buf, 0, SZ_BUF);
	memset (fname, 0, SZ_FNAME);
	for (op=buf; *ip && !isspace(*ip); )	/* get token		*/
	   *op++ = *ip++;

	/*  Upload the file.  If we have a file:// URL strip out the
	 *  local pathname.  Note that in this implementation we're 
	 *  limited to a single data file per-message.
	 */
	if (strncmp ("file://", buf, 7) == 0) {
	    strcpy (fname, &buf[7]);
	    if (access (fname, F_OK) < 0)	/* file doesn't exist	*/
	        return (-1);
	}
	if (access (buf, F_OK) == 0)
	    strcpy (fname, buf);

	if (fname[0]) {				/* upload the file	*/
	    vosDebug ("uploading file '%s'....\n", fname);
    	    if (vos_sendFile (sock, fname, vos_getFName (fname)) != OK)
		fprintf (stderr, "Error sending file '%s'\n", fname);
	    nfiles++;
	}

	while (*ip && isspace (*ip))		/* skip whitespace	*/
	    ip++;
    }

    return (nfiles);
}


/**
 *  VOS_SENDFILE -- Send a file to a remote host.
 */
int
vos_sendFile (int sock, char *path, char *fname)
{
    char  block[SZ_BLOCK];
    int   fd, nread = 0, nleft = 0, size = 0, nb = 0;
    struct stat fs;

    	    
    if (access (path, R_OK) != 0 || stat (path, &fs) != 0) 
	return (ERR);

    size = fs.st_size;
    nleft = size;

    if ((fd = open (path, O_RDONLY))) {
        /*  Send the header to pass the filename and size, then
         *  send the data itself.
         */
        vos_sockWriteHdr (sock, size, fname, SAMP_DATA, 0, to);
        while (nleft > 0) {
	    memset (block, 0, SZ_BLOCK);
	    nb = min (SZ_BLOCK, nleft);

    	    /* Read from the file, write it to the socket.
     	     */
    	    vos_fileRead (fd, block, nb);
	    vos_sockWrite (sock, block, nb);

       	    nleft -= nb;
	    nread += nb;
        }
        close (fd);
    }

    return (OK);
}


/**
 *  VOS_RECVFILE -- Receive a file of the specified size from a remote host.
 */
int
vos_recvFile (int sock, int size, char *fname)
{
    char  block[SZ_BLOCK];
    int   fd, nread = 0, nleft = size, nb = 0;


    /*  Read the file from the socket, write to the filename.
     */
    vosDebug ("receiving file '%s'....%d\n", fname, size);
    if ((fd = open (fname, O_WRONLY|O_CREAT, 0664))) {
        while (nleft > 0) {
            memset (block, 0, SZ_BLOCK);
	    nb = min (SZ_BLOCK, nleft);

	    /* Read from the socket, write it to the file.
	     */
            vos_sockRead (sock, block, nb);
	    vos_fileWrite (fd, block, nb);

            nleft -= nb;
            nread += nb;
        }
        close (fd);
    }

    return (OK);
}


/**
 *  VOS_HANDLECMDINPUT -- Handle input from an input source.
 */
static void
vos_handleCmdInput ()
{
    register int i, read_timeout = 0, rc;
    char  line[SZ_CMD];
    static char data_file[SZ_FNAME];


    memset (line, 0, SZ_CMD);
    memset (data_file, 0, SZ_FNAME);
    while (1) {				    	/* loop until timeout       */

	/*  Initialize the input file descriptor set and cmd buffer.
	 */
	memset (line, 0, SZ_CMD);
	memset (cmd, 0, SZ_CMD);
	for (i=0; i < MAX_ARGS; i++)
   	    memset (args[i], 0, SZ_LINE);

	memcpy (&fds, &allset, sizeof(allset));
      	if ((rc = select (8, &fds, NULL, NULL, (timeout ? &tm : NULL))) == 0) {
	    read_timeout++;			/* input timeout	    */
	    if (hub_connected && !samp_hubRunning()) {
		hub_connected = 0;
	    }
	    if (!hub_connected && samp_hubRunning()) {
		hub_connected = vos_sampInit();
#ifdef HUB_TIMEOUT
	    } else {
	        unlink (dotfile); 		/* clean up the dotfile     */
       	        vos_sampShutdown ();		/* shutdown Hub connection  */
	        return;
#endif
	    }
	    continue;

	} else if (rc < 0) { 			/*  Select error ....  */
	    vosDebug ("select error '%s'\n", strerror (errno));
	    continue;
	}


	if (FD_ISSET(svr_sock, &fds)) {
	    int  nbytes = 0, nread = 0, type = 0, mode = 0;
	    char fname[SZ_FNAME];


       	    /* Accept a connection on the proxy port from a cmdline client.
       	     */
	    vosDebug ("got input on server socket....\n");
	    memset (fname, 0, SZ_FNAME);

       	    if ((ipc_sock = accept (svr_sock, NULL, NULL)) < 0) {
       		fprintf (stderr, "accept() errno %d: %s", 
		    errno, strerror(errno));
		continue;
	    }

	    if (vos_sockReadHdr (ipc_sock, &nbytes, fname, &type, &mode)) {
		vosDebug ("server input: msgType = %s....\n", 
		    vos_typeName (type));

	        if (strcasecmp (proxy_host, senderIP) && type == SAMP_DATA) {
		    if (vos_recvFile (ipc_sock, nbytes, fname) != OK) {
		        if (verbose || debug)
			    fprintf (stderr, "Error in recvFile '%s'\n", fname);
		    }
		    strcpy (data_file, fname);

	            if (vos_sockReadHdr(ipc_sock, &nbytes, fname,&type,&mode)) {
	                nread = vos_sockRead (ipc_sock, line, nbytes);
		        vos_rewriteCmd (line, data_file);
		    }
    		    memset (data_file, 0, SZ_FNAME);

	        } else if (type == SAMP_CMD) {
	            nread = vos_sockRead (ipc_sock, line, nbytes);
		    vosDebug ("server cmd = '%s'....nr=%d nb=%d\n", 
			line, nread, nbytes);
		    if (data_file[0]) {
		        vos_rewriteCmd (line, data_file);
    		        memset (data_file, 0, SZ_FNAME);
    		    }
	        } else if (type == SAMP_RESULT) {
		    ; /*  Not yet implemented  */

	        } else if (type == SAMP_TEST) {
	    	    close (ipc_sock); 	/*  Test connection, just ignore.  */
	        }
	    }
	    input_sock = ipc_sock;

	} else if (FD_ISSET(session_sock, &fds)) {
	    int  nbytes = 0, nread = 0, type = 0, mode = 0;

	    /*  Accept a command from the session manager for forwarding.
	     */
	    if (vos_sockReadHdr (session_sock, &nbytes, fname, &type, &mode)) {
		vosDebug ("got input on session socket....\n");
	        nread = vos_sockRead (session_sock, line, nbytes);
		input_sock = session_sock;

	    } else {
		/*  Session manager closed the socket, shut it down and 
		 *  disconnect.
		 */
		vosDebug ("Closing session socket....\n");
    		FD_CLR (session_sock, &allset);
    		close (session_sock);
		if (session) free ((void *) session);
		session = NULL;
		session_sock = 0;
		continue;
	    }

	} else
	    vosDebug ("Ignoring input on other descriptor ...\n");


	/*  Kill any trailing spaces and make sure we have an actual cmdline.
	 */
	if (isspace(line[strlen(line)-1]))
	    line[strlen(line)-1] = '\0';   
	if (line[0] == '\0')
	    continue;


	/*  Check whether the command we want to process is directed to the
	 *  proxy process itself.  If so we process it locally rather than
	 *  as a SAMP message for other clients.
	 */
	vosDebug ("handleCmd line: '%s'\n", line);
	if (strncasecmp (line, "exec", 4) == 0 ||
	    strncasecmp (line, "echo", 4) == 0) {
	        /*  Special-case for exec/echo cmd to create single arg
	         */
	        strncpy (cmd, line, 4);
	        sprintf (args[0], "%s", &line[5]);
	        numargs = 1;
	        vos_procCmd (sampH, to, cmd, args, numargs);

	} else if (strncasecmp (line, "status", 4) == 0) {
    	    if (ipc_sock > 0) {
                short slen, nwrite;
		char  buf[SZ_LINE];

		memset (buf, 0, SZ_LINE);
	        sprintf (buf, "Status:  SAMP Hub: %s    ", 
		    (hub_connected ? "ON " : "OFF"));
	        if (sess_connected) {
	            strcat (buf, "Session Mgr: ON  (session='");
		    strcat (buf, session);
		    strcat (buf, "')");
	        } else 
	            strcat (buf, "Session Mgr: OFF");

		slen = strlen (buf);		/* return result string     */
        	if (vos_sockWrite (ipc_sock, &slen, sizeof (short)))
            	    nwrite = vos_sockWrite (ipc_sock, buf, slen);

		continue;
    	    }

	} else if (strncasecmp (line, "quit", 4) == 0) {
	    /*  Quit the proxy process and return.
	     */
	    if (access (vos_dotFile(), F_OK) == 0)
		unlink (vos_dotFile());
       	    vos_sampShutdown ();		/* shutdown Hub connection  */
	    exit (0);

	} else if (strncasecmp (line, "list", 4) == 0) {
	    /*  List the connected clients.
	     */
	    verbose++, numargs=1;
	    vos_procCmd (sampH, to, "listClients", args, numargs);

	} else if (strncasecmp (line, "session", 7) == 0) {
	    /*  Special commands for Session management.
	     */
       	    numargs = sscanf (line, "%s %s", cmd, args[0]);

	    if (strcmp (args[0], "list") == 0) {
		memset (args[0], 0, SZ_LINE);
		strcpy (args[0], "listNodes");

		    if (session_sock == 0) {
			fprintf (stderr, "Error: No session established\n");
			return;
		    } else {
	                verbose++;
		        numargs=1;
	                vos_procCmd (sampH, to, "listNodes", args, numargs);
		    }

	    } else if (strncmp (args[0], "leave", 5) == 0) {
		if (session_sock)
		    vos_closeSession (session_sock);

	    } else {
                /*  Open a client connection to the VOSAMP Session Manager.
                 */
		if (vos_testClientSocket (session_host, session_port) < 0) {
		    fprintf (stderr, 
			"Error: Session manager not available at %s:%d\n", 
			session_host, session_port);
		    return;
		}
                vosDebug ("initializing session '%s' on %s:%d\n", args[0],
                    session_host, session_port);
		session_sock = 0;
		session = strdup (args[0]);
                if ((session_sock = vos_openSession (session_host,
                     session_port, args[0])) < 2) {
                        vosDebug ("session open fails...\n");
                        session_sock = 0, session = NULL;
                } else {
                    vosDebug ("child session sock %d...\n", session_sock);
                    FD_SET (session_sock, &allset);
                    vos_setNonBlock (session_sock);
		    sess_connected = 1;
                }
	    }

	} else {
	    /*  Process the input command as a SAMP message.  Only process
	     *  the command if we're connected to a Hub
	     */
	    if (hub_connected) {
       	        numargs = sscanf (line, "%s %s %s %s %s %s %s %s %s", 
	            cmd, args[0], args[1], args[2], args[3], 
	               args[4], args[5], args[6], args[7]);

	        vos_procCmd (sampH, to, cmd, args, numargs);
	    }
	}
    }

#ifdef FOO
	if (ipc_sock)
	    close (ipc_sock); 		/*  close the socket descriptor  */
#endif
}


/**
 *  VOS_REWRITECMD --  Rewrite the command string with filename substitution.
 */
static void
vos_rewriteCmd (char *line, char *fname)
{
    char *ip, *op, buf[SZ_CMD], obuf[SZ_CMD];

    memset (obuf, 0, SZ_CMD);
    for (ip=line; *ip; ) {
        memset (buf, 0, SZ_CMD);
        for (op=buf; *ip && !isspace(*ip); )    /* get token            */
           *op++ = *ip++;

        /*  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);

        while (*ip && isspace (*ip))            /* skip whitespace      */
            strncat (obuf, ip++, 1);
    }

    memset (line, 0, SZ_CMD);
    strcpy (line, obuf);
}


/**
 *  VOS_REWRITEURL -- Rwrite a URL argument so it is compatible with the
 *  session manager.  Upload any local files if needed.
 */
static char *
vos_rewriteURL (char *in)
{
    static char out[SZ_URL], path[SZ_LINE], *fname;
    char   tmpfile[SZ_LINE];


    memset (path, 0, SZ_LINE);		/* initialize		*/
    memset (tmpfile, 0, SZ_LINE);
    memset (out, 0, SZ_URL);

    switch (vos_urlType (in)) {
    case VOS_LOCALURL:
	sprintf (tmpfile, "/tmp/%s", vos_getFName (in));
	vos_getURL (in, tmpfile);
	strcpy (path, tmpfile);
	break;

    case VOS_LOCALURI:
	strcpy (path, &in[7]);
	break;

    case VOS_LOCALFILE:
	strcpy (path, in);
	break;

    case VOS_REMOTE:
	/* Nothing to do, simply return the string.
	 */
	return (in);
    }

    /*  Get the filename from the path.  Format the new URL so that the 
     *  session manager can easily rewrite it to use the smgr data space.
     */
    fname = vos_getFName (path);
    sprintf (out, "SESSION_URL/%s", fname);

    /*  Send data to the session manager for storage as the 'fname'.  The
     *  session manager will rewrite the URL.
     */
    if (session_sock && vos_sendFile (session_sock, path, fname) != OK)
	fprintf (stderr, "Error uploading file '%s'\n", in);

    return (out);
}


/**
 *  USAGE --  Print a task usage summary.
 */
static void
Usage (void)
{ 
 fprintf (stderr,
 "  Usage:\n"
 "\n" 
 "    %% vosamp [-hvd] [-t to] [-p pattern] [-f file] <cmd> [args ...]\n" 
 "\n" 
 "    where:\n"
 "      <cmd>                           command to process\n"
 "      -%%,--test                       run unit tests\n"
 "      -h,--help                       print help summary\n"
 "      -d,--debug                      debug output\n"
 "      -v,--verbose                    verbose output\n"
 "      -q,--quiet                      suppress all output\n"
 "\n"
 "      -i,--interact                   interactive mode\n"
 "      -m,--many                       handle multiple messages\n"
 "      -s,--sender <sender>            handle only messages from <sender>\n"
 "\n"
 "      -t,--to <to>                    send to specified app (or all)\n"
 "      -p,--pattern <pattern>          message pattern: sync|async|notify\n"
 "      -f,--file <file>                send all commands in the file\n"
 "      -n,--nokeepalive                disable keep_alive feature\n"
 "\n"
 "      -P,--proxy <IP>                 use specfied proxy IP\n"
 "      -T,--timeout <N>                keepalive timeout\n"
 "\n"
 "      -r,--return                     return result to API\n"
 "\n" 
 "  Commands:\n" 
 "\n" 
 "  snoop                                 print all received messages\n"
 "  send <mtype> [<args> ...]             generalized <mtype> message send\n" 
 "\n" 
 "  status                                print Hub availability\n" 
 "  list                                  list all registered clients\n"
 "  access <appName>                      print <appName> availability\n" 
 "  handle <mtype>                        wait for <mtype> message\n" 
 "\n" 
 "  exec <cmd>                            execute a client command\n" 
 "  setenv  <name> <value>                set an environment value\n" 
 "  getenv  <name>                        get an environment value\n" 
 "  setparam <name> <value>               set a parameter value\n" 
 "  getparam <name>                       get a parameter value\n" 
 "\n" 
 "  load <url>                            load the image/table\n" 
 "  loadImage <url>                       load the named image\n" 
 "  loadVOTable <url>                     load the named VOTable\n" 
 "  loadFITS <url>                        load the named FITS bintable\n" 
 "  loadSpec <url>                        load the named spectrum\n" 
 "  loadResource <ivorn>                  load the named VO Resource\n" 
 "\n" 
 "  pointAt <ra> <dec>                    point at given coords\n" 
 "  showRow [<url>] [<tblId>] <row>       highlight specified row\n" 
 "  selectRows [<url>] [<tblId>] <rows>   select specified rows\n" 
 "  bibcode <bibcode>                     load the bibcode\n"
 "\n\n" 
 "  Examples:\n\n"
 "    1)  Load a VOTable to Topcat:\n\n"
 "          %% vosamp load /path/example.xml\n"
 "          %% vosamp load http://foo.edu/example.xml\n"
 "          %% vosamp load http://foo.edu/query?RA=0.0&DEC=0.0&SR=0.1\n"
 "\n"
 "    2)  Send a command string to IRAF:\n"
 "\n"
 "          %% vosamp -t iraf exec 'display dev$pix 1'\n"
 "\n"
 "    3)  List all clients in a SAMP desktop session:\n"
 "\n"
 "          %% vosamp list\n"
 "\n"
 "    4)  Check whether a Hub is available from a script:\n"
 "\n"
 "          set isHub = `vosamp access Hub`\n"
 "          if ($isHub == \"no\") then\n"
 "            echo \"No Hub available, quitting .....\"\n"
 "            exit 1\n"
 "          else\n"
 "            ....do something....\n"
 "          endif\n"
 "\n" 
 );
}



/**
 *  Tests -- Task unit tests.
 */
static void
Tests (char *input)
{
   Task *task  = &self;

   char *img   = "http://iraf.noao.edu/votest/ypix.fits";
   char *vot   = "http://iraf.noao.edu/votest/usno-b.xml";
   char *bin   = "http://iraf.noao.edu/votest/usno-b.fits";


   if (access (input, F_OK) != 0) {
	fprintf (stderr, "Error: cannot open input file '%s'\n", input);
	return;
   }

   vo_taskTest (task, "--help", NULL);

   vo_taskTest (task, "load", input, NULL);
   vo_taskTest (task, "load",        img, NULL);
   vo_taskTest (task, "loadImage",   img, NULL);
   vo_taskTest (task, "load",        vot, NULL);
   vo_taskTest (task, "loadVOTable", vot, NULL);
   vo_taskTest (task, "load",        bin, NULL);
   vo_taskTest (task, "loadFITS",    bin, NULL);

   vo_taskTest (task, "access", "hub", NULL);
   vo_taskTest (task, "list", NULL);
   vo_taskTest (task, "load", input, NULL);

   vo_taskTestReport (self);
}


/**
 *  VOS_DOTFILE -- Create a pathname to the .vosamp file indicating a 
 *  running local proxy server.
 */
static char *
vos_dotFile ()
{
    static char dotfile[SZ_FNAME];
    static int  initialized = 0;

    if (! initialized) {
        char   *home = NULL;

        if ((home = getenv ("HOME")) == NULL)
	    home = "./";
        memset (dotfile, 0, SZ_FNAME);
        sprintf (dotfile, "%s/.vosamp", home);
    }
    initialized++;

    return (dotfile);
}


/**
 *  VOS_SAMPINIT -- Initialize the SAMP/Proxy interface connection.
 */
static int
vos_sampInit (void)
{
    FILE *df;


    /*  If there's no Hub running, don't bother ....
     */
    if (!samp_hubRunning())
	return (0);

    /*  Initialize the SAMP interface.
    */
    sampH = sampInit ("vosamp", "VOClient SAMP Task");
/*
    if (samp_hubActive (sampH) == 0) {
	vosDebug ("sampInit failed to connect ....\n");
        vos_sampShutdown ();
        return (0);
    }
*/

    /*  Set alternative messaging pattern if requested. Valid values are
     *  'synch', 'asynch' or 'notify'.
     */
    if (pattern) {
	switch (tolower(pattern[0])) {
	case 's':  samp_setSyncMode (sampH);	break;	    /* default 	*/
	case 'a':  samp_setASyncMode (sampH);	break;
	case 'n':  samp_setNotifyMode (sampH);	break;
	default:
	    if (verbose)
		fprintf (stderr, "Warning: Invalid pattern '%s'\n", pattern);
	}
    } else {
        /*  Use Synchronous mode by default so we don't exit before receiving
         *  the reply.  Otherwise, we could cause an error in the recipient.
         */
        samp_setSyncMode (sampH);
    }

    /*  If we're not sending to a specific client, disable the name mapping
     *  to speed up the connection.
    if (strncmp (to, "all", 3) == 0)
	samp_setOpt (sampH, "mapClients", 0);
     */

    samp_Metadata (sampH, "author.name",   "Mike Fitzpatrick, NOAO");
    samp_Metadata (sampH, "author.email",  "fitz@noao.edu");
    samp_Metadata (sampH, "samp.description.html",
        	"http://iraf.noao.edu/voclient/vosamp.html");
    samp_Metadata (sampH, "samp.icon.url", 
		"http://iraf.noao.edu/voclient/vao_icon.gif");

    /*  If we're in session mode, subscribe to all message types.  The
     *  same handler is used to pass on the message to other clients in
     *  the session.
     */
    if (session)
        samp_Subscribe (sampH, "*",  vos_sessionHandler);

    /*  Register with the Hub and begin messaging.
     */
    sampStartup (sampH);


    /*  Write the dotfile.
     */
    if (!interact && (df = fopen (vos_dotFile(), "w+")) != (FILE *) NULL) {
	fprintf (df, "%s  %d  %d  %ld  %s\n", vos_getLocalIP(), proxy_port,
	    (int) getpid(), (long) (time((time_t)0) + timeout),
	    (session ? session : "none"));
	fclose (df);
    }

    return (sampH);
}


/**
 *  VOS_SAMPSHUTDOWN -- Shutdown the SAMP/Proxy interface connection.
 */
static void
vos_sampShutdown (void)
{
    if (sampShutdown (sampH) < 0) 			/*  clean up 	*/
	fprintf (stderr, "SAMP shutdown fails\n");
    sampClose (sampH);
}


/**
 *  VOS_MSGHANDLER -- Incoming message handler.
 */
static void
vos_msgHandler (char *sender, char *mtype, char *msg_id, int params)
{
    vosDebug ("in vos_msgHandler.....\n");
    if (filt_sender && strcasecmp (filt_sender, sender))
        return;

    /*  Either no filters were set, or the message is of the requested type,
     *  print the contents.
     */
    if (!quiet)
        vos_printMessage (mtype, samp_id2app (sampH, sender), params);

    if (!interact && !multiple) {       /*  Do a clean disconnect ....  */
        if (sampShutdown (sampH) < 0)
            fprintf (stderr, "SAMP shutdown fails\n");
        sampClose (sampH);
        exit (0);
    }
}


/**
 *  VOS_PRINTMESSAGE -- Print a received message to the stdout.
 */
static void
vos_printMessage (char *mtype, char *sender, Map map)
{
    int  i, npars = samp_getMapSize (map);
    char *key = NULL;
    Map   smap;


    if (verbose)
        printf ("sender: '%s'\t", sender);
    printf ("%s", mtype);

    for (i=0; i < npars; i++) {
        key = samp_getMapKey (map, i);
	if (strncmp (key, "meta", 4) == 0 || strncmp (key, "sub", 3) == 0) {
	    smap = samp_getMapFromMap (map, key);
            printf ("\n");
	    samp_printMap (key, smap);
	} else
            printf ("\t%s=%s", key, samp_getMapVal (map, i));
    }

    printf ("\n");
}


/**
 *  VOS_SESSIONHANDLER -- Generic session message-forwarding handler.
 */

#define MTYPE(s)        (strcasecmp(mtype,s)==0)

static void
vos_sessionHandler (char *sender, char *mtype, char *msg_id, Map map)
{
    char   sess_url[SZ_URL], sess_cmd[SZ_CMD], num[SZ_FNAME];
    char  *tid = NULL, *imid = NULL, *url = NULL, *sid = NULL;
    char  *name = NULL, *value = NULL, *cmd = NULL, *bibcode = NULL;
    char  *key = NULL, *val = NULL;
    int    i, row = 0, rows = 0, len, nelem;
    float  ra, dec;
    Map    meta, ids;


    if (!mtype)
	return;

    memset (sess_url, 0, SZ_URL);
    memset (sess_cmd, 0, SZ_CMD);

    /*
    vosDebug ("sender: '%s'  mtype: '%s'  id: '%s'\n", sender, mtype, msg_id);
    */

    /*  Process the mtype.
     */
    if (MTYPE ("samp.app.ping")) {
	;					/* FIXME -- no-op	*/

    } else if (MTYPE ("samp.app.status")) {
	;					/* FIXME -- no-op	*/

    } else if (MTYPE ("table.load.fits")) {
	tid  = strdup (samp_getStringFromMap (map, "table-id"));
	url  = strdup (samp_getStringFromMap (map, "url"));
	name = strdup (samp_getStringFromMap (map, "name"));

	sprintf (sess_cmd, "loadFITS %s %s", vos_rewriteURL(url), tid);


    } else if (MTYPE ("table.load.votable")) {
	/*  Get parameters from the message Map.
	 */
	tid  = strdup (samp_getStringFromMap (map, "table-id"));
	url  = strdup (samp_getStringFromMap (map, "url"));
	name = strdup (samp_getStringFromMap (map, "name"));

	sprintf (sess_cmd, "loadVOTable %s %s", vos_rewriteURL(url), tid);


    } else if (MTYPE ("table.highlight.row")) {
	tid = strdup (samp_getStringFromMap (map, "table-id"));
	url = strdup (samp_getStringFromMap (map, "url"));
	row = samp_getIntFromMap (map, "row");

	sprintf (sess_cmd, "showRow %s %d", vos_rewriteURL(url), row);

	
    } else if (MTYPE ("image.load.fits")) {
	imid = strdup (samp_getStringFromMap (map, "image-id"));
	url  = strdup (samp_getStringFromMap (map, "url"));
	name = strdup (samp_getStringFromMap (map, "name"));

	sprintf (sess_cmd, "loadImage %s %s", vos_rewriteURL(url), imid);


    } else if (MTYPE ("coord.pointAt.sky")) {
	ra  = samp_getFloatFromMap (map, "ra");
	dec = samp_getFloatFromMap (map, "dec");

	sprintf (sess_cmd, "pointAt %g %g", ra, dec);


    } else if (MTYPE ("client.cmd.exec")) {
	cmd = strdup (samp_getStringFromMap (map, "cmd"));

	sprintf (sess_cmd, "exec %s", cmd);


    } else if (MTYPE ("client.env.get")) { 			/**  NYI  **/
	name = strdup (samp_getStringFromMap (map, "name"));


    } else if (MTYPE ("client.env.set")) {
	name  = strdup (samp_getStringFromMap (map, "name"));
	value = strdup (samp_getStringFromMap (map, "value"));

	sprintf (sess_cmd, "setenv %s %s", name, value);


    } else if (MTYPE ("client.param.get")) { 			/**  NYI  **/
	name  = strdup (samp_getStringFromMap (map, "name"));


    } else if (MTYPE ("client.param.set")) {
	name  = strdup (samp_getStringFromMap (map, "name"));
	value = strdup (samp_getStringFromMap (map, "value"));

	sprintf (sess_cmd, "setparam %s %s", name, value);


    } else if (MTYPE ("bibcode.load")) {
	bibcode  = strdup (samp_getStringFromMap (map, "bibcode"));

	sprintf (sess_cmd, "bibcode %s", bibcode);


    } else if (MTYPE ("table.select.rowList")) {
	tid  = strdup (samp_getStringFromMap (map, "table-id"));
	url  = strdup (samp_getStringFromMap (map, "url"));
	rows = samp_getListFromMap (map, "row-list");

	sprintf (sess_cmd, "selectRows %s %s ", vos_rewriteURL(url), tid);
	len = samp_listLen (rows);
	for (i=0; i < len; i++) {
	    sprintf (num, "%d%c", samp_getIntFromList(rows,i), 
	        (i < (len - 1) ? ',' : ' '));
	    strcat (sess_cmd, num);
	}


    } else if (MTYPE ("spectrum.load.ssa-generic")) {
	url  = strdup (samp_getStringFromMap (map, "url"));
	sid  = strdup (samp_getStringFromMap (map, "spectrum-id"));
	name = strdup (samp_getStringFromMap (map, "name"));
	meta = samp_getMapFromMap (map, "meta");

	sprintf (sess_cmd, "loadSpec %s %s %s", 
	    vos_rewriteURL(url), (name ? name : " "), (sid ? sid : " "));


    } else if (MTYPE ("voresource.loadlist.*")) {		/*  NYI  */
	name = strdup (samp_getStringFromMap (map, "name"));
	ids  = samp_getMapFromMap (map, "ids");

	nelem = samp_getMapSize (ids);
	for (i=0; i < nelem; i++) {
	    key = samp_getMapKey (ids, i);
	    val = samp_getMapVal (ids, i);

	    /*  Forward the resources individually.
	     */
	    memset (sess_cmd, 0, SZ_CMD);
	    sprintf (sess_cmd, "loadResource %s", vos_rewriteURL(url));
    	    vos_forwardCmd (sess_cmd);
	}
	goto clean_up;


    } else if (MTYPE ("samp.hub.disconnect")) {
	; 	/* ignore hub ejections		*/
    } else if (MTYPE ("samp.hub.event.subscriptions")) {
	; 	/* ignore client subscriptions	*/
    } else if (MTYPE ("samp.hub.unregister") ||
    	       MTYPE ("samp.hub.event.unregister")) {
	; 	/* ignore hub closures	*/

    } else {
	if (verbose && debug) 
	    fprintf (stderr, "unknown mtype '%s'\n", mtype);
    }


    /*  Forward the session command.
     */
    vos_forwardCmd (sess_cmd);
	
    if (verbose && debug) 
	fprintf (stderr, "sessionHandler: cmdline = '%s'\n", sess_cmd);


    /*  Clean up.
     */
clean_up:
    if (tid)  free (tid); 
    if (url)  free (url); 
    if (cmd)  free (cmd);
    if (sid)  free (sid);
    if (imid)  free (imid); 
    if (name)  free (name);
    if (value)  free (value);
    if (bibcode)  free (bibcode);
}


/**
 *  VOS_FORWARDCMD -- Forward a session command.
 */
static void
vos_forwardCmd (char *sess_cmd)
{
    int   ssock = session_sock, len, nwrite;

    len = strlen (sess_cmd);
    if (vos_sockWriteHdr (ssock, len, NULL, SAMP_CMD, SAMP_NOTIFY, to))
	nwrite = vos_sockWrite (ssock, sess_cmd, len);
}


/**
 *  VOS_PROCCMD -- Process the command and its arguments.
 */
static void
vos_procCmd (int sampH, char *to, char *cmd, char *args[], int numargs)
{
    int   i, reslen = 0, stat = OK, ssock = session_sock;
    char *result = NULL;
    char buf[SZ_BUF];
    char sess_cmd[SZ_BUF];


    /*  Print command help.
     */
    if (!use_ipc) {
        if (strncmp (cmd, "?", 1) == 0) {
	    Usage ();
	    return;
        }
        if (strncmp (args[0], "?", 1) == 0) {
	    vos_cmdHelp (cmd);
	    return;
        }
    }


    /********************************************
     ***         VOSAMP Custom Commands        **
     ********************************************/
    memset (buf, 0, SZ_BUF);
    memset (sess_cmd, 0, SZ_BUF);

    if (MATCH ("status")) {
	stat = (sampH >= 0);

    } else if (MATCH ("handle")) {
	int timeout = (vot_atoi (args[1]) == 0 ? 999999 : vot_atoi (args[1]));

	if (verbose)
	    fprintf (stderr, "Waiting for '%s' ....\n", args[0]);
	if (*args[1])
	    filt_sender = args[1];

	samp_Subscribe (sampH, (filt_mtype = args[0]), vos_msgHandler);
    	samp_DeclareSubscriptions (sampH);
	sleep (timeout);

    } else if (MATCH ("snoop")) {
        /*  Subscribe to all message types and install the snoop handler.
         *  Sleep forever so the handler can print anything it receives.
         */
	multiple = 1;
        samp_Subscribe (sampH, "*",  vos_msgHandler);
    	samp_DeclareSubscriptions (sampH);
	sleep (9999999);

    } else if (MATCH ("send")) {
	if (strcasecmp (to, "all"))	/* no recipient, use broadcast */
	    samp_setASyncMode (sampH);
        stat = samp_sendGeneric (sampH, to, args[0], &args[1]);

    } else if (MATCH ("echo")) {     			/* ECHO 	      */
	if (!use_ipc) {
	    for (i=0; i < numargs; i++)
	        printf ("%s ", args[i]);
 	    printf ("\n");
	}

    } else if (MATCH ("start")) {     			/* START 	      */
	if (!use_ipc)
            printf ("Starting SAMP interface .....\n");
        sampStartup (sampH);

    } else if (MATCH ("stop")) {      			/* STOP 	      */
        if (!use_ipc)
	    printf ("Stopping SAMP interface .....\n");
        sampShutdown (sampH);

    } else if (MATCH ("help")) {      			/* HELP 	      */
        Usage ();

    } else if (MATCH ("quit")) {                   	/* QUIT 	      */
        if (sampShutdown (sampH) < 0) {
	    if (!use_ipc)
                fprintf (stderr, "Shutdown fails\n");
	}
        sampClose (sampH);
	unlink (vos_dotFile());
        exit (0);

    } else if (MATCH ("trace")) {          		/* TRACE 	      */
        xml_trace++;
        if (xml_trace % 2)
            setenv ("XMLRPC_TRACE_XML", "1", 1);
        else
            unsetenv ("XMLRPC_TRACE_XML");

    } else if (MATCH ("listNodes")) {         		/* LIST NODES	      */
	int  type, mode, nbytes, len, nwrite;
	char buf[SZ_BUF];

	len = strlen ("list");
        if (vos_sockWriteHdr (ssock, len, "list", SAMP_CMD, SAMP_NOTIFY, to)) {
	    nwrite = vos_sockWrite (ssock, "list", len);

	    memset (buf, 0, SZ_BUF);
            if (vos_sockReadHdr (session_sock, &nbytes, NULL, &type, &mode))
                reslen = vos_sockRead (session_sock, buf, nbytes);
	    result = strdup (buf);
	}

    } else if (MATCH ("listClients")) {         	/* LIST CLIENTS	      */
	char *clist = NULL;

	samp_mapClients (sampH);
        clist = samp_getClients (sampH);
	if (use_ipc) {
	    reslen = strlen (clist);
	    result = strdup (clist);
	} else {
	    printf ("\nClients:\n%s\n", clist);
	}
	


    /********************************************
     ***      Hub Administrative Messages     ***
     ********************************************/
    } else if (MATCH ("ping")) {		/* samp.app.ping 	      */
        stat = samp_Ping (sampH, "Hub");



    /********************************************
     ***    Client Administrative Messages    ***
     ********************************************/
    } else if (MATCH ("ping")) {		/* samp.app.ping 	      */
        stat = samp_Ping (sampH, to);

    } else if (MATCH ("access")) {		/* samp.app.ping 	      */
        stat = samp_Ping (sampH, (to=args[0]));
	if (use_ipc) {
	    result = strdup ((stat < 0 ? "no" : "yes"));
	    reslen = strlen (result);
	    return_stat = (stat < 0 ? ERR : OK);
	} else {
	    printf ("%s\n", (stat < 0 ? "no" : "yes"));
	    return_stat = (stat < 0 ? ERR : OK);
	}



    /********************************************
     ***    Table/Image Load Message Types    ***
     ********************************************/
						/* image.load.fits 	      */
    } else if (MATCH ("loadImage")) {
	if ((stat = vos_invalidArg (numargs, args, 1, 1))) {
	    return_stat = ERR;
	    goto cmd_exit_;
	}
        stat = samp_imageLoadFITS (sampH, to, 
		vos_toURL (args[0]),		/* URL/file 	*/
		vos_optArg (args[1]), 		/* imgId	*/
		vos_optArg (args[2]));		/* name		*/
	sprintf (sess_cmd, "loadImage %s %s", 
	    vos_rewriteURL(vos_toURL (args[0])), vos_optArg (args[1]));
	if (session && input_sock != session_sock)
	    vos_sendCmd (session_sock, sess_cmd);

    } else if (MATCH ("loadFITS")) {		/* table.load.fits 	      */
	if ((stat = vos_invalidArg (numargs, args, 1, 1))) {
	    return_stat = ERR;
	    goto cmd_exit_;
	}
        stat = samp_tableLoadFITS (sampH, to, 
		vos_toURL (args[0]),		/* URL/file 	*/
		vos_optArg (args[1]), 		/* tblId	*/
		vos_optArg (args[2]));		/* name		*/
	sprintf (sess_cmd, "loadFITS %s %s", 
	    vos_rewriteURL(vos_toURL (args[0])), vos_optArg (args[1]));
	if (session && input_sock != session_sock)
	    vos_sendCmd (session_sock, sess_cmd);


    } else if (MATCH ("loadVOTable")) {		/* table.load.votable 	      */
	if ((stat = vos_invalidArg (numargs, args, 1, 1))) {
	    return_stat = ERR;
	    goto cmd_exit_;
	}
        stat = samp_tableLoadVOTable (sampH, to, 
		vos_toURL (args[0]), 		/* URL/file 	*/
		vos_optArg (args[1]), 		/* tblId	*/
		vos_optArg (args[2]));		/* name		*/
	sprintf (sess_cmd, "loadVOTable %s %s", 
	    vos_rewriteURL(vos_toURL (args[0])), vos_optArg (args[1]));
	if (session && input_sock != session_sock)
	    vos_sendCmd (session_sock, sess_cmd);

    } else if (MATCH ("load")) {
	char   fname[SZ_LINE];
	extern int vot_fileType();

	memset (fname, 0, SZ_LINE);

	if (strncmp (args[0], "http://", 7) == 0) {
            strcpy (fname, "/tmp/vostmp");    /* temp download name    */
	    if (access (fname, F_OK) == 0)
		unlink (fname);
            if (vos_getURL (args[0], fname) <= 0)
                fprintf (stderr, "Error accessing url '%s'\n", args[0]);

	} else if (strncmp (args[0], "file://", 7) == 0) {
	    strcpy (fname, &args[0][7]);
	} else 
	    strcpy (fname, args[0]);

	if (access (fname, F_OK) == 0) {
	    switch (vot_fileType (fname)) {
	    case VOT_FITS:
                stat = samp_imageLoadFITS (sampH, to, 
		    vos_toURL (fname),		/* URL/file 	*/
		    vos_optArg (args[1]), 	/* imgId	*/
		    vos_optArg (args[2]));	/* name		*/
		sprintf (sess_cmd, "loadImage %s %s", 
		    vos_rewriteURL(vos_toURL (fname)), vos_optArg (args[1]));
		if (session && input_sock != session_sock)
		    vos_sendCmd (session_sock, sess_cmd);
	        break;
	    case VOT_VOTABLE:
                stat = samp_tableLoadVOTable (sampH, to, 
		    vos_toURL (fname), 		/* URL/file 	*/
		    vos_optArg (args[1]), 	/* tblId	*/
		    vos_optArg (args[2]));	/* name		*/
		sprintf (sess_cmd, "loadVOTable %s %s", 
		    vos_rewriteURL(vos_toURL (fname)), vos_optArg (args[1]));
		if (session && input_sock != session_sock)
		    vos_sendCmd (session_sock, sess_cmd);
	        break;
	    case VOT_FITS_SPEC:
	        break;
	    case VOT_VOTABLE_SPEC:
	        break;
	    default:
	        if (!use_ipc)
	            fprintf (stderr,
			"Error: cannot determine file type of '%s'.\n",
		        args[0]);
	    }
	} else
	    fprintf (stderr, "Error: cannot access '%s'.\n", fname);



    /********************************************
     ***        Resource Message Types        ***
     ********************************************/
    } else if (MATCH ("loadResource")) {	/* voresource.loadlist        */
	if ((stat = vos_invalidArg (numargs, args, 1, 1))) {
	    return_stat = ERR;
	    goto cmd_exit_;
	}
	/*  NYI  */



    /********************************************
     ***         Utility Message Types        ***
     ********************************************/
    } else if (MATCH ("showRow")) {		/* table.highlight.row        */
		/* showRow <url> <row> [<id>]	*/
        stat = samp_tableHighlightRow (sampH, to, 
		vos_optArg (args[2]),		/* table-id 	*/
		vos_toURL (args[0]),		/* URL/file 	*/
		vot_atoi(args[1]));		/* row 		*/
	
    } else if (MATCH ("selectRows")) {		/* table.select.rowList       */
	int  nrows = 0;
	int *rows = vos_toIntArray (args[2], &nrows);

	stat = samp_tableSelectRowList (sampH, to, 
		vos_optArg (args[0]),		/* table-id	*/
                vos_toURL (args[1]),		/* URL/file	*/
		rows,				/* rows[]	*/
		nrows);				/* row 		*/

    } else if (MATCH ("pointAt")) {		/* coord.pointAt.sky          */
        stat = samp_coordPointAtSky (sampH, to, 
		vot_atof (args[0]), 		/* RA		*/
		vot_atof (args[1]));		/* Dec		*/


    /********************************************
     ***     Spectrum Load Message Types      ***
     ********************************************/
    } else if (MATCH ("loadSpec")) {		/* spectrum.load.ssa-generic  */
	/*  FIXME -- meta map not implemented */
	stat = samp_specLoadSSAGeneric (sampH, to, 
		vos_toURL (args[0]),		/* URL		*/
		0, 				/* Map meta	*/  /* NYI */
		vos_optArg (args[2]), 		/* spectrumId	*/
		vos_optArg (args[3]));		/* name		*/


    /********************************************
     ***         Bibcode Message Types        ***
     ********************************************/
    } else if (MATCH ("bibcode")) {		/* bibcode.load	              */
        stat = samp_bibLoad (sampH, to, args[1]);


    /********************************************
     ***         VO/IRAF Message Types        ***
     ********************************************/
    } else if (MATCH ("exec")) {		/* client.cmd.exec    	      */
        samp_cmdExec (sampH, to, args[0]);

    } else if (MATCH ("getenv")) {		/* client.env.get     	      */
        char *v = samp_envGet (sampH, to, 
		args[0]); 			/* name		*/
	if (use_ipc) {
	    reslen = strlen (v);
	    result = strdup (v);
	} else
	    printf ("%s\n", v);
  	if (v) free ((void *) v);

    } else if (MATCH ("setenv")) {		/* client.env.set     	      */
        stat = samp_envSet (sampH, to, 
		args[0], 			/* name		*/
		args[1]);			/* value	*/

    } else if (MATCH ("getparam")) {		/* client.param.get   	      */
        char *v = samp_paramGet (sampH, to, 
		args[0]); 			/* name		*/
	if (use_ipc) {
	    reslen = strlen (v);
	    result = strdup (v);
	} else
	    printf ("%s\n", v);
  	if (v) free ((void *) v);

    } else if (MATCH ("setparam")) {		/* client.param.set           */
        stat = samp_paramSet (sampH, to, 
		args[0], 			/* name		*/
		args[1]);			/* value	*/


    /********************************************
     ***            Unknown Command           ***
     ********************************************/
    } else {
	if (use_ipc) {
	    memset (buf, 0, SZ_BUF);
	    sprintf (buf, "Error: unknown command '%s'\n", cmd);
	    result = strdup (buf);
	    reslen = strlen (buf);
	} else
	    fprintf (stderr, "Error: unknown command '%s'\n", cmd);
    }


    if (!quiet) {
	if (!reslen) {
	    result = strdup ((stat < 0 ? "Error" : "OK"));
	    reslen = strlen (result);
	    return_stat = (stat < 0 ? ERR : OK);
        }
    }
    vosDebug ("procCmd: reslen=%d  result='%s'\n", reslen, result);
    

    /*  Return result to the remote caller.
     */
cmd_exit_:
    if (ipc_sock > 0) {
	int  nwrite;
	short slen = reslen;

        if (vos_sockWrite (ipc_sock, &slen, sizeof (short)))
	    nwrite = vos_sockWrite (ipc_sock, result, slen);
    }
	    
    if (result)  free (result);
}


/**
 *  VOS_INVALIDARG -- Check arguments for validity.
 */
static int
vos_invalidArg (int argc, char *argv[], int nargs, int exist)
{
    int  stat = 0;

    /*  See if the number of args we have is less than what we require.
     */
    if (argc < nargs) {
	fprintf (stderr, "Error: invalid number of args for command '%s'\n",
	    cmd);
	return ((stat = -1));
    }

    /*  See whether we require the existance of the first argument.  If this
     *  is a local file it must exist, assume URLs are valid.
     */
    if (exist) {
        if (!argv[0] || !argv[0][0])
	    return ((stat = -1));
	if (strncmp ("http", argv[0], 4) && access (argv[0], R_OK)) {
	    fprintf (stderr, "Error: cannot access file '%s'\n", args[0]);
	    return ((stat = -1));
	}
    }

    return (stat);
}


/**
 *  VOS_CMDHELP -- Print a command help summary for interactive mode.
 */
static void
vos_cmdHelp (char *cmd)
{
    if (MATCH ("status")) {
	printf ("status\n");
    } else if (MATCH ("handle")) {
	;
    } else if (MATCH ("snoop")) {
	printf ("snoop\n");
    } else if (MATCH ("send")) {
	;
    } else if (MATCH ("start")) {
	printf ("start\n");
    } else if (MATCH ("stop")) {
	printf ("stop\n");
    } else if (MATCH ("echo")) {
	printf ("echo <text_string>\n");
    } else if (MATCH ("help")) {
	printf ("help <cmd>\n");
    } else if (MATCH ("quit")) {
	printf ("quit\n");
    } else if (MATCH ("trace")) {
	printf ("trace\n");
    } else if (MATCH ("listClients")) {
	printf ("listClients\n");
    } else if (MATCH ("ping")) {
	printf ("ping <appName>\n");
    } else if (MATCH ("access")) {
	printf ("access <appName>\n");

    } else if (MATCH ("loadImage") || MATCH ("loadFITS")) {
	printf ("loadImage <file | URL> [<table-id> [<name>]]\n");
    } else if (MATCH ("loadVOTable")) {
	printf ("loadVOTable <file | URL> [<table-id> [<name>]]\n");
    } else if (MATCH ("loadResource")) {
	;
    } else if (MATCH ("showRow")) {
	printf ("showRow <table-id> <file | URL> <row>\n");
    } else if (MATCH ("selectRows")) {
	printf ("selectRows <table-id> <file | URL> <rowList>\n");

    } else if (MATCH ("pointAt")) {
	printf ("pointAt <ra> <dec>\t# coords in decimal degrees\n");

    } else if (MATCH ("loadSpec")) {
	printf ("loadSpec <URL> <meta> [<spectrum-id> <name>]\n");
    } else if (MATCH ("bibcode")) {
	printf ("bibcode <bibcode>\n");

    } else if (MATCH ("exec")) {
	printf ("exec <cmd_str>\n");
    } else if (MATCH ("getenv")) {
	printf ("getenv <name>\n");
    } else if (MATCH ("setenv")) {
	printf ("setenv <name> <value>\n");
    } else if (MATCH ("getparam")) {
	printf ("getparam <name>\n");
    } else if (MATCH ("setparam")) {
	printf ("setparam <name> <value>\n");
    }
}


/**
 *  VOSDEBUG -- Utility to print debug messages.
 */
static void
vosDebug (char *format, ...)
{
    va_list  argp;
    char buf[1024];
    extern char *vo_encodeString ();


    if (!debug)
	return;

    /*  Format the message.
     */
    memset (buf, 0, 1024);
    va_start (argp,  format);
    vo_encodeString (buf, format, &argp);
    va_end (argp);

    if (buf[strlen(buf)-1] != '\n') 	/*  ensure a newline  	*/
        strcat (buf, "\n");

    fprintf (stderr, "[%d]  %s", (int)getpid(), buf);
}



/**
 *  VOS_OPENSESSION -- Open a connection to the VOSAMP Session Manager.
 *
 *  @brief      Open a connection to the VOSAMP Session Manager.
 *  @fn         int vos_openSession (char *host, int port, char *session_name)
 *
 *  @param  host        session manager host
 *  @param  port        session manager connection port
 *  @param  name        session name
 *  @return             fd to the session socket
 */
int
vos_openSession (char *host, int port, char *session_name)
{
    int   sock = 0, cb_sock = 0, cb_port = 0, nr, nw, len, ready = SESS_READY;
    char  cmd[SZ_LINE];


    /*  Open a socket to the connection port.
     */
    if ((sock = vos_openClientSocket (host, port, 1)) <= 0)
	return (1);

    /*  Read the callback port number.
     */
    if ((nr = vos_sockRead (sock, &cb_port, sizeof (short))) != sizeof (short))
	return (1);

    /*  Close the socket to the connection port.
     */
    close (sock); 		

    /*  Open a new connection to the callback port.
     */
    if ((cb_sock = vos_openClientSocket (host, cb_port, 1)) <= 0)
	return (1);

    /*  Write the 'ready' code to the callback prot.
     */
    nw = vos_sockWrite (cb_sock, &ready, sizeof (short));


    /*  Send the 'connect' message to connect to the named session.  The
     *  server will either create a new session or have us join an existing
     *  session created by another node.
     */
    memset (cmd, 0, SZ_LINE);
    sprintf (cmd, "connect %s", session_name);
    len = strlen (cmd);
    if (vos_sockWriteHdr (cb_sock, len, NULL, SAMP_CMD, SAMP_NOTIFY, "smgr"))
        nw = vos_sockWrite (cb_sock, cmd, len);

    /*  Return 0 if we can connect, 1 on err, or the callback descriptor.
     */
    return (cb_sock);
}


/**
 *  VOS_CLOSESESSION -- Close the specified session connection.
 *
 *  @brief      Close the specified session connection.
 *  @fn         int vos_closeSession (int sock)
 *
 *  @param  sock        session socket fd
 *  @return             0 if cmd was sent, 1 otherwise
 */
int
vos_closeSession (int sock)
{
    if (vos_sockWriteHdr (sock, 0, NULL, SAMP_QUIT, SAMP_NOTIFY, "smgr"))
	return (1);
    return (0);
}