upgrade xpa

1 files changed, 1217 insertions, 0 deletions

diff --git a/xpa/command.c b/xpa/command.c
new file mode 100644
index 0000000..2ea182d
--- /dev/null
+++ b/xpa/command.c
@@ -0,0 +1,1217 @@
+/*
+ *	Copyright (c) 1999-2003 Smithsonian Astrophysical Observatory
+ */
+
+#include <xpap.h>
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ *
+ * 			Private Routines and Data
+ *
+ *
+ *----------------------------------------------------------------------------
+ */
+
+/* this is the static xpa struct that holds the reserved commands */
+static XPA rxpa=NULL;
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPACmdParseNames
+ *
+ * Purpose:	massage a name string, changing multiple sequential spaces
+ *		into a single space
+ *
+ * Returns:	new name, with spaces massaged (also number of spacess)
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+static char *
+XPACmdParseNames(char *lbuf, int *ntokens)
+#else
+static char *XPACmdParseNames(lbuf, ntokens)
+     char *lbuf;
+     int *ntokens;
+#endif
+{
+  char tbuf[SZ_LINE];
+  int lp=0;
+  char *buf;
+
+  /* can't be larger than the original string */
+  buf = (char *)xmalloc(strlen(lbuf)+1);
+  *buf = '\0';
+  *ntokens = 0;
+
+  /* pick off each word, separating by a single space */
+  while( word(lbuf, tbuf, &lp)){
+    if( *buf != '\0' )
+      strcat(buf, " ");
+    strcat(buf, tbuf);
+    *ntokens += 1;
+  }
+
+  /* make the string the right size */
+  buf = (char *)xrealloc(buf, strlen(buf)+1);
+  return(buf);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPAReceiveNSConnect
+ *
+ * Purpose:	reset and re-establish connection to name server
+ *
+ * Returns:	xpa callback error codes
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+static int 
+XPAReceiveNSConnect (void *client_data, void *call_data, char *paramlist,
+	       char *buf, size_t len)
+#else
+static int XPAReceiveNSConnect(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char *buf;
+     size_t len;
+#endif
+{
+  XPA xpa = (XPA)call_data;
+  XPA txpa;
+  char tbuf[SZ_LINE];
+  int doall=0;
+  int lp=0;
+
+  if( paramlist && *paramlist ){
+    if( word(paramlist, tbuf, &lp) && !strcmp(tbuf, "-all") ){
+      doall = 1;
+    }
+  }
+  if( doall ){
+    for(txpa=XPAListHead(); txpa!=NULL; txpa=txpa->next){
+      XPANSAdd(txpa, NULL, NULL);
+    }
+  }
+  else{
+    XPANSAdd(xpa, NULL, NULL);
+  }
+  return(0);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPAReceiveNSDisconnect
+ *
+ * Purpose:	break connection to name server
+ *
+ * Returns:	xpa callback error codes
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+static int 
+XPAReceiveNSDisconnect (void *client_data, void *call_data, char *paramlist,
+	       char *buf, size_t len)
+#else
+static int XPAReceiveNSDisconnect(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char *buf;
+     size_t len;
+#endif
+{
+  XPA xpa = (XPA)call_data;
+  XPA txpa;
+  NS ns, tns;
+  char tbuf[SZ_LINE];
+  int doall=0;
+  int lp=0;
+
+  if( paramlist && *paramlist ){
+    if( word(paramlist, tbuf, &lp) && !strcmp(tbuf, "-all") ){
+      doall = 1;
+    }
+  }
+  if( doall ){
+    for(txpa=XPAListHead(); txpa!=NULL; txpa=txpa->next){
+      for(ns=txpa->nshead; ns!= NULL; ){
+	tns = ns->next;
+	XPANSClose(txpa, ns);
+	ns = tns;
+      }
+    }
+  }
+  else{
+    for(ns=xpa->nshead; ns!= NULL; ){
+      tns = ns->next;
+      XPANSClose(xpa, ns);
+      ns = tns;
+    }
+  }
+  return(0);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPAReceiveEnv
+ *
+ * Purpose:	set an environment variable
+ *
+ * Returns:	xpa callback error codes
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+static int 
+XPAReceiveEnv (void *client_data, void *call_data, char *paramlist,
+	       char *buf, size_t len)
+#else
+static int XPAReceiveEnv(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char *buf;
+     size_t len;
+#endif
+{
+  XPA xpa = (XPA)call_data;
+  char name[SZ_LINE];
+  char value[SZ_LINE];
+  char *tbuf;
+  int lp=0;
+
+  if( word(paramlist, name, &lp) ){
+    if( word(paramlist, value, &lp) ){
+      tbuf = (char *)xmalloc(strlen(name)+1+strlen(value)+1);
+      snprintf(tbuf, SZ_LINE, "%s=%s", name, value);
+      putenv(tbuf);
+      return(0);
+    }
+    else{
+      if( strchr(name, '=') != NULL ){
+	tbuf = xstrdup(name);
+	putenv(tbuf);
+	return(0);
+      }
+      else{
+	XPAError(xpa, "XPA setenv requires name and value pair\n");
+	return(-1);
+      }
+    }
+  }
+  else{
+    XPAError(xpa, "XPA setenv requires name and value pair\n");
+    return(-1);
+  }
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPASendEnv
+ *
+ * Purpose:	return an environment variable to client
+ *
+ * Returns:	xpa callback error codes
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+static int 
+XPASendEnv (void *client_data, void *call_data, char *paramlist,
+	    char **buf, size_t *len)
+#else
+static int XPASendEnv(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char **buf;
+     size_t *len;
+#endif
+{
+  int tlen;
+  char *tbuf;
+  char *ebuf;
+
+  if( (ebuf = (char *)getenv(paramlist)) != NULL ){
+    tlen = strlen(ebuf)+2;
+    tbuf = (char *)xmalloc(tlen);
+    snprintf(tbuf, tlen, "%s\n", ebuf);
+    *buf = tbuf;
+    *len = strlen(tbuf);
+  }
+  else{
+    *buf = xstrdup("\n");
+    *len = 1;
+  }
+  return(0);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPAReceiveReserved
+ *
+ * Purpose:	execute reserved command
+ *
+ * Returns:	xpa callback error codes
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+static int 
+XPAReceiveReserved (void *client_data, void *call_data, char *paramlist,
+		    char *buf, size_t len)
+#else
+static int XPAReceiveReserved(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char *buf;
+     size_t len;
+#endif
+{
+  char *cmd = (char *)client_data;
+  XPA xpa = (XPA)call_data;
+
+  if( !strcmp(cmd, "end") ){
+    xpa->comm->status |= XPA_STATUS_ENDBUF;
+    return(0);
+  }
+  else if( !strcmp(cmd, "exec") ){
+    xpa->comm->status |= XPA_STATUS_READBUF;
+    return(0);
+  }
+  else{
+    return(-1);
+  }
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPASendHelp
+ *
+ * Purpose:	send help strings
+ *
+ * Returns:	xpa callback error codes
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+static int 
+XPASendHelp (void *client_data, void *call_data, char *paramlist,
+	     char **buf, size_t *len)
+#else
+static int XPASendHelp(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char **buf;
+     size_t *len;
+#endif
+{
+  XPA xpa = (XPA)call_data;
+  XPACmd cmd;
+  int lp=0;
+  int slen;
+  char tbuf[SZ_LINE];
+  char lbuf[SZ_LINE];
+  char *sbuf;
+
+  if( !paramlist || !*paramlist ){
+    if( xpa->version != NULL ){
+      snprintf(lbuf, SZ_LINE, "XPA version: %s\n", xpa->version);
+      send(xpa_datafd(xpa), lbuf, strlen(lbuf), 0);
+    }
+  }
+  if( xpa->commands == NULL ){
+    if( xpa->help != NULL ){
+      slen = strlen(xpa->help)+SZ_LINE;
+      sbuf = (char *)xmalloc(slen);
+      snprintf(sbuf, slen, "%s\n", xpa->help);
+      send(xpa_datafd(xpa), sbuf, strlen(sbuf), 0);
+      xfree(sbuf);
+    }
+    else{
+      strcpy(lbuf, "\n");
+      send(xpa_datafd(xpa), lbuf, strlen(lbuf), 0);
+    }
+  }
+  else{
+    if( paramlist && *paramlist ){
+      while( word(paramlist, tbuf, &lp) ){
+	for(cmd=xpa->commands; cmd!=NULL; cmd=cmd->next){
+	  if( !strcmp(tbuf, cmd->name) ){
+	    if( cmd->help != NULL ){
+	      slen = strlen(cmd->name)+strlen(cmd->help)+SZ_LINE;
+	      sbuf = (char *)xmalloc(slen);
+	      snprintf(sbuf, slen, "%s:\t%s\n", cmd->name, cmd->help);
+	      send(xpa_datafd(xpa), sbuf, strlen(sbuf), 0);
+	      xfree(sbuf);
+	    }
+	    else{
+	      snprintf(lbuf, SZ_LINE, "%s:\t(no help available)\n", cmd->name);
+	      send(xpa_datafd(xpa), lbuf, strlen(lbuf), 0);
+	    }
+	  }
+	}
+      }
+    }
+    else{
+      for(cmd=xpa->commands; cmd!=NULL; cmd=cmd->next){
+	if( cmd->help != NULL ){
+	  slen = strlen(cmd->name)+strlen(cmd->help)+SZ_LINE;
+	  sbuf = (char *)xmalloc(slen);
+	  snprintf(sbuf, slen, "%s:\t%s\n", cmd->name, cmd->help);
+	  send(xpa_datafd(xpa), sbuf, strlen(sbuf), 0);
+	  xfree(sbuf);
+	}
+	else{
+	  snprintf(lbuf, SZ_LINE, "%s:\t(no help available)\n", cmd->name);
+	  send(xpa_datafd(xpa), lbuf, strlen(lbuf), 0);
+	}
+      }
+    }
+  }
+  return(0);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPASendVersion
+ *
+ * Purpose:	send XPA version string
+ *
+ * Returns:	xpa callback error codes
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+static int 
+XPASendVersion (void *client_data, void *call_data, char *paramlist,
+	     char **buf, size_t *len)
+#else
+static int XPASendVersion(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char **buf;
+     size_t *len;
+#endif
+{
+  XPA xpa = (XPA)call_data;
+  char lbuf[SZ_LINE];
+
+  if( xpa->version != NULL )
+    snprintf(lbuf, SZ_LINE, "%s\n", xpa->version);
+  else
+    strcpy(lbuf, "\n");
+  send(xpa_datafd(xpa), lbuf, strlen(lbuf), 0);
+  return(0);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ *
+ * 			Semi-Public Routines and Data
+ *
+ *  		    These routines are used by XPAHandler and XPANew
+ *
+ *
+ *----------------------------------------------------------------------------
+ */
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPAInitReserved
+ *
+ * Purpose:	add the reserved commands to the reserved xpa struct
+ *
+ * Results:	none
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+void 
+XPAInitReserved (void)
+#else
+void XPAInitReserved()
+#endif
+{
+  if( !rxpa ){
+    if( (rxpa = (XPA)xcalloc(1, sizeof(struct xparec))) == NULL )
+      return;
+    /* XPACmdAdd requires that the callbacks be defined explicitly in rxpa */
+    rxpa->send_callback = XPASendCommands;
+    rxpa->receive_callback = XPAReceiveCommands;
+    /* add reserved commands */
+    XPACmdAdd(rxpa, "-acl",
+	  "\tget (set) the access control list\n\t\t  options: host type acl",
+	  XPASendAcl, NULL, NULL, XPAReceiveAcl, NULL, "fillbuf=false");
+    XPACmdAdd(rxpa, "-env",
+	  "\tget (set) an environment variable\n\t\t  options: name (value)",
+	  XPASendEnv, NULL, NULL, XPAReceiveEnv, NULL, NULL);
+    XPACmdAdd(rxpa, "-exec",
+	  "\texecute commands from buffer\n\t\t  options: none",
+	  NULL, NULL, NULL, XPAReceiveReserved, (void *)"exec", NULL);
+    XPACmdAdd(rxpa, "-help",
+	  "\treturn help string for specified XPA\n\t\t  options: cmd name (commands only)",
+	  XPASendHelp, NULL, NULL, NULL, NULL, NULL);
+    XPACmdAdd(rxpa, "-ltimeout",
+	  "\tget (set) long timeout\n\t\t  options: seconds|reset",
+	  XPASendLTimeout, NULL, NULL, XPAReceiveLTimeout, NULL, NULL);
+    XPACmdAdd(rxpa, "-nsconnect",
+	  "\tre-establish name server connection to this XPA\n\t\t  options: -all",
+	  NULL, NULL, NULL, XPAReceiveNSConnect, NULL, NULL);
+    XPACmdAdd(rxpa, "-nsdisconnect",
+	  "\tbreak name server connection to this XPA\n\t\t  options: -all",
+	  NULL, NULL, NULL, XPAReceiveNSDisconnect, NULL, NULL);
+    XPACmdAdd(rxpa, "-remote",
+	  "\tconnect to remote name service with specified acl \n\t\t  options: host:port +|-|acl -proxy",
+	  XPASendRemote, NULL, NULL, XPAReceiveRemote, NULL, "fillbuf=false");
+    XPACmdAdd(rxpa, "-clipboard",
+	  "\tset/get clipboard information \n\t\t  options: [cmd] name",
+	  XPASendClipboard, NULL, NULL, XPAReceiveClipboard, NULL, NULL);
+    XPACmdAdd(rxpa, "-stimeout",
+	  "\tget (set) short timeout\n\t\t  options: seconds|reset",
+	  XPASendSTimeout, NULL, NULL, XPAReceiveSTimeout, NULL, NULL);
+    XPACmdAdd(rxpa, "-version",
+	  "\treturn XPA version string\n\t\t  options: none",
+	  XPASendVersion, NULL, NULL, NULL, NULL, NULL);
+  }
+}
+
+#ifdef ANSI_FUNC
+void 
+XPAFreeReserved (void)
+#else
+void XPAFreeReserved()
+#endif
+{
+  XPACmd cmd, tcmd;
+  if( !rxpa ) return;
+  /* free reserved commands */
+  for(cmd=rxpa->commands; cmd!=NULL; ){
+    tcmd = cmd->next;
+    XPACmdDel(rxpa, cmd);
+    cmd = tcmd;
+  }
+  xfree(rxpa);
+  rxpa = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPACmdLookupReserved
+ *
+ * Purpose:	lookup a reserved command name
+ *
+ * Results:	cmd struct or null
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+XPACmd 
+XPACmdLookupReserved (XPA xpa, char *lbuf, int *lp)
+#else
+XPACmd XPACmdLookupReserved(xpa, lbuf, lp)
+     XPA xpa;
+     char *lbuf;
+     int *lp;
+#endif
+{
+  XPACmd cmd;
+  int lp2=0;
+  char *lptr;
+  char name[SZ_LINE];
+
+  /* make sure we have something to work with */
+  if( (rxpa==NULL) || (lbuf==NULL) || (lbuf[*lp]=='\0') )
+    return(NULL);
+
+  /* this is where we start parsing */
+  lptr = &(lbuf[*lp]);
+
+  /* to simplify life, we assume reserved words are 1 token */
+  if( !word(lptr, name, &lp2) )
+    return(NULL);
+
+  /* look for reserved keywords that have callbacks */
+  for(cmd=rxpa->commands; cmd!=NULL; cmd=cmd->next){
+    if( !strcmp(name, cmd->name) ){
+      *lp += lp2;
+      return(cmd);
+    }
+  }
+
+  /* nothing, nowhere */
+  return(NULL);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPACmdLookup
+ *
+ * Purpose:	lookup a user-defined command name
+ *
+ * Results:	cmd struct or null
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+XPACmd 
+XPACmdLookup (XPA xpa, char *lbuf, int *lp)
+#else
+XPACmd XPACmdLookup(xpa, lbuf, lp)
+     XPA xpa;
+     char *lbuf;
+     int *lp;
+#endif
+{
+  XPACmd cmd;
+  int i;
+  int lp2;
+  int len, tlen;
+  char *lptr;
+  char tbuf[SZ_LINE];
+  char name[SZ_LINE];
+
+  /* make sure we have something to work with */
+  if( (xpa==NULL) || (lbuf==NULL) || (lbuf[*lp]=='\0') )
+    return(NULL);
+
+  /* this is where we start parsing */
+  lptr = &(lbuf[*lp]);
+
+  /* look up commands for this name */
+  for(cmd=xpa->commands; cmd!=NULL; cmd=cmd->next){
+    /* make up a name with the required number of tokens for this command */
+    *name = '\0';
+    lp2 = 0;
+    tlen = 0;
+    for(i=0; i<cmd->ntokens; i++){
+      if( word(lptr, tbuf, &lp2)){
+	len = strlen(tbuf)+1;
+	if( (tlen+len) <= (SZ_LINE-1) ){
+	  if( *name != '\0' )
+	    strcat(name, " ");
+	  strcat(name, tbuf);
+	  tlen += len;
+	}
+	/* not enough room */
+	else{
+	  *name = '\0';
+	  break;
+	}
+      }
+    }
+    /* we now have the name,  see if its what we want */
+    if( *name && !strcmp(cmd->name, name) ){
+      *lp += lp2;
+      return(cmd);
+    }
+  }
+
+  /* did not find the command in this xpa -- now look through reserved */
+  return(XPACmdLookupReserved(xpa, lbuf, lp));
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPAReceiveCommands
+ *
+ * Purpose:	process a list of commands from xpaset
+ *
+ * Results:	number of commands processed
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+int 
+XPAReceiveCommands (void *client_data, void *call_data, char *paramlist,
+		    char *buf, size_t len)
+#else
+int XPAReceiveCommands(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char *buf;
+     size_t len;
+#endif
+{
+  XPA xpa = (XPA)call_data;
+  XPACmd cmd;
+  int lp;
+  int savelp;
+  int plen;
+  int bgot;
+  int got=0;
+  int gotbuf=0;
+  int freebuf=1;
+  char lbuf[SZ_LINE];
+  char tbuf[SZ_LINE];
+  char tbuf1[SZ_LINE];
+
+  /* use ";" as a command separator (as well as \n) */
+  newdtable(";");
+
+  /* if we already have buf, there will be no need to get it */
+  if( buf )
+    gotbuf++;
+
+  /* if we have no paramlist, we read from the socket */
+  if( (xpa_datafd(xpa) >=0) && (!paramlist || (*paramlist == '\0')) ){
+    xpa->comm->status |= XPA_STATUS_READBUF;
+    XPAGets(xpa, xpa_datafd(xpa), lbuf, SZ_LINE, XPALongTimeout());
+    FPRINTF((stderr, "%sXPAReceiveCommands: read %s\n", _sp, lbuf));
+  }
+  else{
+    xpa->comm->status &= ~XPA_STATUS_READBUF;
+    nowhite(paramlist, lbuf);
+  }
+
+  /* we must have something to start with */
+  if( *lbuf == '\0' ){
+    XPAError(xpa, xpaMessbuf[XPA_RTN_NOCMD2]);
+    got = -1;
+    goto done;
+  }
+  
+  /* This look either executes the one set of commands in paramlist,
+     or reads one line at a time from the socket and executes commands.
+     In the latter case, each callback can read the socket as well */
+  while( 1 ){
+    FPRINTF((stderr, "%sXPAReceiveCommands: top of loop: %s\n", _sp, lbuf));
+    lp = 0;
+    while( lbuf[lp] != '\0' ){
+      if( (cmd = XPACmdLookup(xpa, lbuf, &lp)) == NULL ){
+	XPAError(xpa, xpaMessbuf[XPA_RTN_UNCMD]);
+	got = -1;
+	goto done;
+      }
+      /* reserved commands can only be called from the same host as the server,
+	 or from local (unix) sockets */
+      if( (cmd->xpa == rxpa) && 
+	  strcmp(cmd->name, "-help") && strcmp(cmd->name, "-version") ){
+	if( XPAMtype() == XPA_INET ){
+	  if( (!xpa->comm || !LOCALIP(xpa->comm->cmdip)) ){
+	    FPRINTF((stderr, "%sXPAReceiveCommands: rejecting reserved: %s\n",
+		    _sp, cmd->name));
+	    XPAError(xpa, xpaMessbuf[XPA_RTN_NOAUTH]);
+	    got = -1;
+	    goto done;
+	  }
+	}
+      }
+      FPRINTF((stderr, "%sXPAReceiveCommands: cmd->name: %s\n",
+	       _sp, cmd->name));
+      *tbuf = '\0';
+      if( (lastdelim() != ';') && (lastdelim() != '\n') ){
+	/* skip white space between command and params */
+	while( isspace((int)lbuf[lp]) )
+	  lp++;
+	/* here is where the params start */
+	savelp = lp;
+	/* look for command delimiter -- the end of the params */
+	while( word(lbuf, tbuf1, &lp) ){
+	  if( (lastdelim() == ';')  || (lastdelim() == '\n') ){
+	    break;
+	  }
+	  /* make sure a command-ending delim is not next */
+	  while( isspace((int)lbuf[lp]) )
+	    lp++;
+	  if( (lbuf[lp] == ';')  || (lbuf[lp] == '\n') ){
+	    break;
+	  }
+	}
+	/* get length of parameter list */
+	plen = lp - savelp;
+	/* but skip final delim */
+	if( (plen>0) && ((lastdelim() == ';')||(lastdelim() == '\n')) )
+	  plen--;
+	/* copy the params up to the command delimiter */
+	if( plen > 0 ){
+	  strncpy(tbuf, &(lbuf[savelp]), plen);
+	  tbuf[plen] = '\0';
+	}
+      }
+      /* execute the associated XPA callback */
+      if( cmd->receive_callback != NULL ){
+	/* get buf now, if its needed */
+	if( !gotbuf && (xpa_datafd(xpa) >= 0) &&
+	    (cmd->receive_mode & XPA_MODE_FILLBUF) ){
+	  /* read buf -- this buf will stay around for all commands */
+	  FPRINTF((stderr, "%sXPAReceiveCommands: at XPAGetBuf\n", _sp));
+	  bgot = XPAGetBuf(xpa, xpa_datafd(xpa), &buf, &len, -1);
+	  /* close the data channel */
+	  XPACloseData(xpa, xpa->comm);
+	  if( bgot >= 0 ){
+	    /* got the buffer */
+	    gotbuf++;
+	  }
+	  /* error getting buf */
+	  else{
+	    XPAError(xpa, xpaMessbuf[XPA_RTN_NODATA]);
+	    got = -1;
+	    goto done;
+	  }
+	}
+	got = (cmd->receive_callback)(cmd->receive_data, call_data,
+				      tbuf, buf, len);
+	/* if we don't want to free the buffer, mark it for saving */
+	if( (buf != NULL) && !(cmd->receive_mode & XPA_MODE_FREEBUF) ){
+	  freebuf=0;
+	}
+	if( got != 0 ){
+	  goto done;
+	}
+      }
+      else{
+	XPAError(xpa, xpaMessbuf[XPA_RTN_NOREC]);
+	got = -1;
+	goto done;
+      }
+    }
+    /* conditions for exiting the command loop: */
+    /* if we processed the END command, we are done */
+    if( xpa->comm->status & XPA_STATUS_ENDBUF )
+      break;
+    /* if we are not reading the data buffer, we are done */
+    if( !(xpa->comm->status & XPA_STATUS_READBUF) )
+      break;
+    /* if we got EOF or error reading the data buffer, we are done */
+    if( XPAGets(xpa, xpa_datafd(xpa), lbuf, SZ_LINE, XPALongTimeout()) <=0 )
+      break;
+  }
+
+done:
+  /* if no one wants buf, free it now */
+  if( freebuf )
+    xfree(buf);
+  /* restore last delimiter table */
+  freedtable();
+  /* return error code */
+  return(got);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPASendCommands
+ *
+ * Purpose:	process a list of commands from xpaget
+ *
+ * Results:	number of commands processed (currently 0 or 1)
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+int 
+XPASendCommands (void *client_data, void *call_data, char *paramlist,
+		 char **buf, size_t *len)
+#else
+int XPASendCommands(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char **buf;
+     size_t *len;
+#endif
+{
+  XPA xpa = (XPA)call_data;
+  XPACmd cmd;
+  char tbuf[SZ_LINE];
+  int lp=0;
+  int got=0;
+
+  /* return help as default */
+  if( *paramlist == '\0' ){
+    paramlist = "-help";
+  }
+
+  /* lookup the command and execute */
+  if( (cmd = XPACmdLookup(xpa, paramlist, &lp)) != NULL ){
+    /* reserved commands can only be called from the same host as the server,
+       or from local (unix) sockets */
+    if( (cmd->xpa == rxpa) && 
+	strcmp(cmd->name, "-help") && strcmp(cmd->name, "-version") ){
+	if( XPAMtype() == XPA_INET ){
+	  if( (!xpa->comm || !LOCALIP(xpa->comm->cmdip)) ){
+	    FPRINTF((stderr, "%sXPAReceiveCommands: rejecting reserved: %s\n",
+		    _sp, cmd->name));
+	    XPAError(xpa, xpaMessbuf[XPA_RTN_NOAUTH]);
+	    got = -1;
+	    goto done;
+	  }
+	}
+    }
+    /* execute the associated XPA send callback,
+       using the remaining command string as an argument */
+    strcpy(tbuf, &paramlist[lp]);
+    nocr(tbuf);
+    if( !strcmp(tbuf, "-help") ){
+      if( cmd->help != NULL )
+	snprintf(tbuf, SZ_LINE, "%s\n", cmd->help);
+      else
+	snprintf(tbuf, SZ_LINE, "\n");
+      send(xpa_datafd(xpa), tbuf, strlen(tbuf), 0);
+      got = 0;
+    }
+    else if( cmd->send_callback != NULL ){
+      got = (cmd->send_callback)(cmd->send_data, call_data,
+				 &paramlist[lp], buf, len);
+    }
+    else{
+      XPAError(xpa, xpaMessbuf[XPA_RTN_NOSEND]);
+      got = -1;
+      goto done;
+    }
+  }
+  else{
+    XPAError(xpa, xpaMessbuf[XPA_RTN_UNCMD]);
+    got = -1;
+    goto done;
+  }
+
+done:
+  /* return error code */
+  return(got);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ *
+ * 			Public Routines and Data
+ *
+ *
+ *----------------------------------------------------------------------------
+ */
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPACmdNew
+ *
+ * Purpose:	define a named command access point 
+ *
+ * Results:	XPA struct or NULL
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+XPA 
+XPACmdNew (char *xclass, char *name)
+#else
+XPA XPACmdNew(xclass, name)
+     char *xclass;
+     char *name;
+#endif
+{
+  XPA xpa;
+  char tbuf[SZ_LINE];
+
+  /* we need a name */
+  if( (name == NULL) || (*name == '\0') )
+    return(NULL);
+
+  /* we need some valid class */
+  if( (xclass == NULL) || (*xclass == '\0') )
+    xclass = "*";
+
+  /* help string */
+  snprintf(tbuf, SZ_LINE, "XPA commands for %s:%s\n\t\t  options: see -help",
+	  xclass, name);
+
+  /* create a new XPA with command callbacks */
+  xpa = XPANew(xclass, name, tbuf,
+	       XPASendCommands, NULL, NULL,
+	       XPAReceiveCommands, NULL, "fillbuf=false");
+
+  /* return the good news */
+  return(xpa);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPACmdAdd
+ *
+ * Purpose:	add a command to a named command access point 
+ *
+ * Results:	0 on success, -1 for failure
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+XPACmd 
+XPACmdAdd (XPA xpa, char *name, char *help,
+	   SendCb send_callback, void *send_data, char *send_mode,
+	   ReceiveCb rec_callback, void *rec_data, char *rec_mode)
+#else
+XPACmd XPACmdAdd(xpa, name, help,
+		 send_callback, send_data, send_mode,
+		 rec_callback, rec_data, rec_mode)
+     XPA xpa;
+     char *name;
+     char *help;
+     SendCb send_callback;
+     void *send_data;
+     char *send_mode;
+     ReceiveCb rec_callback;
+     void *rec_data;
+     char *rec_mode;
+#endif
+{
+  XPACmd xnew;
+  XPACmd cur;
+  XPACmd prev;
+
+  /* make sure we have a valid command record */
+  if( !xpa || 
+      (xpa->send_callback != XPASendCommands)       || 
+      (xpa->receive_callback != XPAReceiveCommands) ){
+    return(NULL);
+  }
+
+  /* we need either a send or a receive or both */
+  if( (send_callback == NULL) && (rec_callback == NULL ) ){
+    return(NULL);
+  }
+
+  /* limit the size of the cmd name designation */
+  if( strlen(name) > XPA_NAMELEN ){
+    return(NULL);
+  }
+
+  /* allocate space for a new record */
+  xnew = (XPACmd)xcalloc(1, sizeof(struct xpacmdrec));
+
+  /* backlink to xpa */
+  xnew->xpa = xpa;
+
+  /* fill in the blanks */
+  xnew->name = XPACmdParseNames(name, &(xnew->ntokens));
+  xnew->help = xstrdup(help);
+
+  /* receive callback */
+  xnew->send_callback = send_callback;
+  xnew->send_data = send_data;
+  xnew->send_mode = XPA_DEF_MODE_SEND;
+  XPAMode(send_mode, &(xnew->send_mode), "freebuf", XPA_MODE_FREEBUF,1);
+  /* acl is a global mode */
+  XPAMode(send_mode, &(xpa->send_mode), "acl", XPA_MODE_ACL, 1);
+
+  /* receive callback */
+  xnew->receive_callback = rec_callback;
+  xnew->receive_data = rec_data;
+  /* process the mode string */
+  xnew->receive_mode = XPA_DEF_MODE_REC;
+  XPAMode(rec_mode, &(xnew->receive_mode), "usebuf", XPA_MODE_BUF,1);
+  XPAMode(rec_mode, &(xnew->receive_mode), "fillbuf", XPA_MODE_FILLBUF,1);
+  XPAMode(rec_mode, &(xnew->receive_mode), "freebuf", XPA_MODE_FREEBUF,1);
+  /* acl is a global mode */
+  XPAMode(rec_mode, &(xpa->receive_mode), "acl", XPA_MODE_ACL, 1);
+
+  /* enter into list, in alphabetical order */
+  if( xpa->commands == NULL  ){
+    xpa->commands = xnew;
+    return(xnew);
+  }
+  else{
+    for(prev=NULL, cur=xpa->commands; cur!=NULL; prev=cur, cur=cur->next){
+      /* if new name is an existing name, add it before */
+      if( strcmp(xnew->name,   cur->name) ==0 )
+	goto addname;
+      /* if existing name is a subset of new name, add it before */
+      else if( !strncmp(xnew->name, cur->name, strlen(cur->name)) )
+	goto addname;
+      /* if new name is a subset of existing name, add it after */
+      else if( !strncmp(xnew->name, cur->name, strlen(xnew->name)) )
+	continue;
+      /* if new name is lexically greater than existing name, add it after */
+      else if( strcmp(xnew->name,   cur->name) >0 )
+	continue;
+addname:
+      /* add the new name here and return */
+      if( prev == NULL ){
+	xpa->commands = xnew;
+	xnew->next = cur;
+	return(xnew);
+      }
+      else{
+	prev->next = xnew;
+	xnew->next = cur;
+	return(xnew);
+      }
+    }
+    /* if we are still here, we did not find a place to insert, i.e.,
+       we are at the end of the list */
+    prev->next = xnew;
+    return(xnew);
+  }
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPACmdDel
+ *
+ * Purpose:	free a named command access point 
+ *
+ * Results:	none
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+int
+XPACmdDel (XPA xpa, XPACmd cmd)
+#else
+int XPACmdDel(xpa, cmd)
+     XPA xpa;
+     XPACmd cmd;
+#endif
+{
+  XPACmd cur;
+  int got=0;
+
+  /* gotta have something to free */
+  if( cmd == NULL )
+    return(-1);
+
+  /* remove from list of xpa's commands */
+  if( xpa && xpa->commands ){
+    if( xpa->commands == cmd ){
+      xpa->commands = cmd->next;
+      got++;
+    }
+    else{
+      for(cur=xpa->commands; cur!=NULL; cur=cur->next){
+	if( cur->next == cmd ){
+	  cur->next = cmd->next;
+	  got++;
+	  break;
+	}
+      }
+    }
+  }
+
+  /* free up space */
+  if( got ){
+    if( cmd->name )
+      xfree(cmd->name);
+    if( cmd->help )
+      xfree(cmd->help);
+    xfree(cmd);
+    return(0);
+  }
+  else{
+    return(-1);
+  }
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPACmdInternalReceive
+ *
+ * Purpose:	internal execute of the receive callback for this command
+ *
+ * Results:	number of commands processed
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+int 
+XPACmdInternalReceive (void *client_data, void *call_data,
+		       char *paramlist, char *buf, size_t len)
+#else
+int XPACmdInternalReceive(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char *buf;
+     size_t len;
+#endif
+{
+  XPA xpa = (XPA)call_data;
+
+  /* make sure we have something */
+  if( xpa == NULL )
+    return(-1);
+  /* make the call */
+  return(XPAReceiveCommands(client_data, xpa, paramlist, buf, len));
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPACmdInternalSend
+ *
+ * Purpose:	internal execute of the send callback for this command
+ *
+ * Results:	number of commands processed (currently 0 or 1)
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+int 
+XPACmdInternalSend (void *client_data, void *call_data,
+		    char *paramlist, char **buf, size_t *len)
+#else
+int XPACmdInternalSend(client_data, call_data, paramlist, buf, len)
+     void *client_data;
+     void *call_data;
+     char *paramlist;
+     char **buf;
+     size_t *len;
+#endif
+{
+  XPA xpa = (XPA)call_data;
+
+  /* make sure we have something */
+  if( xpa == NULL )
+    return(-1);
+
+  /* make the call */
+  return(XPASendCommands(client_data, xpa, paramlist, buf, len));
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * Routine:	XPAGetReserved
+ *
+ * Purpose:	return xpa handle for reserved xpa commands
+ *
+ * Return:	xpa handle
+ *
+ *----------------------------------------------------------------------------
+ */
+#ifdef ANSI_FUNC
+XPA 
+XPAGetReserved (void)
+#else
+XPA XPAGetReserved()
+#endif
+{
+  return(rxpa);
+}