diff options
Diffstat (limited to 'xpa/client.c')
| -rw-r--r-- | xpa/client.c | 3057 |
1 files changed, 3057 insertions, 0 deletions
diff --git a/xpa/client.c b/xpa/client.c new file mode 100644 index 0000000..f70ff40 --- /dev/null +++ b/xpa/client.c @@ -0,0 +1,3057 @@ +/* + * Copyright (c) 1999-2003 Smithsonian Astrophysical Observatory + */ + +#include <xpap.h> + +/* + *---------------------------------------------------------------------------- + * + * + * Private Routines and Data + * + * + *---------------------------------------------------------------------------- + */ + +/* this is the head of the global list of client xpas */ +static XPA xpaclienthead=NULL; + +static char errbuf[SZ_LINE]; /* holds current error message */ +static int id=0; /* id of current command */ + +#define DATA_CONNECT 1 +#define DATA_ACCEPT 2 +#define DATA_DATA 4 + +/* use of a double fork() call is used to prevent zombies which happen + if fork is a child of xpans started by an XPA server (i.e., for some + reason, the SIGCHLD signal does not get sent to xpans parent) + See Stevens, Advanced Programming in te Unix Environment, p. 202 */ +#define USE_DOUBLE_FORK 1 +#ifndef USE_DOUBLE_FORK +#ifdef ANSI_FUNC +void sig_chld(int signo) +#else +#endif +{ + int stat; + + while(waitpid(-1, &stat, WNOHANG) > 0){ + ; + } + return; +} +#endif + +/* + *---------------------------------------------------------------------------- + * + * Routine: rdl + * + * Purpose: read characters up a new-line + * + * Returns: number of characters read + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static int +rdl (int fd, char *buf, size_t len) +#else +static int rdl(fd, buf, len) + int fd; + char *buf; + int len; +#endif +{ + int i=0; + int got; + + /* start out clean */ + *buf = '\0'; + + /* make sure we have a valid channel */ + if( fd < 0 ) + return(-1); + + /* grab characters up to a new-line or max len */ + while( i < (len-1) ){ + got = read(fd, &(buf[i]), 1); + if( got < 1 ) + break; + else if( buf[i++] == '\n' ) + break; + } + buf[i] = '\0'; + return(i); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAProxyAccept + * + * Purpose: accept a connection from an XPA proxy server + * + * Return: fd of accepted connection or -1 + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static +int XPAProxyAccept(XPA xpa, char *method, char *xclass, char *name, int ifd, + unsigned int *rip, unsigned short *rport, char *rname) +#else +static +int XPAProxyAccept(xpa, method, xclass, name, ifd, rip, rport, rname) + XPA xpa; + char *method; + char *xclass; + char *name; + int ifd; + unsigned int *rip; + unsigned short *rport; + char *rname; +#endif +{ + int sock; + int got; + int oum; + int ofd; + int niter; + int swidth=FD_SETSIZE; + int keep_alive=1; + int reuse_addr=1; + unsigned int ip; + unsigned short port; + char tbuf[SZ_LINE]; + char amethod[SZ_LINE]; + char *tptr; + socklen_t slen; + struct sockaddr_in sock_in; +#if HAVE_SYS_UN_H + struct sockaddr_un sock_un; +#endif + struct timeval tv; + struct timeval *tvp; + fd_set readfds; + + /* initialize results */ + if( rip ) *rip = 0; + if( rport ) *rport = 0; + if( rname ) *rname = '\0'; + + switch(XPAMethod(method)){ + case XPA_INET: + if( !XPAParseIpPort(method, &ip, &port) ){ + goto error; + } + /* open a socket for data connections */ + if( (sock = xsocket(AF_INET, SOCK_STREAM, 0)) < 0 ){ + PERROR(("xpaaccept socket")); + goto error; + } + setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, + (char *)&keep_alive, sizeof(keep_alive)); + setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + (char *)&reuse_addr, sizeof(reuse_addr)); + memset((char *)&sock_in, 0, sizeof(sock_in)); + sock_in.sin_family = AF_INET; + sock_in.sin_addr.s_addr = htonl(INADDR_ANY); + sock_in.sin_port = htons(port); + /* bind to the ip:port */ + if( xbind(sock, (struct sockaddr *)&sock_in, sizeof(sock_in)) < 0 ){ + PERROR(("xpaaccept bind")); + xclose(sock); + goto error; + } + snprintf(amethod, SZ_LINE, "%x:%d", ip, port); + break; +#if HAVE_SYS_UN_H + case XPA_UNIX: + ip = 0; + port = 0; + /* get filename part, composed of class and name and unique id */ + snprintf(tbuf, SZ_LINE, "%s_%s.%d", xclass, name, (int)time(NULL)); + /* change "/" to "_" for filename */ + for(tptr = tbuf; *tptr != '\0'; tptr++){ + if( *tptr == '/' ) *tptr = '_'; + } + /* create full pathname */ + snprintf(amethod, SZ_LINE, "%s/%s", XPATmpdir(), tbuf); + /* delete old copy */ + unlink (amethod); + /* open a socket and fill in socket information */ + if( (sock = xsocket(AF_UNIX, SOCK_STREAM, 0)) < 0 ){ + goto error; + } + setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, + (char *)&keep_alive, sizeof(keep_alive)); + memset((char *)&sock_un, 0, sizeof(sock_un)); + sock_un.sun_family = AF_UNIX; + strcpy(sock_un.sun_path, amethod); + /* unset umask so that everyone can read and write */ + oum = umask(0); + /* bind to the file */ + got = xbind(sock, (struct sockaddr *)&sock_un, sizeof(sock_un)); + /* reset umask to previous */ + umask(oum); + /* now check for bind error */ + if( got < 0 ){ + xclose(sock); + goto error; + } + break; +#endif + default: + goto error; + } + + /* send port to client so they can connect */ + /* first listen for the connection */ + if( listen(sock, XPA_MAXLISTEN) < 0 ){ + PERROR(("xpaaccept listen")); + xclose(sock); + goto error; + } + + /* and tell the client that we are listening */ + snprintf(tbuf, SZ_LINE, "xpaaccept %s (%s:%s %s)\n", + amethod, xclass, name, method); + FPRINTF((stderr, "%sXPAProxyAccept: sending command to %d:\n%s", + _sp, ifd, tbuf)); + if( XPAPuts(NULL, ifd, tbuf, XPAShortTimeout()) <= 0 ){ + PERROR(("client xpaaccept write")); + xclose(sock); + goto error; + } + + /* we will iterate on xselect */ + if( XPAShortTimeout() > 0 ) + niter = XPAShortTimeout()*100; + else + niter = XPA_SHORT_TIMEOUT*100; +again: + /* this has to be able to time out */ + tv.tv_sec = 0; + tv.tv_usec = 10000; + tvp = &tv; + /* wait for this socket and XPA sockets */ + FD_ZERO(&readfds); + FD_SET(sock, &readfds); + XPAAddSelect(NULL, &readfds); + /* wait for the connection */ + got = xselect(swidth, &readfds, NULL, NULL, tvp); + /* process results of select */ + if( got > 0 ){ + if( !FD_ISSET(sock, &readfds)){ + XPAProcessSelect(&readfds, 0); + goto again; + } + switch(XPAMethod(method)){ + case XPA_INET: + while( 1 ){ + slen = sizeof(struct sockaddr_in); + if((ofd=xaccept(sock, (struct sockaddr *)&sock_in, &slen)) >= 0){ + break; + } + else{ + if( xerrno == EINTR ) + continue; + else{ + PERROR(("xpaaccept acccept")); + xclose(sock); + goto error; + } + } + } + break; +#if HAVE_SYS_UN_H + case XPA_UNIX: + while( 1 ){ + slen = sizeof(struct sockaddr_un); + if((ofd=xaccept(sock, (struct sockaddr *)&sock_un, &slen)) >= 0){ + break; + } + else{ + if( xerrno == EINTR ) + continue; + else{ + PERROR(("xpaaccept acccept")); + xclose(sock); + goto error; + } + } + } + break; +#endif + default: + xclose(sock); + goto error; + } + } + /* timeout? */ + else if( got == 0 ){ + if( --niter > 0 ){ + goto again; + } + else{ + xclose(sock); + FPRINTF((stderr, "%sXPAProxyAccept: select timed out\n", _sp)); + goto error; + } + } + /* error */ + else{ + if( xerrno == EINTR ){ + PERROR(("xpaaccept select")); + goto again; + } + else{ + xclose(sock); + goto error; + } + } + /* done with listening */ + xclose(sock); + + /* fill in return information */ + if( rip ) *rip = ip; + if( rport ) *rport = port; + if( rname ){ + strncpy(rname, amethod, SZ_LINE-1); + rname[SZ_LINE-1] = '\0'; + } + return(ofd); + +error: + return(-1); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientNewInput + * + * Purpose: allocate a new input struct for reading data from stdin + * + * Return: input struct, or NULL on error + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static XPAInput +XPAClientNewInput(XPA xpa) +#else +static XPAInput XPAClientNewInput(xpa) + XPA xpa; +#endif +{ + XPAInput xnew, inp; + + /* allocate a new record */ + if( (xnew=(XPAInput)xcalloc(1, sizeof(XPAInputRec))) == NULL ){ + return(NULL); + } + /* allocate the data buffer */ + xnew->buf = (char *)xmalloc(XPA_BIOSIZE); + /* this buffer starts (and currently ends) at the current byte count */ + xnew->start = xpa->inpbytes; + xnew->end = xpa->inpbytes; + xnew->bytes = 0; + + /* add this input to end of list of input's */ + if( xpa->inphead == NULL ){ + xpa->inphead = xnew; + } + else{ + for(inp=xpa->inphead; inp->next!=NULL; inp=inp->next) + ; + inp->next = xnew; + } + + /* return the record struct */ + return(xnew); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientFreeInput + * + * Purpose: free a input buffer once its been sent to all targets + * + * Return: 0 on success, -1 on failure + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static void +XPAClientFreeInput (XPA xpa, XPAInput inp) +#else +static void XPAClientFreeInput(xpa, inp) + XPA xpa; + XPAInput inp; +#endif +{ + XPAInput cur; + + if( !xpa || !inp ) + return; + + if( inp == xpa->inphead ){ + xpa->inphead = inp->next; + } + else{ + for(cur=xpa->inphead; cur!=NULL; cur=cur->next){ + if( cur->next == inp ){ + cur->next = inp->next; + break; + } + } + } + + /* free current record */ + if( inp != NULL ){ + if( inp->buf != NULL ) + xfree(inp->buf ); + xfree(inp); + } +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientFreeAllInputs + * + * Purpose: free remaining input buffers + * + * Return: 0 on success, -1 on failure + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static void +XPAClientFreeAllInputs (XPA xpa) +#else +static void XPAClientFreeAllInputs(xpa) + XPA xpa; +#endif +{ + XPAInput cur, tmp; + + if( !xpa ) + return; + + for(cur=xpa->inphead; cur!=NULL; ){ + tmp = cur->next; + XPAClientFreeInput(xpa, cur); + cur = tmp; + } + xpa->inpbytes = 0; +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientProcessInput + * + * Purpose: read input from stdin and store in an input struct + * + * Return: bytes read + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static int +XPAClientProcessInput(XPA xpa) +#else +static int XPAClientProcessInput(xpa) + XPA xpa; +#endif +{ + static XPAInput cur=NULL; + int get, got; + + /* set up next buffer, if necessary */ + for(cur=xpa->inphead; cur!=NULL; cur=cur->next){ + if( cur->bytes < XPA_BIOSIZE ) + break; + } + if( cur == NULL ){ + cur = XPAClientNewInput(xpa); + } + + /* read data from stdin */ + get = MIN(XPA_IOSIZE, XPA_BIOSIZE - cur->bytes); + if( isatty(xpa->ifd) ){ + got = rdl(xpa->ifd, &(cur->buf[cur->bytes]), get); + } + else{ + got = read(xpa->ifd, &(cur->buf[cur->bytes]), get); + } + switch(got){ + case -1: + if( XPAVerbosity() ){ + PERROR(("XPA client read")); + } + return(0); + case 0: + xpa->ifd = -1; + FPRINTF((stderr, "%sXPAClientProcessInput: signalling EOF\n", _sp)); + break; + default: + break; + } + cur->bytes += got; + cur->end += got; + xpa->inpbytes += got; +#ifdef FIXEDBYCYGWIN +#if HAVE_CYGWIN + /* on non-NT Windows machines, Cygwin select() does not work once a pipe + gets EOF. It should show the fd ready for reading (and read 0 bytes), + but does not, so we have to hack a manual check */ + /* GetVersion is a Windows call */ + if( GetVersion() >= 0x80000000L ){ + if( got < get ){ + xpa->ifd = -1; + } + } +#endif +#endif + + /* verify to stdout, if necessary */ + if( xpa->client_mode & XPA_CLIENT_VERIFY ){ + fwrite(&(cur->buf[cur->bytes-got]), sizeof(char), got, stdout); + } + + /* return the number of bytes just read */ + return(got); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientFree + * + * Purpose: free a client record and remove from list + * + * Returns: none + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static void +XPAClientFree (XPA xpa, XPAClient client) +#else +static void XPAClientFree(xpa, client) + XPA xpa; + XPAClient client; +#endif +{ + XPAClient cur; + + /* remove from list of xpa's */ + if( xpa->clienthead ){ + if( xpa->clienthead == client ){ + xpa->clienthead = client->next; + } + else{ + for(cur=xpa->clienthead; cur!=NULL; cur=cur->next){ + if( cur->next == client ){ + cur->next = client->next; + break; + } + } + } + } + + if( client->cmdfd >= 0 ){ +#if HAVE_CYGWIN + shutdown(client->cmdfd, SHUT_RDWR); +#endif + xclose(client->cmdfd); + } + if( client->datafd >= 0 ){ +#if HAVE_CYGWIN + shutdown(client->datafd, SHUT_RDWR); +#endif + xclose(client->datafd); + } + if( client->dataname ){ + unlink(client->dataname); + xfree(client->dataname); + } + if( client->method ) + xfree(client->method); + if( client->info ) + xfree(client->info); + if( client->xtemplate ) + xfree(client->xtemplate); + if( client->xclass ) + xfree(client->xclass); + if( client->name ) + xfree(client->name); + if( client->id ) + xfree(client->id); + /* xpaget's fd mode has an alloc'ed bufptr and lenptr */ + if( (client->type == 'g') && (client->mode & XPA_CLIENT_FD) ){ + if( client->bufptr && *(client->bufptr) ) + xfree(*(client->bufptr)); + if( client->bufptr ) + xfree(client->bufptr); + if( client->lenptr ) + xfree(client->lenptr); + } + xfree(client); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientDataSent + * + * Purpose: data is sent, so close data channel and change status to + * signal that we are waiting for the server + * + * Returns: none + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static void +XPAClientDataSent (XPA xpa, XPAClient client) +#else +static void XPAClientDataSent(xpa, client) + XPA xpa; + XPAClient client; +#endif +{ + FPRINTF((stderr, "%sXPAClientDataSent: for cmd %d data %d\n", _sp, + client->cmdfd, client->datafd)); + /* close the data channel, which should trigger a result from the server */ + if( client->datafd >= 0 ){ +#if HAVE_CYGWIN + shutdown(client->datafd, SHUT_RDWR); +#endif + xclose(client->datafd); + client->datafd = -1; + } + /* we are now waiting for the server to complete the calllback */ + client->status = XPA_CLIENT_WAITING; +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientEnd + * + * Purpose: finish up with this client + * + * Returns: error message or null + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static char * +XPAClientEnd (XPA xpa, XPAClient client) +#else +static char *XPAClientEnd(xpa, client) + XPA xpa; + XPAClient client; +#endif +{ + char *error=NULL; + char *eptr; + + FPRINTF((stderr, "%sXPAClientEnd: for cmd %d data %d\n", _sp, + client->cmdfd, client->datafd)); + /* always read the status line -- if we are not ack'ing, we'll get an + OK from the server before the calllback and we can exit quickly */ + /* don't do this if client is xpainfo and we're not ack'ing */ + if( !((client->type == 'i') && !(client->mode & XPA_CLIENT_ACK)) ){ +retry: + if( XPAGets(NULL, client->cmdfd, errbuf, SZ_LINE, XPALongTimeout()) >0 ){ + FPRINTF((stderr, "%sXPAClientEnd: read %s\n", _sp, errbuf)); + eptr = errbuf; + /* this should never happen */ + if( *eptr == '?' ){ + snprintf(errbuf, SZ_LINE, + "XPA$WARNING: protocol mismatch - missing id\n%s", eptr); + error = NULL; + } + else{ + /* make sure we are dealing with a proper message */ + if( strncmp(eptr, client->id, strlen(client->id)) ){ + if( XPAVerbosity() > 1 ){ + fprintf(stderr, + "XPA$WARNING: ignoring out of sync server message:\n"); + fprintf(stderr, "%s", errbuf); + } + goto retry; + } + /* go past id */ + eptr += strlen(client->id); + while( isspace((int)*eptr) ) eptr++; + if( !strncmp(eptr, "XPA$OK", 6) ){ + error = NULL; + } + else{ + error = eptr; + } + } + } + else{ + if( XPAVerbosity() > 1 ){ + fprintf(stderr, + "XPA$WARNING: no reply from server callback (assuming OK)\n"); + } + error = NULL; + } + } + else + error = NULL; + + /* store the error return */ + if( client->errptr ) + *(client->errptr) = xstrdup(error); + + /* remove this client if we are not meant to persist */ + if( !xpa->persist ){ + XPAClientFree(xpa, client); + } + /* otherwise mark as inactive */ + else{ + client->status = XPA_CLIENT_IDLE; + client->bytes = 0; + } + + /* return error status */ + return(error); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientNew + * + * Purpose: allocate a new xpa client + * + * Returns: xpa client struct + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static XPAClient +XPAClientNew (XPA xpa, char *mode, char *xtemplate, int type, + char *xclass, char *name, char *method, char *info) +#else +static XPAClient XPAClientNew(xpa, mode, xtemplate, type, + xclass, name, method, info) + XPA xpa; + char *mode; + char *xtemplate; + int type; + char *xclass; + char *name; + char *method; + char *info; +#endif +{ + XPAClient xnew, client; + struct sockaddr_in sock_in; +#if HAVE_SYS_UN_H + struct sockaddr_un sock_un; +#endif + char xmode[SZ_LINE]; + char tbuf[SZ_LINE]; + char amethod[SZ_LINE]; + char *s=NULL; + unsigned short port; + unsigned int ip=0; + int fd; + int pfd; + int tries=0; + int nsproxy=0; + int keep_alive=1; + + FPRINTF((stderr, "%sXPAClientNew: entering with %s %s %s %s\n", _sp, + xclass, name, method, info)); + + /* no errors as yet */ + *errbuf = '\0'; + + /* look for reuse of xpans fd (used in conjunction with the xpans proxy) */ + *xmode = '\0'; + if( mode ){ + strncpy(xmode, mode, SZ_LINE-1); + xmode[SZ_LINE-1] = '\0'; + } + if( keyword(xmode, "nsproxy", tbuf, SZ_LINE) ){ + nsproxy = 1; + pfd = strtol(tbuf, &s, 0); + fd = XPAProxyAccept(xpa, XPANSMethod(NULL,2), + xclass, name, pfd, &ip, &port, amethod); + /* make sure we got a valid int fd */ + if( fd < 0 ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server on proxyaccept (%s:%s%s)\n", + xclass, name, XPATimestamp()); + FPRINTF((stderr, "%sXPAClientNew: %s", _sp, errbuf)); + PERROR(("XPAClientNew")); + return(NULL); + } + } + /* normal usage: connect to server */ + else{ + switch(XPAMethod(method)){ + case XPA_INET: +again1: + if( !XPAParseIpPort(method, &ip, &port) ) + return(NULL); + /* use $localhost over $host (we do not trust host to be correct) */ + if( (ip == gethostip("$host")) && (tries == 0) ) + ip = gethostip("$localhost"); + /* connect to the server before we go further */ + if( (fd = xsocket(AF_INET, SOCK_STREAM, 0)) < 0 ){ + return(NULL); + } + setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, + (char *)&keep_alive, sizeof(keep_alive)); + memset((char *)&sock_in, 0, sizeof(sock_in)); + sock_in.sin_family = AF_INET; + sock_in.sin_addr.s_addr = htonl(ip); + sock_in.sin_port = htons(port); + /* make the connection with the server */ + if( connect(fd, (struct sockaddr *)&sock_in, sizeof(sock_in)) <0 ){ + xclose(fd); + /* if localhost doesn't work, make one try with the host ip */ + /* we also try again just in case there was an odd error such + as "permission denied", which we have seen once or twice */ + if( tries < 2 ){ + tries++; + goto again1; + } + /* give up */ + else{ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server on connect (%s:%s%s)\n", + xclass, name, XPATimestamp()); + PERROR(("XPAClientNew")); + return(NULL); + } + } + /* make sure we close on exec */ + xfcntl(fd, F_SETFD, FD_CLOEXEC); + FPRINTF((stderr, "%sXPAClientNew: inet connect returns fd %d\n", + _sp, fd)); + break; +#if HAVE_SYS_UN_H + case XPA_UNIX: +again2: + /* open a socket and fill in socket information */ + if( (fd = xsocket(AF_UNIX, SOCK_STREAM, 0)) < 0 ){ + return(NULL); + } + setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, + (char *)&keep_alive, sizeof(keep_alive)); + memset((char *)&sock_un, 0, sizeof(sock_un)); + sock_un.sun_family = AF_UNIX; + strcpy(sock_un.sun_path, method); + /* make the connection with the server */ + if( connect(fd, (struct sockaddr *)&sock_un, sizeof(sock_un)) <0 ){ + xclose(fd); + /* Unix sockets get ECONNREFUSED when the listen queue is full, + so we try a few times to give the server a chance to recover */ + if( (xerrno == ECONNREFUSED) && (tries < XPA_RETRIES) ){ + tries++; + XPASleep(10); + goto again2; + } + /* give up */ + else{ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server on connect (%s:%s%s)\n", + xclass, name, XPATimestamp()); + PERROR(("XPAClientNew")); + return(NULL); + } + } + /* make sure we close on exec */ + xfcntl(fd, F_SETFD, FD_CLOEXEC); + FPRINTF((stderr, "%sXPAClientNew: unix connect returns fd %d\n", + _sp, fd)); + break; +#endif + default: + return(NULL); + } + strncpy(amethod, method, SZ_LINE-1); + amethod[SZ_LINE-1] = '\0'; + } + + /* allocate new send record */ + if( (xnew=(XPAClient)xcalloc(1, sizeof(XPAClientRec))) == NULL ){ + xclose(fd); + return(NULL); + } + + /* fill in the blanks */ + xnew->xtemplate = xstrdup(xtemplate); + xnew->type = type; + xnew->cmdfd = fd; + xnew->datafd = -1; + xnew->xclass = xstrdup(xclass); + xnew->name = xstrdup(name); + xnew->method = xstrdup(amethod); + xnew->info = xstrdup(info); + xnew->ip = ip; + xnew->nsproxy = nsproxy; + xnew->status = XPA_CLIENT_ACTIVE; + + /* now that we have a valid client, add to list */ + if( xpa->clienthead == NULL ){ + xpa->clienthead = xnew; + } + else{ + for(client=xpa->clienthead; client->next!=NULL; client=client->next) + ; + client->next = xnew; + } + FPRINTF((stderr, "%sXPAClientNew: new fd %d\n", _sp, xnew->cmdfd)); + /* return the good news */ + return(xnew); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientAddSelect + * + * Purpose: add one or more xpa client sockets to the select flags + * + * Return: number of clients that were added to the select flags + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +int +XPAClientAddSelect (XPA xpa, fd_set *readfdsptr, fd_set *writefdsptr) +#else +int XPAClientAddSelect(xpa, readfdsptr, writefdsptr) + XPA xpa; + fd_set *readfdsptr; + fd_set *writefdsptr; +#endif +{ + XPAClient client; + int got=0; + int loop=0; + + /* better have some place to set the flags */ + if( readfdsptr == NULL ) + return(0); + + /* if no xpa is specified, do them all */ + if( xpa == NULL ){ + if( xpaclienthead == NULL ) return(0); + xpa = xpaclienthead; + loop = 1; + } + +loop: + /* set select flags for all clients */ + for(client=xpa->clienthead; client!=NULL; client=client->next){ + /* if this client is processing */ + if( (client->status == XPA_CLIENT_PROCESSING) && (client->datafd >= 0) ){ + if( client->type == 'g' ){ + FPRINTF((stderr, "%sXPAClientAddSelect(get): adding fd %d\n", _sp, + client->datafd)); + FD_SET(client->datafd, readfdsptr); + got++; + } + else if( client->type == 's' ){ + FPRINTF((stderr, "%sXPAClientAddSelect(set): adding fd %d\n", _sp, + client->datafd)); + FD_SET(client->datafd, writefdsptr); + got++; + } + } + /* if this client is waiting */ + else if( (client->status == XPA_CLIENT_WAITING) && (client->cmdfd >= 0) ){ + FPRINTF((stderr, "%sXPAClientAddSelect(waiting): adding fd %d\n", _sp, + client->cmdfd)); + FD_SET(client->cmdfd, readfdsptr); + got++; + } + } + /* loop if necessary */ + if( loop && (xpa=xpa->next) ) goto loop; + /* return the news */ + return(got); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientGet + * + * Purpose: process an xpaget request for a given client + * + * Return: 0 on success, -1 on failure + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static int +XPAClientGet (XPA xpa, XPAClient client) +#else +static int XPAClientGet(xpa, client) + XPA xpa; + XPAClient client; +#endif +{ + int status; + char tbuf[SZ_LINE]; + + /* allocate the first buffer, if necessary */ + if( *(client->bufptr) == NULL ){ + client->bufsize = XPA_IOSIZE; + *(client->bufptr) = (char *)xmalloc(client->bufsize); + *(client->lenptr) = 0; + } + if( (*(client->lenptr) + XPA_IOSIZE) > client->bufsize ){ + client->bufsize += (XPA_IOSIZE*10); + *(client->bufptr) = (char *)xrealloc(*(client->bufptr), client->bufsize); + } + + /* now retrieve the data from the server */ + status = recv(client->datafd, *(client->bufptr) + *(client->lenptr), + XPA_IOSIZE, 0); + /* status < 0 means error */ + switch(status){ + /* error */ + case -1: + /* socket would block */ + if((xerrno == EINPROGRESS) || (xerrno == EWOULDBLOCK)){ + return(0); + } + /* clean up after error */ + if( *(client->bufptr) ){ + xfree(*(client->bufptr)); + *(client->bufptr) = NULL; + client->bufsize = 0; + } + *(client->lenptr) = 0; + XPAClientDataSent(xpa, client); +#ifdef OLD + (void)XPAClientEnd(xpa, client); + /* we need to flag some sort of error, if nothing came across */ + if( *(client->errptr) == NULL ){ + *(client->errptr) = xstrdup( + "XPA$ERROR: incomplete transmission from server\n"); + } +#endif + break; + /* eof */ + case 0: + /* if we have multiple clients, we now need to write this one */ + if( client->mode & XPA_CLIENT_FD ){ + if( xpa->nclient > 1 ){ + snprintf(tbuf, SZ_LINE, "XPA$BEGIN %s:%s %s\n", + client->xclass, client->name, client->method); + write(client->fd, tbuf, strlen(tbuf)); + } + write(client->fd, *(client->bufptr), *(client->lenptr)); + if( xpa->nclient > 1 ){ + snprintf(tbuf, SZ_LINE, "XPA$END %s:%s %s\n", + client->xclass, client->name, client->method); + write(client->fd, tbuf, strlen(tbuf)); + } + /* we can free buf, since its not being passed back */ + if( *(client->bufptr) ){ + xfree(*(client->bufptr)); + *(client->bufptr) = NULL; + client->bufsize = 0; + } + } + else{ + /* set final buffer size and put a convenience null at the end */ + if( *(client->bufptr) ){ + client->bufsize = *(client->lenptr)+1; + *(client->bufptr) = (char *)xrealloc(*(client->bufptr),client->bufsize); + *(*(client->bufptr)+*(client->lenptr)) = '\0'; + } + } + /* for all clients, we need to clean up */ + XPAClientDataSent(xpa, client); +#ifdef OLD + (void)XPAClientEnd(xpa, client); +#endif + break; + /* status > 0: bytes read */ + default: + *(client->lenptr) += status; + /* for single client fd mode, we write immediately -- this deals with + the important case of one client with a large amount of data */ + if( (client->mode & XPA_CLIENT_FD) && (xpa->nclient == 1) ){ + write(client->fd, *(client->bufptr), *(client->lenptr)); + /* reset buf for next read */ + if( *(client->bufptr) ) xfree(*(client->bufptr)); + *(client->bufptr) = NULL; + *(client->lenptr) = 0; + } + break; + } + return(status); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientSet + * + * Purpose: process an xpaset request for a given client + * + * Return: 0 on success, -1 on failure + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static int +XPAClientSet (XPA xpa, XPAClient client) +#else +static int XPAClientSet(xpa, client) + XPA xpa; + XPAClient client; +#endif +{ + int status; + int left; + int got; + int len; + XPAInput inp; + + if( client->mode & XPA_CLIENT_BUF ){ + while( 1 ){ + len = MIN(XPA_IOSIZE, client->len - client->bytes); + /* see if we have written it all */ + if( len == 0 ){ + status = 1; + goto done; + } + /* write the next chunk */ + FPRINTF((stderr, + "%sXPAClientSet: fd %d sending %lu bytes (%lu - %lu)\n", _sp, + client->datafd, (unsigned long)len, + (unsigned long)client->len, (unsigned long)client->bytes)); + got=send(client->datafd, &(client->buf[client->bytes]), len, 0); + if( got >= 0 ){ + client->bytes += got; + if( XPALevelGet() >0 ) + return(got); + } + else{ + PERROR(("XPAClientSet")); + /* check for error */ + if( (xerrno != EWOULDBLOCK) && (xerrno != EAGAIN) ){ + status = -1; + goto done; + } + /* write would block, so we return and wait the server */ + else{ + return(0); + } + } + } + } + /* reading from stdin and writing to servers */ + else{ + /* find the input buf that contains the data we need */ + for(inp=xpa->inphead; inp!=NULL; inp=inp->next){ + if( (client->bytes >= inp->start) && (client->bytes < inp->end) ){ + break; + } + } + /* if we can't find a buffer ... */ + if( !inp ){ + /* ... and we have all the input, we are done */ + if( xpa->ifd < 0 ){ + FPRINTF((stderr, "%sXPAClientSet: all data read\n", _sp)); + status = 1; + goto done; + } + /* ... but there is more input to come, return */ + else{ + return(0); + } + } + /* optimization: don't write a buffer until its full (or until eof) */ + if( (xpa->ifd >=0) && (inp->bytes < XPA_BIOSIZE) ){ + return(0); + } + + /* write bytes until we would block or until end of this buffer, etc */ + while( 1 ){ + len = MIN(XPA_IOSIZE, inp->end - client->bytes); + FPRINTF((stderr, "%sXPAClientSet: has %lu=min(%d,(%lu-%lu)) [%d]\n", + _sp, (unsigned long)len, XPA_IOSIZE, + (unsigned long)inp->end, (unsigned long)client->bytes, + client->status)); + /* if we are done with this buffer, just return */ + if( (client->status == XPA_CLIENT_PROCESSING) && (len <=0) ){ + /* see if everyone else is done with this buffer as well, + in which case we can free it */ + left = 0; + for(client=xpa->clienthead; client!=NULL; client=client->next){ + if( (client->type != 's') || !(client->mode & XPA_CLIENT_FD) ) + continue; + /* in order to be totally written out, the following must be true: + * 1. send->bytes must be past the end of this buffer + * and + * 2. this buffer must be filled or else we hit eof + */ + FPRINTF((stderr, + "%sXPAClientSet: %lu>=%lu && ((%lu>=%d) or %d<0)) .. ", + _sp, client->bytes, (unsigned long)inp->end, + (unsigned long)inp->bytes, XPA_BIOSIZE, + xpa->ifd)); + if( (client->bytes >= inp->end) && + ((inp->bytes >= XPA_BIOSIZE) || (xpa->ifd < 0)) ){ + /* buffer complete written */ + FPRINTF((stderr, "%sEOF (%lu)\n", + _sp, (unsigned long)xpa->inpbytes)); + ; + } + else{ + FPRINTF((stderr, "%s\n", _sp)); + /* buffer not complete written */ + left++; + break; + } + } + /* if nothing is left, we can free this input struct */ + if( !left ){ + XPAClientFreeInput(xpa, inp); + } + return(0); + } + /* write to the server */ + FPRINTF((stderr, + "%sXPAClientSet: fd %d sending %lu bytes (%lu):\n", _sp, + client->datafd, + (unsigned long)len, (unsigned long)client->bytes)); + got = send(client->datafd, &(inp->buf[client->bytes-inp->start]),len,0); + /* check for success */ + if( got >= 0 ){ + /* update the number of bytes we wrote */ + client->bytes += got; + FPRINTF((stderr, "%sXPAClientSet: sent %lu bytes (total is %lu)\n", + _sp, (unsigned long)got, (unsigned long)client->bytes)); + /* go back for more */ + if( XPALevelGet() >0 ) + return(got); + else + continue; + } + /* check for error */ + else{ + PERROR(("XPAClientSet")); + /* anything but a "would block" error is bad */ + if( (xerrno != EWOULDBLOCK) && (xerrno != EAGAIN) ){ + status = -1; + goto done; + } + /* write would block, so we return and wait the server */ + else{ + FPRINTF((stderr, "%sXPAClientSet: waiting for more data\n", _sp)); + return(0); + } + } + } + } + +done: + XPAClientDataSent(xpa, client); +#ifdef OLD + (void)XPAClientEnd(xpa, client); +#endif + return(status); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientProcessSelect + * + * Purpose: process xpas that have pending reads or writes + * + * Return: number of xpas processed + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +int +XPAClientProcessSelect (XPA xpa, + fd_set *readfdsptr, fd_set *writefdsptr, int maxreq) +#else +int XPAClientProcessSelect(xpa, readfdsptr, writefdsptr, maxreq) + XPA xpa; + fd_set *readfdsptr; + fd_set *writefdsptr; + int maxreq; +#endif +{ + int got=0; + int loop=0; + XPAClient client; + + /* <= 0 means do all of them */ + if( maxreq < 0 ){ + maxreq = 0; + } + + /* if no xpa is specified, do them all */ + if( xpa == NULL ){ + if( xpaclienthead == NULL ) return(0); + xpa = xpaclienthead; + loop = 1; + } + +loop: + /* first process any new input before we write output */ + if( xfd_isset_stdin(xpa->ifd, readfdsptr) ){ + xfd_clr_stdin(xpa->ifd, readfdsptr); + XPAClientProcessInput(xpa); + } + /* look at all clients */ +again: + for(client=xpa->clienthead; client!=NULL; client=client->next){ + /* if we are processing */ + if( (client->status == XPA_CLIENT_PROCESSING) && (client->datafd>=0) ){ + /* then handle new requests */ + if((client->type == 'g') && FD_ISSET(client->datafd, readfdsptr)){ + FD_CLR(client->datafd, readfdsptr); + XPAClientGet(xpa, client); + got++; + if( maxreq && (got >= maxreq) ) return(got); + goto again; + } + else if((client->type == 's') && FD_ISSET(client->datafd, writefdsptr)){ + FD_CLR(client->datafd, writefdsptr); + /* if the return is > 0, we completed the send */ + if( XPAClientSet(xpa, client) > 0 ) + got++; + if( maxreq && (got >= maxreq) ) return(got); + goto again; + } + } + /* if this client is waiting */ + else if( (client->status == XPA_CLIENT_WAITING) && (client->cmdfd >= 0) ){ + if( FD_ISSET(client->cmdfd, readfdsptr)){ + FD_CLR(client->cmdfd, readfdsptr); + XPAClientEnd(xpa, client); + got++; + if( maxreq && (got >= maxreq) ) return(got); + goto again; + } + } + } + /* loop if necessary */ + if( loop && (xpa=xpa->next) ) goto loop; + /* return the news */ + return(got); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientLoop + * + * Purpose: non-X programs event loop for handling XPA client events + * + * Returns: none + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static int +XPAClientLoop (XPA xpa, int mode) +#else +static int XPAClientLoop(xpa, mode) + XPA xpa; + int mode; +#endif +{ + int got=0; + int sgot; + int doxpa=1; + int ltimeout; + char *s=NULL; + fd_set readfds; + fd_set writefds; + static int width=0; + struct timeval tv; + struct timeval *tvp; + + /* set width once */ + if( width == 0 ){ + width = FD_SETSIZE; + } + /* allow environment to turn off xpa server processing in client loop */ + if( (s=getenv("XPA_CLIENT_DOXPA")) && isfalse(s) ){ + doxpa = 0; + } + ltimeout = XPALongTimeout(); + FD_ZERO(&readfds); + FD_ZERO(&writefds); + while( XPAClientAddSelect(xpa, &readfds, &writefds) ){ + /* add other XPA's and process them as we process the client */ + if( (mode & XPA_CLIENT_SEL_XPA) && doxpa ){ + FPRINTF((stderr, "%sXPAClientLoop: will handle server reqs ...\n", _sp)); + XPAAddSelect(NULL, &readfds); + } + /* hopefully, a server will respond in a finite amount of time */ + if( ltimeout > 0 ){ + tv.tv_sec = ltimeout; + tv.tv_usec = 0; + tvp = &tv; + } + /* wait forever, if necessary */ + else{ + tvp = NULL; + } + /* add stdin to select, if there is one */ + if( xpa->ifd >= 0 ){ + xfd_set_stdin(xpa->ifd, &readfds); +#if HAVE_MINGW32 + /* BUT: for windows, we can't add stdin to select and therefore we + must set a short timeout and look manually */ + tv.tv_sec = 0; + tv.tv_usec = 10000; + /* this is the number of window iterations we will perform */ + if( ltimeout > 0 ) + ltimeout *= 100; + tvp = &tv; +#endif + } + /* wait for a server to respond */ + FPRINTF((stderr, "%sXPAClientLoop: waiting on select() ...\n", _sp)); + sgot = xselect(width, &readfds, &writefds, NULL, tvp); + FPRINTF((stderr, "%sXPAClientLoop: select returns: %d\n", _sp, sgot)); + /* error -- what should we do? */ + if( sgot < 0 ){ + if( xerrno == EINTR ){ + FD_ZERO(&readfds); + FD_ZERO(&writefds); + continue; + } + if( XPAVerbosity() ){ + perror("XPAClientLoop() select"); + } + exit(1); + } + /* timed out -- no one responded */ + else if( sgot == 0 ){ +#if HAVE_MINGW32 + if( xpa->ifd >= 0 ){ + if( ltimeout > 0 ){ + if( --ltimeout <= 0 ) + break; + } + } + else{ + break; + } +#else + break; +#endif + } + else{ + got += XPAClientProcessSelect(xpa, &readfds, &writefds, 0); + if( (mode & XPA_CLIENT_SEL_XPA) && doxpa ){ + got += XPAProcessSelect(&readfds, 0); + } + } + FD_ZERO(&readfds); + FD_ZERO(&writefds); + } + return(got); +} + +#if HAVE_MINGW32==0 +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientLoopFork + * + * Purpose: non-X programs forked event loop for handling XPA client events + * + * Returns: number of clients "processed" + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static int +XPAClientLoopFork (XPA xpa, int mode) +#else +static int XPAClientLoopFork(xpa, mode) + XPA xpa; + int mode; +#endif +{ + XPAClient client, tclient; + pid_t pid; + int got; + int fd[2]; + char active=1; +#ifndef USE_DOUBLE_FORK + struct sigaction act; + /* set up the signal handler to reap children (to avoid zombies) */ + act.sa_handler = sig_chld; + sigemptyset(&act.sa_mask); + act.sa_flags = 0; +#ifdef SA_RESTART + act.sa_flags |= SA_RESTART; +#endif +#ifdef SA_NOCLDWAIT + act.sa_flags |= SA_NOCLDWAIT; +#endif + sigaction(SIGCHLD, &act, NULL); +#endif + + if( pipe(fd) < 0 ){ + got = 0; + } + else if( (pid = fork()) < 0 ){ + close(fd[0]); + close(fd[1]); + got=0; + } + else if( pid == 0 ){ /* child */ + /* child write to parent that he is active */ + close(fd[0]); + write(fd[1], &active, 1); + close(fd[1]); +#ifdef USE_DOUBLE_FORK + /* second fork prevents zombies: + when child/parent exits, second child is inherited + by init and thus is not a child of original parent */ + if( (pid = fork()) >= 0 ){ + /* child/parent exits */ + if( pid > 0 ) + exit(0); + /* new child goes on under init ... */ + } +#endif + /* enter the main loop and process */ + XPAIOCallsXPA(0); + XPAClientLoop(xpa, mode); + exit(0); + } else { /* parent */ + /* parent waits for child to wake up */ + close(fd[1]); + read(fd[0], &active, 1); + close(fd[0]); +#ifdef USE_DOUBLE_FORK + /* for double fork, also wait for intermediate process to exit */ + waitpid(pid, NULL, 0); +#endif + /* fake end of clients */ + for(got=0, client=xpa->clienthead; client!=NULL; ){ + got++; + tclient = client->next; + if( (client->status == XPA_CLIENT_PROCESSING) && (client->datafd >=0) ){ +#if HAVE_CYGWIN + /* In Cygwin, we call shutdown (as well as close) to avoid Windows + problems. The parent can't do this since the child is using the + sockets, so we just close the sockets explicitly here */ + xclose(client->datafd); + client->datafd = -1; + if( !xpa->persist ){ + xclose(client->cmdfd); + client->cmdfd = -1; + } +#endif + client->errptr = NULL; + /* remove this client if we are not meant to persist */ + if( !xpa->persist ){ + XPAClientFree(xpa, client); + } + /* otherwise mark as inactive */ + else{ + client->status = XPA_CLIENT_IDLE; + client->bytes = 0; + } + } + client = tclient; + } + } + return(got); +} +#endif + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientConnect + * + * Purpose: go to name service and get new names, merge with old, + * and connect to servers + * + * Returns: number of connections + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static int +XPAClientConnect (XPA xpa, char *mode, char *xtemplate, int type) +#else +static int XPAClientConnect(xpa, mode, xtemplate, type) + XPA xpa; + char *mode; + char *xtemplate; + int type; +#endif +{ + int i; + int n; + int got; + int lp=0; + int total=0; + char **xclasses; + char **names; + char **methods; + char **infos; + char xtype[2]; + char xmode[SZ_LINE]; + char tbuf[SZ_LINE]; + char lbuf[SZ_LINE]; + XPAClient client; + + /* do some initialization */ + XPAInitEnv(); + + /* make sure we have a target */ + if( !xtemplate || !*xtemplate ) + return(0); + + /* make a string out of the type for the lookup */ + xtype[0] = type; + xtype[1] = '\0'; + + /* reset the number of clients we are processing */ + xpa->nclient = 0; + + /* look for specific proxy info */ + *xmode = '\0'; + if( mode ){ + strncpy(xmode, mode, SZ_LINE-1); + xmode[SZ_LINE-1] = '\0'; + } + if( keyword(xmode, "ns", lbuf, SZ_LINE) ){ + FPRINTF((stderr, "%sXPAClientConnect: using ns info: %s\n", _sp, lbuf)); + newdtable("(),"); + xclasses = (char **)xmalloc(sizeof(char *)); + names = (char **)xmalloc(sizeof(char *)); + methods = (char **)xmalloc(sizeof(char *)); + infos = (char **)xmalloc(sizeof(char *)); + if( word(lbuf, tbuf, &lp) ) + xclasses[0] = xstrdup(tbuf); + if( word(lbuf, tbuf, &lp) ) + names[0] = xstrdup(tbuf); + if( word(lbuf, tbuf, &lp) ) + methods[0] = xstrdup(tbuf); + infos[0] = xstrdup(XPA_DEF_CLIENT_INFO); + n = 1; + freedtable(); + } + /* else ask xpans for access points matching the template */ + else{ + n = XPANSLookup(xpa, + xtemplate, xtype, &xclasses, &names, &methods, &infos); + } + /* mark existing clients who do not match this template */ + for(got=0, client=xpa->clienthead; client !=NULL; client=client->next){ + for(i=0; i<n; i++){ + if( (client->type == type) && + (!strcmp(client->xclass, xclasses[i])) && + (!strcmp(client->name, names[i])) && + (!strcmp(client->method, methods[i])) && + (!strcmp(client->info, infos[i])) ){ + got++; + } + } + /* don't unmark if its a different type -- someone else might be active */ + if( !got && (client->type == type) ){ + client->status = XPA_CLIENT_IDLE; + } + } + /* add new clients for this type */ + for(i=0; i<n; i++){ + for(got=0, client=xpa->clienthead; client !=NULL; client=client->next){ + if( (client->type == type) && + (!strcmp(client->xclass, xclasses[i])) && + (!strcmp(client->name, names[i])) && + (!strcmp(client->method, methods[i])) && + (!strcmp(client->info, infos[i])) ){ + /* might have to change the template */ + if( strcmp(client->xtemplate, xtemplate) ){ + xfree(client->xtemplate); + client->xtemplate = xstrdup(xtemplate); + } + client->status = XPA_CLIENT_ACTIVE; + got++; + total++; + FPRINTF((stderr, "%sXPAClientConnect: existing match: %s %s %s\n", + _sp, xclasses[i], names[i], methods[i])); + break; + } + } + if( !got ){ + FPRINTF((stderr, "%sXPAClientConnect: calls XPAClientNew for %s:%s %s\n", + _sp, xclasses[i], names[i], methods[i])); + if( XPAClientNew(xpa, mode, xtemplate, type, + xclasses[i], names[i], methods[i], infos[i]) ) + total++; + } + /* done with these strings */ + xfree(xclasses[i]); + xfree(names[i]); + xfree(methods[i]); + xfree(infos[i]); + } + /* free up arrays alloc'ed by names server */ + if( n > 0 ){ + xfree(xclasses); + xfree(names); + xfree(methods); + xfree(infos); + } + return(total); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClientStart + * + * Purpose: send init string to server and perform other authentication + * tasks + * + * Returns: 0 if success, -1 otherwise + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +static int +XPAClientStart (XPA xpa, XPAClient client, char *paramlist, char *mode) +#else +static int XPAClientStart(xpa, client, paramlist, mode) + XPA xpa; + XPAClient client; + char *paramlist; + char *mode; +#endif +{ + int fd=0; + int lp=0; + int flags; + int tries=0; + int dmode=0; + int keep_alive=1; + unsigned int ip=0; + unsigned short port; + char tbuf[SZ_LINE]; + char tbuf2[SZ_LINE]; + char lbuf[SZ_LINE]; + char *cmd=NULL; + char *method=NULL; + struct sockaddr_in sock_in; +#if HAVE_SYS_UN_H + struct sockaddr_un sock_un; +#endif + + switch(client->type){ + case 'a': + cmd = "xpaaccess"; + break; + case 'g': + cmd = "xpaget"; + break; + case 'i': + cmd = "xpainfo"; + break; + case 's': + cmd = "xpaset"; + break; + } + + /* get mode flags */ + XPAMode(mode, &(client->mode), "ack", XPA_CLIENT_ACK, 1); + if( client->type == 's' ) + XPAMode(mode, &(xpa->client_mode), "verify", XPA_CLIENT_VERIFY, 0); + /* package up and send the initialization message */ + strcpy(lbuf, cmd); + /* set and save the id value */ + snprintf(tbuf, SZ_LINE, "%c%d", client->type, id++); + if( client->id ) xfree(client->id); + client->id = xstrdup(tbuf); + /* if we are using the xpans proxy, we will want to call + accept() (server calls connect()) for the data channel */ + if( client->nsproxy ) + strcat(lbuf, " -a"); + /* set the value of the client big-endian-ness */ + snprintf(tbuf, SZ_LINE, " -e %s", XPAEndian() ? "big" : "little"); + strcat(lbuf, tbuf); + snprintf(tbuf, SZ_LINE, " -i %s", client->id); + strcat(lbuf, tbuf); + if( !(client->mode & XPA_CLIENT_ACK) ) + strcat(lbuf, " -n"); + if( strcmp(client->info, XPA_DEF_CLIENT_INFO) ){ + snprintf(tbuf, SZ_LINE, " -p %s", client->info); + strcat(lbuf, tbuf); + } + snprintf(tbuf, SZ_LINE, " %s:%s", client->xclass, client->name); + strcat(lbuf, tbuf); + if( paramlist && *paramlist ){ + strcat(lbuf, " "); + strncat(lbuf, paramlist, MAX(0,(int)(SZ_LINE-(int)strlen(lbuf)-2))); + } + strcat(lbuf, "\n"); + FPRINTF((stderr, "%sXPAClientStart: fd %d sends:\n%s", + _sp, client->cmdfd, lbuf)); + if( XPAPuts(NULL, client->cmdfd, lbuf, XPAShortTimeout()) <= 0 ){ + goto error; + } + + /* if xpainfo and no ack'ing, we are basically done */ + if( (client->type == 'i') && !(client->mode & XPA_CLIENT_ACK) ){ + goto done; + } + + /* authentication */ +retry: + lp = 0; + if( XPAGets(NULL, client->cmdfd, lbuf, SZ_LINE, XPAShortTimeout()) >0 ){ + FPRINTF((stderr, "%sXPAClientStart: fd %d received cmd:\n%s", _sp, + client->cmdfd, lbuf)); + /* this should never happen */ + if( !word(lbuf, tbuf, &lp) || (*tbuf == '?') ){ + snprintf(errbuf, SZ_LINE, + "XPA$WARNING: Protocol mismatch: id\n%s", lbuf); + goto error; + } + /* make sure we are dealing with a proper message */ + if( strcmp(tbuf, client->id) ){ + FPRINTF((stderr, "%sXPA$WARNING: ignoring out of sync message:\n", _sp)); + FPRINTF((stderr, "%s", lbuf)); + if( XPAVerbosity() > 1 ){ + fprintf(stderr, "XPA$WARNING: ignoring out of sync server message:\n"); + fprintf(stderr, "%s", lbuf); + } + goto retry; + } + + /* this should never happen */ + if( !word(lbuf, tbuf, &lp) ){ + snprintf(errbuf, SZ_LINE, "XPA$WARNING: missing BUF request\n%s", lbuf); + goto error; + } + if( !strcmp(tbuf, "XPA$NODATA") || !strcmp(tbuf, "XPA$NOBUF") ){ + xpa->nclient += 1; + goto started; + } + /* support 2.2 (DATA) and 2.0,2.1 (BUF) */ + else if( !strcmp(tbuf, "XPA$DATA") || !strcmp(tbuf, "XPA$BUF") ){ + if( !strcmp(tbuf, "XPA$DATA") ){ + dmode |= DATA_DATA; + if( !word(lbuf, tbuf, &lp) ){ + snprintf(errbuf, SZ_LINE, + "XPA$WARNING: missing DATA request type\n%s", lbuf); + goto error; + } + if( !strcmp(tbuf, "connect") ){ + method = client->method; + dmode |= DATA_CONNECT; + } + else if( !strcmp(tbuf, "accept") ){ + method = client->method; + dmode |= DATA_ACCEPT; + } + else{ + snprintf(errbuf, SZ_LINE, + "XPA$WARNING: invalid data connection request: %s (%s:%s)\n", + tbuf, client->xclass, client->name); + goto error; + } + } + else if( !strcmp(tbuf, "XPA$BUF") ){ + if( !word(lbuf, tbuf, &lp) ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: missing data buffer method (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + goto error; + } + method = tbuf; + dmode |= DATA_CONNECT; + } + /* handle connect-type requests */ + if( dmode & DATA_CONNECT ){ + switch(XPAMethod(method)){ + case XPA_INET: + XPAParseIpPort(method, &ip, &port); + /* connect to the server before we go further */ + if( (fd = xsocket(AF_INET, SOCK_STREAM, 0)) < 0 ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: bad socket for data chan (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + if( XPAVerbosity() ){ + perror("XPA client socket"); + } + goto error; + } + setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, + (char *)&keep_alive, sizeof(keep_alive)); + memset((char *)&sock_in, 0, sizeof(sock_in)); + sock_in.sin_family = AF_INET; + /* connect using the same ip we used for the command channel + (i.e., could be localhost) */ + sock_in.sin_addr.s_addr = htonl(client->ip); + sock_in.sin_port = htons(port); + FPRINTF((stderr, + "%sXPAClientStart: attempting dchan connect: %s\n", + _sp, method)); + if( connect(fd, (struct sockaddr *)&sock_in, sizeof(sock_in)) < 0 ){ + PERROR(("dchan connect")); + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: can't connect to data chan (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + if( XPAVerbosity() ){ + perror("XPA client connect"); + } + xclose(fd); + goto error; + } + break; +#if HAVE_SYS_UN_H + case XPA_UNIX: +again: + /* open a socket and fill in socket information */ + if( (fd = xsocket(AF_UNIX, SOCK_STREAM, 0)) < 0 ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: bad socket for data chan (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + if( XPAVerbosity() ){ + perror("XPA client socket"); + } + goto error; + } + setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, + (char *)&keep_alive, sizeof(keep_alive)); + memset((char *)&sock_un, 0, sizeof(sock_un)); + sock_un.sun_family = AF_UNIX; + strcpy(sock_un.sun_path, method); + FPRINTF((stderr, + "%sXPAClientStart: attempting dchan connect: %s\n", + _sp, method)); + if( connect(fd, (struct sockaddr *)&sock_un, sizeof(sock_un)) < 0 ){ + PERROR(("dchan connect")); + xclose(fd); + if( (xerrno == ECONNREFUSED) && (tries < XPA_RETRIES) ){ + tries++; + xclose(fd); + XPASleep(10); + goto again; + } + /* give up */ + else{ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: can't connect to data chan (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + if( XPAVerbosity() ){ + perror("XPA client connect"); + } + goto error; + } + } + break; +#endif + default: + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: unknown connection method (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + goto error; + } + } + /* handle "doaccept" requests */ + else if( dmode & DATA_ACCEPT ){ + fd = XPAProxyAccept(xpa, XPANSMethod(NULL,2), + client->xclass, client->name, client->cmdfd, + NULL, NULL, tbuf2); + if( fd < 0 ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: can't connect to proxy server (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + goto error; + } + else if( *tbuf2 ){ + client->dataname = xstrdup(tbuf2); + } + } + + /* common code for either type of data connect request */ + client->datafd = fd; + /* make sure we close on exec */ + xfcntl(client->datafd, F_SETFD, FD_CLOEXEC); + /* for senders, set to no block mode */ + if( client->type == 's' ){ + /* save state and set in non-blocking mode */ + xfcntl_nonblock(client->datafd, flags); + } + xpa->nclient += 1; + goto started; + } + /* handle error message */ + else if( !strcmp(tbuf, "XPA$ERROR") ){ + snprintf(errbuf, SZ_LINE, "%s", &lbuf[lp]); + goto error; + } + /* everything else is an error */ + else{ + snprintf(errbuf, SZ_LINE, "%s", &lbuf[lp]); + goto error; + } + } + else{ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server during handshake (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + goto error; + } + +error: + FPRINTF((stderr, "Error in XPAClientStart: %s", errbuf)); + XPAClientFree(xpa, client); + return(-1); + +started: + /* it is necessary to add this this extra hack/ack between the + authentication ack and the error return (both from the server) + to avoid getting Nagle buffered. if we already did an accept, + however, we already sent a message and need not repeat it */ + if( !(dmode & DATA_ACCEPT) ){ + FPRINTF((stderr, "%sXPAClientStart: %d sending nagle\n", + _sp, client->cmdfd)); + XPAPuts(NULL, client->cmdfd, "xpanagle\n", XPAShortTimeout()); + } + + /* write a "data request" to the server on the data channel, supplying + the arguments to allow the server to find the associated command */ + if( dmode & DATA_DATA ){ + if( !word(lbuf, tbuf, &lp) ) + strcpy(tbuf, "?"); + if( !word(lbuf, tbuf2, &lp) ) + strcpy(tbuf2, "?"); + snprintf(lbuf, SZ_LINE, "xpadata -f %s %s\n", tbuf, tbuf2); + FPRINTF((stderr, + "%sXPAClientStart: sending data channel %d request: %s", _sp, + client->datafd, lbuf)); + if( XPAPuts(NULL, client->datafd, lbuf, XPAShortTimeout()) <0 ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: unable to issue data request: %s (%s:%s%s)\n", + lbuf, client->xclass, client->name, XPATimestamp()); + FPRINTF((stderr, "%sXPAClientStart: error returned is %s", _sp, errbuf)); + goto error; + } + } + +done: + /* mark as active and started */ + client->status = XPA_CLIENT_PROCESSING; + return(0); +} + +/* + *---------------------------------------------------------------------------- + * + * + * Public Routines + * + * + *---------------------------------------------------------------------------- + */ + +/* + *--------------------------------------------------------------------------- + * + * Routine: XPAClientValid + * + * Purpose: see if the xpa client struct is valid + * + * Results: 1 on success, 0 for failure + * + *--------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +int +XPAClientValid (XPA xpa) +#else +int XPAClientValid(xpa) + XPA xpa; +#endif +{ + return(_XPAValid(xpaclienthead, xpa, "c")); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAOpen + * + * Purpose: open a persistent XPA client connection + * + * Returns: XPA struct on success + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +XPA +XPAOpen (char *mode) +#else +XPA XPAOpen(mode) + char *mode; +#endif +{ + XPA xpa; + + /* allocate xpa struct */ + if( (xpa = (XPA)xcalloc(1, sizeof(XPARec))) == NULL ) + return(NULL); + /* add version */ + xpa->version = xstrdup(XPA_VERSION); + /* mark this as a client struct */ + xpa->type = xstrdup("c"); + /* mark as persistent so we don't destroy at the end of the transfer */ + xpa->persist = 1; + + /* add this xpa to end of list of client xpas */ + XPAListAdd(&xpaclienthead, xpa); + + return(xpa); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAClose + * + * Purpose: close a persistent XPA client connection + * + * Returns: none + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +void +XPAClose (XPA xpa) +#else +void XPAClose(xpa) + XPA xpa; +#endif +{ + XPAClient client, tclient; + NS ns, tns; + + /* ignore struct if its not a client struct */ + if( !XPAClientValid(xpa) ) + return; + + /* remove from list of client xpas */ + XPAListDel(&xpaclienthead, xpa); + + /* free each remaining client */ + for(client=xpa->clienthead; client!=NULL; ){ + tclient = client->next; + XPAClientFree(xpa, client); + client = tclient; + } + + /* close down the name server and all of the remotes for this xpa */ + for(ns=xpa->nshead; ns!=NULL; ){ + tns = ns->next; + XPANSClose(xpa, ns); + ns = tns; + } + + /* free string space */ + if( xpa->version ) + xfree(xpa->version); + if( xpa->type ) + xfree(xpa->type); + if( xpa ) + xfree(xpa); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAGet + * + * Purpose: get XPA values + * + * Returns: 0 for success, -1 for failure + * len bytes of data returned in buf + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +int +XPAGet (XPA xpa, char *xtemplate, char *paramlist, char *mode, + char **bufs, size_t *lens, char **names, char **messages, int n) +#else +int XPAGet(xpa, xtemplate, paramlist, mode, bufs, lens, names, messages, n) + XPA xpa; + char *xtemplate; + char *paramlist; + char *mode; + char **bufs; + size_t *lens; + char **names; + char **messages; + int n; +#endif +{ + int i; + int oldmode=0; + int xmode=0; + int type='g'; + int idef=1; + int got=0; + char tbuf[SZ_LINE]; + XPAClient client, tclient; + + FPRINTF((stderr, "%sXPAGet: starting\n", _sp)); + /* if not persistent, we need a temp xpa struct; + (also ignore passed struct if its not a client struct) */ + if( (xpa == NULL) || strcmp(xpa->type, "c") ){ + if( (xpa = XPAOpen(NULL)) == NULL ) + return(-1); + /* mark this as not persistent */ + xpa->persist = 0; + } + /* save xpa mode -- this call might override */ + else{ + /* make sure we have a valid client handle */ + if( !XPAClientValid(xpa) ){ + if( XPAVerbosity() ){ + fprintf(stderr, "XPA$ERROR: invalid xpa client handle\n"); + } + return(-1); + } + oldmode = xpa->client_mode; + } + + /* these arrays are required */ + if( (bufs == NULL) || (lens == NULL) ){ + got = -1; + goto done; + } + + /* flag that we don't read from stdin */ + xpa->ifd = -1; + + /* zero out the return buffers */ + memset((char *)bufs, 0, ABS(n)*sizeof(char *)); + memset((char *)lens, 0, ABS(n)*sizeof(size_t)); + if( names != NULL ) + memset((char *)names, 0, ABS(n)*sizeof(char *)); + if( messages != NULL ) + memset((char *)messages, 0, ABS(n)*sizeof(char *)); + + /* connect to clients and grab data */ + if( XPAClientConnect(xpa, mode, xtemplate, type) >0 ){ + /* retrieve data from n active clients */ + for(client=xpa->clienthead; client!=NULL; ){ + tclient = client->next; + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (got<ABS(n)) ){ + if( names != NULL ){ + snprintf(tbuf, SZ_LINE, "%s:%s %s", + client->xclass, client->name, client->method); + names[got] = xstrdup(tbuf); + } + if( XPAClientStart(xpa, client, paramlist, mode) >=0 ){ + /* we fill buffers */ + client->mode |= XPA_CLIENT_BUF; + client->bufptr = &(bufs[got]); + client->lenptr = &(lens[got]); + if( names != NULL ) + client->nameptr = &(names[got]); + if( messages != NULL ) + client->errptr = &(messages[got]); + } + else{ + if( messages != NULL ) + messages[got] = xstrdup(errbuf); + } + got++; + } + client = tclient; + } + /* if we have active clients */ + if( got ){ +#if HAVE_MINGW32==0 + /* check for loop modes */ + XPAMode(mode, &xmode, "dofork", XPA_CLIENT_SEL_FORK, 0); + /* dofork implies don't do xpa */ + if( xmode & XPA_CLIENT_SEL_FORK ) + idef = 0; + XPAMode(mode, &xmode, "doxpa", XPA_CLIENT_SEL_XPA, idef); + if( xmode & XPA_CLIENT_SEL_FORK ){ + XPAClientLoopFork(xpa, xmode); + } + else{ + /* enter the main loop and process */ + XPAClientLoop(xpa, xmode); + } +#else + XPAMode(mode, &xmode, "doxpa", XPA_CLIENT_SEL_XPA, idef); + XPAClientLoop(xpa, xmode); +#endif + } + } + +done: + /* look for clients who timed out */ + for(i=0, client=xpa->clienthead; client!=NULL; client=client->next){ + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (i<ABS(n)) ){ + i++; + if( (client->status == XPA_CLIENT_PROCESSING) && ( messages != NULL) ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server callback (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + messages[i] = xstrdup(errbuf); + } + } + } + /* remove this xpa if we are not meant to persist */ + if( xpa && !xpa->persist ) + XPAClose(xpa); + /* restore xpa mode -- this call might override */ + else + xpa->client_mode = oldmode; + + /* return number of clients processes (including errors) */ + return(got); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAGetFd + * + * Purpose: get XPA values + * + * Returns: 0 for success, -1 for failure + * len bytes of data returned in buf + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +int +XPAGetFd (XPA xpa, char *xtemplate, char *paramlist, char *mode, + int *fds, char **names, char **messages, int n) +#else +int XPAGetFd(xpa, xtemplate, paramlist, mode, fds, names, messages, n) + XPA xpa; + char *xtemplate; + char *paramlist; + int *fds; + char *mode; + char **names; + char **messages; + int n; +#endif +{ + int i; + int oldmode=0; + int xmode=0; + int got=0; + int type='g'; + int idef=1; + char tbuf[SZ_LINE]; + XPAClient client, tclient; + + FPRINTF((stderr, "%sXPAGetFd: starting\n", _sp)); + /* if not persistent, we need a temp xpa struct; + (also ignore passed struct if its not a client struct) */ + if( (xpa == NULL) || strcmp(xpa->type, "c") ){ + if( (xpa = XPAOpen(NULL)) == NULL ) + return(-1); + /* mark this as not persistent */ + xpa->persist = 0; + } + /* save xpa mode -- this call might override */ + else{ + /* make sure we have a valid client handle */ + if( !XPAClientValid(xpa) ){ + if( XPAVerbosity() ){ + fprintf(stderr, "XPA$ERROR: invalid xpa client handle\n"); + } + return(-1); + } + oldmode = xpa->client_mode; + } + + /* flag that we don't read from stdin */ + xpa->ifd = -1; + + /* zero out the return buffers */ + if( names != NULL ) + memset((char *)names, 0, ABS(n)*sizeof(char *)); + if( messages != NULL ) + memset((char *)messages, 0, ABS(n)*sizeof(char *)); + + /* connect to clients and grab data */ + if( XPAClientConnect(xpa, mode, xtemplate, type) > 0 ){ + /* retrieve data from n active clients */ + for(client=xpa->clienthead; client!=NULL; ){ + tclient = client->next; + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (got<ABS(n)) ){ + if( names != NULL ){ + snprintf(tbuf, SZ_LINE, "%s:%s %s", + client->xclass, client->name, client->method); + names[got] = xstrdup(tbuf); + } + if( XPAClientStart(xpa, client, paramlist, mode) >= 0 ){ + /* we write to an fd */ + client->mode |= XPA_CLIENT_FD; + /* negative value => one channel for all clients */ + if( n < 0 ) + client->fd = fds[0]; + else + client->fd = fds[got]; + client->bufptr = (char **)xcalloc(1, sizeof(char *)); + client->lenptr = (size_t *)xcalloc(1, sizeof(size_t)); + if( names != NULL ) + client->nameptr = &(names[got]); + if( messages != NULL ) + client->errptr = &(messages[got]); + } + else{ + if( messages != NULL ) + messages[got] = xstrdup(errbuf); + } + got++; + } + client = tclient; + } + /* if we have active clients */ + if( got ){ +#if HAVE_MINGW32==0 + /* check for loop modes */ + XPAMode(mode, &xmode, "dofork", XPA_CLIENT_SEL_FORK, 0); + /* dofork implies don't do xpa */ + if( xmode & XPA_CLIENT_SEL_FORK ) + idef = 0; + XPAMode(mode, &xmode, "doxpa", XPA_CLIENT_SEL_XPA, idef); + if( xmode & XPA_CLIENT_SEL_FORK ){ + XPAClientLoopFork(xpa, xmode); + } + else{ + /* enter the main loop and process */ + XPAClientLoop(xpa, xmode); + } +#else + XPAMode(mode, &xmode, "doxpa", XPA_CLIENT_SEL_XPA, idef); + XPAClientLoop(xpa, xmode); +#endif + } + } + /* look for clients who timed out */ + for(i=0, client=xpa->clienthead; client!=NULL; client=client->next){ + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (i<ABS(n)) ){ + i++; + if( (client->status == XPA_CLIENT_PROCESSING) && ( messages != NULL) ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server callback (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + messages[i] = xstrdup(errbuf); + } + } + } + /* remove this xpa if we are not meant to persist */ + if( xpa && !xpa->persist ) + XPAClose(xpa); + /* restore xpa mode -- this call might override */ + else + xpa->client_mode = oldmode; + + /* return number of clients processes (including errors) */ + return(got); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPASet + * + * Purpose: set XPA values + * + * Returns: 0 for success, -1 for failure + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +int +XPASet (XPA xpa, char *xtemplate, char *paramlist, char *mode, + char *buf, size_t len, char **names, char **messages, int n) +#else +int XPASet(xpa, xtemplate, paramlist, mode, buf, len, names, messages, n) + XPA xpa; + char *xtemplate; + char *paramlist; + char *mode; + char *buf; + size_t len; + char **names; + char **messages; + int n; +#endif +{ + int i; + int oldmode=0; + int xmode=0; + int got=0; + int type='s'; + int idef=1; + char tbuf[SZ_LINE]; + XPAClient client, tclient; + + FPRINTF((stderr, "%sXPASet: starting\n", _sp)); + /* if not persistent, we need a temp xpa struct; + (also ignore passed struct if its not a client struct) */ + if( (xpa == NULL) || strcmp(xpa->type, "c") ){ + if( (xpa = XPAOpen(NULL)) == NULL ) + return(-1); + /* mark this as not persistent */ + xpa->persist = 0; + } + /* save xpa mode -- this call might override */ + else{ + /* make sure we have a valid client handle */ + if( !XPAClientValid(xpa) ){ + if( XPAVerbosity() ){ + fprintf(stderr, "XPA$ERROR: invalid xpa client handle\n"); + } + return(-1); + } + oldmode = xpa->client_mode; + } + + /* flag that we don't read from stdin */ + xpa->ifd = -1; + + /* zero out the return buffers */ + if( names != NULL ) + memset((char *)names, 0, ABS(n)*sizeof(char *)); + if( messages != NULL ) + memset((char *)messages, 0, ABS(n)*sizeof(char *)); + + /* connect to clients and grab data */ + if( XPAClientConnect(xpa, mode, xtemplate, type) >0 ){ + /* retrieve data from n active clients */ + for(client=xpa->clienthead; client!=NULL; ){ + tclient = client->next; + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (got<ABS(n)) ){ + if( names != NULL ){ + snprintf(tbuf, SZ_LINE, "%s:%s %s", + client->xclass, client->name, client->method); + names[got] = xstrdup(tbuf); + } + if( XPAClientStart(xpa, client, paramlist, mode) >= 0 ){ + /* we fill buffers */ + client->mode |= XPA_CLIENT_BUF; + client->buf = buf; + client->len = len; + if( names != NULL ) + client->nameptr = &(names[got]); + if( messages != NULL ) + client->errptr = &(messages[got]); + } + else{ + if( messages != NULL ) + messages[got] = xstrdup(errbuf); + } + got++; + } + client = tclient; + } + /* if we have active clients */ + if( got ){ +#if HAVE_MINGW32==0 + /* check for loop modes */ + XPAMode(mode, &xmode, "dofork", XPA_CLIENT_SEL_FORK, 0); + /* dofork implies don't do xpa */ + if( xmode & XPA_CLIENT_SEL_FORK ) + idef = 0; + XPAMode(mode, &xmode, "doxpa", XPA_CLIENT_SEL_XPA, idef); + if( xmode & XPA_CLIENT_SEL_FORK ){ + XPAClientLoopFork(xpa, xmode); + } + else{ + /* enter the main loop and process */ + XPAClientLoop(xpa, xmode); + } +#else + XPAMode(mode, &xmode, "doxpa", XPA_CLIENT_SEL_XPA, idef); + XPAClientLoop(xpa, xmode); +#endif + } + } + /* look for clients who timed out */ + for(i=0, client=xpa->clienthead; client!=NULL; client=client->next){ + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (i<ABS(n)) ){ + i++; + if( (client->status == XPA_CLIENT_PROCESSING) && ( messages != NULL) ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server callback (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + messages[i] = xstrdup(errbuf); + } + } + } + /* remove this xpa if we are not meant to persist */ + if( xpa && !xpa->persist ) + XPAClose(xpa); + /* restore xpa mode -- this call might override */ + else + xpa->client_mode = oldmode; + + /* return number of clients processes (including errors) */ + return(got); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPASetFd + * + * Purpose: set XPA values + * + * Returns: 0 for success, -1 for failure + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +int +XPASetFd (XPA xpa, char *xtemplate, char *paramlist, char *mode, + int fd, char **names, char **messages, int n) +#else +int XPASetFd(xpa, xtemplate, paramlist, mode, fd, names, messages, n) + XPA xpa; + char *xtemplate; + char *paramlist; + char *mode; + int fd; + char **names; + char **messages; + int n; +#endif +{ + int i; + int oldmode=0; + int xmode=0; + int got=0; + int got2=0; + int type='s'; + int idef=1; + int flags; + char *s; + char tbuf[SZ_LINE]; + XPAClient client, tclient; + + FPRINTF((stderr, "%sXPASetFd: starting\n", _sp)); + /* if not persistent, we need a temp xpa struct; + (also ignore passed struct if its not a client struct) */ + if( (xpa == NULL) || strcmp(xpa->type, "c") ){ + if( (xpa = XPAOpen(NULL)) == NULL ) + return(-1); + /* mark this as not persistent */ + xpa->persist = 0; + } + /* save xpa mode -- this call might override */ + else{ + /* make sure we have a valid client handle */ + if( !XPAClientValid(xpa) ){ + if( XPAVerbosity() ){ + fprintf(stderr, "XPA$ERROR: invalid xpa client handle\n"); + } + return(-1); + } + oldmode = xpa->client_mode; + } + + /* Set non-blocking mode for the input fd, if its not a tty */ + xpa->ifd = fd; + if( isatty(xpa->ifd) == 0 ){ + /* save state and set in non-blocking mode */ + xfcntl_nonblock(xpa->ifd, flags); + } + /* zero out the return buffers */ + if( names != NULL ) + memset((char *)names, 0, ABS(n)*sizeof(char *)); + if( messages != NULL ) + memset((char *)messages, 0, ABS(n)*sizeof(char *)); + + /* connect to clients and grab data */ + if( XPAClientConnect(xpa, mode, xtemplate, type) >0 ){ + /* open clients all at once */ + for(client=xpa->clienthead; client!=NULL; ){ + tclient = client->next; + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (got<ABS(n)) ){ + if( names != NULL ){ + snprintf(tbuf, SZ_LINE, "%s:%s %s", + client->xclass, client->name, client->method); + names[got] = xstrdup(tbuf); + } + if( XPAClientStart(xpa, client, paramlist, mode) >= 0 ){ + /* we fill buffers */ + client->mode |= XPA_CLIENT_FD; + if( names != NULL ) + client->nameptr = &(names[got]); + if( messages != NULL ) + client->errptr = &(messages[got]); + } + else{ + if( messages != NULL ) + messages[got] = xstrdup(errbuf); + } + got++; + } + client = tclient; + } + /* if we have active clients */ + if( got ){ + /* if fd is null, user did not want to send data, just the paramlist */ + if( fd < 0 ){ + for(client=xpa->clienthead; client!=NULL; ){ + tclient = client->next; + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (got<ABS(n)) ){ + XPAClientDataSent(xpa, client); + s = XPAClientEnd(xpa, client); + if( (messages != NULL) && (messages[got2] == NULL) ) + messages[got2] = xstrdup(s); + got2++; + } + client = tclient; + } + } + else{ +#if HAVE_MINGW32==0 + /* check for loop modes */ + XPAMode(mode, &xmode, "dofork", XPA_CLIENT_SEL_FORK, 0); + /* dofork implies don't do xpa */ + if( xmode & XPA_CLIENT_SEL_FORK ) + idef = 0; + XPAMode(mode, &xmode, "doxpa", XPA_CLIENT_SEL_XPA, idef); + if( xmode & XPA_CLIENT_SEL_FORK ){ + XPAClientLoopFork(xpa, xmode); + } + else{ + /* enter the main loop and process */ + XPAClientLoop(xpa, xmode); + } +#else + XPAMode(mode, &xmode, "doxpa", XPA_CLIENT_SEL_XPA, idef); + XPAClientLoop(xpa, xmode); +#endif + } + } + } + /* look for clients who timed out */ + for(i=0, client=xpa->clienthead; client!=NULL; client=client->next){ + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (i<ABS(n)) ){ + i++; + if( (client->status == XPA_CLIENT_PROCESSING) && ( messages != NULL) ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server callback (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + messages[i] = xstrdup(errbuf); + } + } + } + /* reset flags, if necessary */ + if( xpa->ifd >=0 && (isatty(xpa->ifd) ==0) ){ + xfcntl(xpa->ifd, F_SETFL, flags); + } + /* free all input structs */ + XPAClientFreeAllInputs(xpa); + /* remove this xpa if we are not meant to persist */ + if( xpa && !xpa->persist ) + XPAClose(xpa); + /* restore xpa mode -- this call might override */ + else + xpa->client_mode = oldmode; + + /* return number of clients processes (including errors) */ + return(got); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAInfo + * + * Purpose: send XPA info + * + * Returns: 0 for success, -1 for failure + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +int +XPAInfo (XPA xpa, char *xtemplate, char *paramlist, char *mode, + char **names, char **messages, int n) +#else +int XPAInfo(xpa, xtemplate, paramlist, mode, names, messages, n) + XPA xpa; + char *xtemplate; + char *paramlist; + char *mode; + char **names; + char **messages; + int n; +#endif +{ + int i; + int oldmode=0; + int got=0; + char type='i'; + char *s; + char tbuf[SZ_LINE]; + XPAClient client, tclient; + + /* if not persistent, we need a temp xpa struct; + (also ignore passed struct if its not a client struct) */ + if( (xpa == NULL) || strcmp(xpa->type, "c") ){ + if( (xpa = XPAOpen(NULL)) == NULL ) + return(-1); + /* mark this as not persistent */ + xpa->persist = 0; + } + /* save xpa mode -- this call might override */ + else{ + /* make sure we have a valid client handle */ + if( !XPAClientValid(xpa) ){ + if( XPAVerbosity() ){ + fprintf(stderr, "XPA$ERROR: invalid xpa client handle\n"); + } + return(-1); + } + oldmode = xpa->client_mode; + } + + /* flag that we don't read from stdin */ + xpa->ifd = -1; + + /* zero out the return buffers */ + if( names != NULL ) + memset((char *)names, 0, ABS(n)*sizeof(char *)); + if( messages != NULL ) + memset((char *)messages, 0, ABS(n)*sizeof(char *)); + + /* connect to clients and grab data */ + if( XPAClientConnect(xpa, mode, xtemplate, type) >0 ){ + /* retrieve data from n active clients */ + for(client=xpa->clienthead; client!=NULL; ){ + tclient = client->next; + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (got<ABS(n)) ){ + if( names != NULL ){ + snprintf(tbuf, SZ_LINE, "%s:%s %s", + client->xclass, client->name, client->method); + names[got] = xstrdup(tbuf); + } + if( XPAClientStart(xpa, client, paramlist, mode) >= 0 ){ + XPAClientDataSent(xpa, client); + s = XPAClientEnd(xpa, client); + if( (messages != NULL) && (messages[got] == NULL) ) + messages[got] = xstrdup(s); + } + else{ + if( (messages != NULL) && (messages[got] == NULL) ) + messages[got] = xstrdup(errbuf); + } + got++; + } + client = tclient; + } + } + /* look for clients who timed out */ + for(i=0, client=xpa->clienthead; client!=NULL; client=client->next){ + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (i<ABS(n)) ){ + i++; + if( (client->status == XPA_CLIENT_PROCESSING) && ( messages != NULL) ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server callback (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + messages[i] = xstrdup(errbuf); + } + } + } + /* remove this xpa if we are not meant to persist */ + if( xpa && !xpa->persist ) + XPAClose(xpa); + /* restore xpa mode -- this call might override */ + else + xpa->client_mode = oldmode; + + /* return number of clients processes (including errors) */ + return(got); +} + +/* + *---------------------------------------------------------------------------- + * + * Routine: XPAAccess + * + * Purpose: determine if XPA access point is available + * + * Returns: 0 for success, -1 for failure + * + *---------------------------------------------------------------------------- + */ +#ifdef ANSI_FUNC +int +XPAAccess (XPA xpa, char *xtemplate, char *paramlist, char *mode, + char **names, char **messages, int n) +#else +int XPAAccess(xpa, xtemplate, paramlist, mode, names, messages, n) + XPA xpa; + char *xtemplate; + char *paramlist; + char *mode; + char **names; + char **messages; + int n; +#endif +{ + int i; + int oldmode=0; + int xmode=0; + int got=0; + int type='a'; + char *s; + char *ind1, *ind2; + char tbuf[SZ_LINE]; + XPAClient client, tclient; + + /* if not persistent, we need a temp xpa struct; + (also ignore passed struct if its not a client struct) */ + if( (xpa == NULL) || strcmp(xpa->type, "c") ){ + if( (xpa = XPAOpen(NULL)) == NULL ) + return(-1); + /* mark this as not persistent */ + xpa->persist = 0; + } + /* save xpa mode -- this call might override */ + else{ + /* make sure we have a valid client handle */ + if( !XPAClientValid(xpa) ){ + if( XPAVerbosity() ){ + fprintf(stderr, "XPA$ERROR: invalid xpa client handle\n"); + } + return(-1); + } + oldmode = xpa->client_mode; + } + + /* flag that we don't read from stdin */ + xpa->ifd = -1; + + /* zero out the return buffers */ + if( names != NULL ) + memset((char *)names, 0, ABS(n)*sizeof(char *)); + if( messages != NULL ) + memset((char *)messages, 0, ABS(n)*sizeof(char *)); + + /* connect to clients and grab data */ + if( XPAClientConnect(xpa, mode, xtemplate, type) >0 ){ + /* retrieve data from n active clients */ + for(client=xpa->clienthead; client!=NULL; ){ + tclient = client->next; + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (got<ABS(n)) ){ + if( names != NULL ){ + snprintf(tbuf, SZ_LINE, "%s:%s %s", + client->xclass, client->name, client->method); + names[got] = xstrdup(tbuf); + } + if( XPAClientStart(xpa, client, paramlist, mode) >=0 ){ + XPAClientDataSent(xpa, client); + s = XPAClientEnd(xpa, client); + if( (messages != NULL) && (messages[got] == NULL) ) + messages[got] = xstrdup(s); + } + else{ + if( (messages != NULL) && (messages[got] == NULL) ) + messages[got] = xstrdup(errbuf); + } + /* might have to fix the name if was an explicit mach:port */ + if( names && names[got] && *errbuf && + !strncmp(names[got], "?:?", 3) && + (ind1=strrchr(errbuf, '(')) && (ind2=strrchr(errbuf, ')')) ){ + ind1++; + strncpy(tbuf, ind1, ind2-ind1); + tbuf[ind2-ind1] = '\0'; + xfree(names[got]); + names[got] = xstrdup(tbuf); + } + got++; + } + client = tclient; + } + /* if we have active clients */ + if( got ){ + /* check for loop modes */ + XPAMode(mode, &xmode, "doxpa", XPA_CLIENT_SEL_XPA, 1); + /* enter the main loop and process */ + XPAClientLoop(xpa, xmode); + } + } + /* look for clients who timed out */ + for(i=0, client=xpa->clienthead; client!=NULL; client=client->next){ + if( (client->type == type) && (client->status != XPA_CLIENT_IDLE) && + (i<ABS(n)) ){ + i++; + if( (client->status == XPA_CLIENT_PROCESSING) && ( messages != NULL) ){ + snprintf(errbuf, SZ_LINE, + "XPA$ERROR: no response from server callback (%s:%s%s)\n", + client->xclass, client->name, XPATimestamp()); + messages[i] = xstrdup(errbuf); + } + } + } + /* remove this xpa if we are not meant to persist */ + if( xpa && !xpa->persist ) + XPAClose(xpa); + /* restore xpa mode -- this call might override */ + else + xpa->client_mode = oldmode; + + /* return number of clients processes (including errors) */ + return(got); +} + |