X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=blobdiff_plain;f=comstack%2Ftcpip.c;h=667accf49360959eea4e9ba7834ee46e04e205a1;hp=6c684adc74d90f421786cd668ee44790c3945ccd;hb=3a14421799597d61196e2bb07bdd83396000cb45;hpb=832b2543074a15413097abfc0d9b7aca2c301b68 diff --git a/comstack/tcpip.c b/comstack/tcpip.c index 6c684ad..667accf 100644 --- a/comstack/tcpip.c +++ b/comstack/tcpip.c @@ -1,10 +1,81 @@ /* - * Copyright (c) 1995, Index Data + * Copyright (c) 1995-1998, Index Data * See the file LICENSE for details. * Sebastian Hammer, Adam Dickmeiss * * $Log: tcpip.c,v $ - * Revision 1.2 1995-06-15 12:30:06 quinn + * Revision 1.25 1998-07-07 15:49:23 adam + * Added braces to avoid warning. + * + * Revision 1.24 1998/06/29 07:59:17 adam + * Minor fix. + * + * Revision 1.23 1998/06/23 15:37:50 adam + * Added type cast to prevent warning. + * + * Revision 1.22 1998/06/22 11:32:36 adam + * Added 'conditional cs_listen' feature. + * + * Revision 1.21 1998/05/20 09:55:32 adam + * Function tcpip_get treats EINPROGRESS error in the same way as + * EWOULDBLOCK. EINPROGRESS shouldn't be returned - but it is on + * Solaris in some cases. + * + * Revision 1.20 1998/05/18 10:10:40 adam + * Minor change to avoid C++ warning. + * + * Revision 1.19 1998/02/11 11:53:33 adam + * Changed code so that it compiles as C++. + * + * Revision 1.18 1997/09/29 07:15:25 adam + * Changed use of setsockopt to avoid warnings on MSVC. + * + * Revision 1.17 1997/09/17 12:10:30 adam + * YAZ version 1.4. + * + * Revision 1.16 1997/09/01 08:49:14 adam + * New windows NT/95 port using MSV5.0. Minor changes only. + * + * Revision 1.15 1997/05/14 06:53:33 adam + * C++ support. + * + * Revision 1.14 1997/05/01 15:06:32 adam + * Moved WINSOCK init. code to tcpip_init routine. + * + * Revision 1.13 1996/11/01 08:45:18 adam + * Bug fix: used close on MS-Windows. Fixed to closesocket. + * + * Revision 1.12 1996/07/06 19:58:30 quinn + * System headerfiles gathered in yconfig + * + * Revision 1.11 1996/02/23 10:00:39 quinn + * WAIS Work + * + * Revision 1.10 1996/02/20 12:52:11 quinn + * WAIS protocol support. + * + * Revision 1.9 1996/02/10 12:23:11 quinn + * Enablie inetd operations fro TCP/IP stack + * + * Revision 1.8 1995/11/01 13:54:27 quinn + * Minor adjustments + * + * Revision 1.7 1995/10/30 12:41:16 quinn + * Added hostname lookup for server. + * + * Revision 1.6 1995/09/29 17:12:00 quinn + * Smallish + * + * Revision 1.5 1995/09/29 17:01:48 quinn + * More Windows work + * + * Revision 1.4 1995/09/28 10:12:26 quinn + * Windows-support changes + * + * Revision 1.3 1995/09/27 15:02:45 quinn + * Modified function heads & prototypes. + * + * Revision 1.2 1995/06/15 12:30:06 quinn * Added @ as hostname alias for INADDR ANY. * * Revision 1.1 1995/06/14 09:58:20 quinn @@ -79,13 +150,18 @@ #include #include #include +#ifndef WINDOWS #include +#endif #include #include #include #include -#include + +/* Chas added the following 2, so we get the definition of completeBER */ +#include +#include int tcpip_close(COMSTACK h); int tcpip_put(COMSTACK h, char *buf, int size); @@ -94,11 +170,23 @@ int tcpip_connect(COMSTACK h, void *address); int tcpip_more(COMSTACK h); int tcpip_rcvconnect(COMSTACK h); int tcpip_bind(COMSTACK h, void *address, int mode); -int tcpip_listen(COMSTACK h, char *addrp, int *addrlen); +int tcpip_listen(COMSTACK h, char *raddr, int *addrlen, + int (*check_ip)(void *cd, const char *a, int len, int type), + void *cd); + COMSTACK tcpip_accept(COMSTACK h); +char *tcpip_addrstr(COMSTACK h); +void *tcpip_straddr(COMSTACK h, const char *str); -int completeBER(unsigned char *buf, int len); +/* + * Determine length/completeness of incoming packages + */ +/* Chas: Removed the definition of completeBERfrom here, use the one in the */ +/* include directory as that as the extern "C" around it */ +/*int completeBER(unsigned char *buf, int len); */ /* from the ODR module */ +int completeWAIS(unsigned char *buf, int len); /* from waislen.c */ +#undef TRACE_TCPIP #ifdef TRACE_TCPIP #define TRC(x) x #else @@ -108,34 +196,85 @@ int completeBER(unsigned char *buf, int len); typedef struct tcpip_state { char *altbuf; /* alternate buffer for surplus data */ - int altsize; /* size as malloced */ + int altsize; /* size as xmalloced */ int altlen; /* length of data or 0 if none */ int written; /* -1 if we aren't writing */ int towrite; /* to verify against user input */ + int (*complete)(unsigned char *buf, int len); /* length/completeness */ + struct sockaddr_in addr; /* returned by cs_straddr */ + char buf[128]; /* returned by cs_addrstr */ } tcpip_state; -COMSTACK tcpip_type(int blocking, int protocol) +#ifdef WINDOWS +static int tcpip_init (void) +{ + static int initialized = 0; + if (!initialized) + { + WORD requested; + WSADATA wd; + + requested = MAKEWORD(1, 1); + if (WSAStartup(requested, &wd)) + return 0; + initialized = 1; + } + return 1; +} +#else +static int tcpip_init (void) +{ + return 1; +} +#endif +/* + * This function is always called through the cs_create() macro. + * s >= 0: socket has already been established for us. + */ +COMSTACK tcpip_type(int s, int blocking, int protocol) { COMSTACK p; - struct protoent *proto; tcpip_state *state; - int s; - - if (!(proto = getprotobyname("tcp"))) - return 0; - if ((s = socket(AF_INET, SOCK_STREAM, proto->p_proto)) < 0) - return 0; - if (!(p = malloc(sizeof(struct comstack)))) - return 0; - if (!(state = p->private = malloc(sizeof(tcpip_state)))) - return 0; + int new_socket; +#ifdef WINDOWS + unsigned long tru = 1; +#else + struct protoent *proto; +#endif + + if (!tcpip_init ()) + return 0; + if (s < 0) + { +#ifndef WINDOWS + if (!(proto = getprotobyname("tcp"))) + return 0; + if ((s = socket(AF_INET, SOCK_STREAM, proto->p_proto)) < 0) +#else + if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) +#endif + return 0; + new_socket = 1; + } + else + new_socket = 0; + if (!(p = (struct comstack *)xmalloc(sizeof(struct comstack)))) + return 0; + if (!(state = (struct tcpip_state *)(p->cprivate = + xmalloc(sizeof(tcpip_state))))) + return 0; + +#ifdef WINDOWS + if (!(p->blocking = blocking) && ioctlsocket(s, FIONBIO, &tru) < 0) +#else if (!(p->blocking = blocking) && fcntl(s, F_SETFL, O_NONBLOCK) < 0) - return 0; +#endif + return 0; p->iofile = s; p->type = tcpip_type; - p->protocol = protocol; + p->protocol = (enum oid_proto) protocol; p->f_connect = tcpip_connect; p->f_rcvconnect = tcpip_rcvconnect; @@ -146,15 +285,21 @@ COMSTACK tcpip_type(int blocking, int protocol) p->f_bind = tcpip_bind; p->f_listen = tcpip_listen; p->f_accept = tcpip_accept; + p->f_addrstr = tcpip_addrstr; + p->f_straddr = tcpip_straddr; - p->state = CS_UNBND; + p->state = new_socket ? CS_UNBND : CS_IDLE; /* state of line */ p->event = CS_NONE; - p->errno = 0; + p->cerrno = 0; p->stackerr = 0; state->altbuf = 0; state->altsize = state->altlen = 0; state->towrite = state->written = -1; + if (protocol == PROTO_WAIS) + state->complete = completeWAIS; + else + state->complete = completeBER; p->timeout = COMSTACK_DEFAULT_TIMEOUT; TRC(fprintf(stderr, "Created new TCPIP comstack\n")); @@ -162,55 +307,81 @@ COMSTACK tcpip_type(int blocking, int protocol) return p; } -struct sockaddr_in *tcpip_strtoaddr(const char *str) +static int tcpip_strtoaddr_ex(const char *str, struct sockaddr_in *add) { - static struct sockaddr_in add; struct hostent *hp; char *p, buf[512]; short int port = 210; unsigned tmpadd; + if (!tcpip_init ()) + return 0; TRC(fprintf(stderr, "tcpip_strtoaddress: %s\n", str ? str : "NULL")); - add.sin_family = AF_INET; + add->sin_family = AF_INET; strcpy(buf, str); if ((p = strchr(buf, ':'))) { - *p = 0; - port = atoi(p + 1); + *p = 0; + port = atoi(p + 1); } - add.sin_port = htons(port); + add->sin_port = htons(port); if (!strcmp("@", buf)) - add.sin_addr.s_addr = INADDR_ANY; + add->sin_addr.s_addr = INADDR_ANY; else if ((hp = gethostbyname(buf))) - memcpy(&add.sin_addr.s_addr, *hp->h_addr_list, sizeof(struct in_addr)); + memcpy(&add->sin_addr.s_addr, *hp->h_addr_list, + sizeof(struct in_addr)); else if ((tmpadd = (unsigned) inet_addr(buf)) != 0) - memcpy(&add.sin_addr.s_addr, &tmpadd, sizeof(struct in_addr)); + memcpy(&add->sin_addr.s_addr, &tmpadd, sizeof(struct in_addr)); else - return 0; + return 0; + return 1; +} + +void *tcpip_straddr(COMSTACK h, const char *str) +{ + tcpip_state *sp = (tcpip_state *)h->cprivate; + + if (!tcpip_strtoaddr_ex (str, &sp->addr)) + return 0; + return &sp->addr; +} + +struct sockaddr_in *tcpip_strtoaddr(const char *str) +{ + static struct sockaddr_in add; + + if (!tcpip_strtoaddr_ex (str, &add)) + return 0; return &add; } int tcpip_more(COMSTACK h) { - tcpip_state *sp = h->private; - - return sp->altlen && completeBER((unsigned char *) sp->altbuf, sp->altlen); + tcpip_state *sp = (tcpip_state *)h->cprivate; + + return sp->altlen && (*sp->complete)((unsigned char *) sp->altbuf, + sp->altlen); } /* - * connect(2) will block - nothing we can do short of doing weird things - * like spawning subprocesses or threading or some weird junk like that. + * connect(2) will block (sometimes) - nothing we can do short of doing + * weird things like spawning subprocesses or threading or some weird junk + * like that. */ int tcpip_connect(COMSTACK h, void *address) { - struct sockaddr_in *add = address; + struct sockaddr_in *add = (struct sockaddr_in *)address; TRC(fprintf(stderr, "tcpip_connect\n")); if (connect(h->iofile, (struct sockaddr *) add, sizeof(*add)) < 0) { - if (errno == EINPROGRESS) - return 1; - return -1; +#ifdef WINDOWS + if (WSAGetLastError() == WSAEWOULDBLOCK) +#else + if (errno == EINPROGRESS) +#endif + return 1; + return -1; } h->state = CS_DATAXFER; return 0; @@ -227,87 +398,131 @@ int tcpip_rcvconnect(COMSTACK h) int tcpip_bind(COMSTACK h, void *address, int mode) { - struct sockaddr *addr = address; - int one = 1; + struct sockaddr *addr = (struct sockaddr *)address; +#ifdef WINDOWS + BOOL one = 1; +#else + unsigned long one = 1; +#endif TRC(fprintf(stderr, "tcpip_bind\n")); - if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) + if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, (char*) + &one, sizeof(one)) < 0) { - h->errno = CSYSERR; - return -1; + h->cerrno = CSYSERR; + return -1; } if (bind(h->iofile, addr, sizeof(struct sockaddr_in)) < 0) { - h->errno = CSYSERR; - return -1; + h->cerrno = CSYSERR; + return -1; } if (mode == CS_SERVER && listen(h->iofile, 3) < 0) { - h->errno = CSYSERR; - return -1; + h->cerrno = CSYSERR; + return -1; } h->state = CS_IDLE; return 0; } -int tcpip_listen(COMSTACK h, char *raddr, int *addrlen) +#if 0 +void tcpip_get_ip(COMSTACK h, char *ip_buf) +{ + struct tcpip_state *sp = (tcpip_state *)h->cprivate; + const char *ip_addr = (const char *) (&sp->addr->sin_addr.s_addr); + int i; + + for (i = 0; i<4; i++) + TRC (fprintf (stderr, "%u ", ip_addr[i])); + TRC (fprintf (stderr, "\n")); +} +#endif + +int tcpip_listen(COMSTACK h, char *raddr, int *addrlen, + int (*check_ip)(void *cd, const char *a, int len, int type), + void *cd) { struct sockaddr_in addr; int len = sizeof(addr); - TRC(fprintf(stderr, "tcpip_listen\n")); + TRC(fprintf(stderr, "tcpip_listen pid=%d\n", getpid())); if (h->state != CS_IDLE) { - h->errno = CSOUTSTATE; - return -1; + h->cerrno = CSOUTSTATE; + return -1; } if ((h->newfd = accept(h->iofile, (struct sockaddr*)&addr, &len)) < 0) { - if (errno == EWOULDBLOCK) - h->errno = CSNODATA; - else - h->errno = CSYSERR; - return -1; +#ifdef WINDOWS + if (WSAGetLastError() == WSAEWOULDBLOCK) +#else + if (errno == EWOULDBLOCK) +#endif + + h->cerrno = CSNODATA; + else + h->cerrno = CSYSERR; + return -1; } - if (addrlen && *addrlen > sizeof(struct sockaddr_in)) - memcpy(raddr, &addr, *addrlen = sizeof(struct sockaddr_in)); + if (addrlen && *addrlen >= sizeof(struct sockaddr_in)) + memcpy(raddr, &addr, *addrlen = sizeof(struct sockaddr_in)); else if (addrlen) - *addrlen = 0; + *addrlen = 0; + if (check_ip && (*check_ip)(cd, (const char *) &addr.sin_addr, + sizeof(addr.sin_addr), AF_INET)) + { + h->cerrno = CSDENY; +#ifdef WINDOWS + closesocket(h->iofile); +#else + close(h->iofile); +#endif + return -1; + } h->state = CS_INCON; return 0; } COMSTACK tcpip_accept(COMSTACK h) { - COMSTACK new; - tcpip_state *state; + COMSTACK cnew; + tcpip_state *state, *st = (tcpip_state *)h->cprivate; +#ifdef WINDOWS + unsigned long tru = 1; +#endif TRC(fprintf(stderr, "tcpip_accept\n")); if (h->state != CS_INCON) { - h->errno = CSOUTSTATE; - return 0; + h->cerrno = CSOUTSTATE; + return 0; } - if (!(new = malloc(sizeof(*new)))) + if (!(cnew = (COMSTACK)xmalloc(sizeof(*cnew)))) { - h->errno = CSYSERR; - return 0; + h->cerrno = CSYSERR; + return 0; } - memcpy(new, h, sizeof(*h)); - new->iofile = h->newfd; - if (!(state = new->private = malloc(sizeof(tcpip_state)))) + memcpy(cnew, h, sizeof(*h)); + cnew->iofile = h->newfd; + if (!(state = (tcpip_state *)(cnew->cprivate = xmalloc(sizeof(tcpip_state))))) { - h->errno = CSYSERR; - return 0; + h->cerrno = CSYSERR; + return 0; } - if (!new->blocking && fcntl(new->iofile, F_SETFL, O_NONBLOCK) < 0) - return 0; +#ifdef WINDOWS + if (!cnew->blocking && ioctlsocket(cnew->iofile, FIONBIO, &tru) < 0) +#else + if (!cnew->blocking && fcntl(cnew->iofile, F_SETFL, O_NONBLOCK) < 0) +#endif + return 0; state->altbuf = 0; state->altsize = state->altlen = 0; state->towrite = state->written = -1; - new->state = CS_DATAXFER; + state->complete = st->complete; + cnew->state = CS_DATAXFER; h->state = CS_IDLE; - return new; + return cnew; } #define CS_TCPIP_BUFCHUNK 4096 @@ -318,7 +533,7 @@ COMSTACK tcpip_accept(COMSTACK h) */ int tcpip_get(COMSTACK h, char **buf, int *bufsize) { - tcpip_state *sp = h->private; + tcpip_state *sp = (tcpip_state *)h->cprivate; char *tmpc; int tmpi, berlen, rest, req, tomove; int hasread = 0, res; @@ -326,59 +541,69 @@ int tcpip_get(COMSTACK h, char **buf, int *bufsize) TRC(fprintf(stderr, "tcpip_get: bufsize=%d\n", *bufsize)); if (sp->altlen) /* switch buffers */ { - TRC(fprintf(stderr, " %d bytes in altbuf (0x%x)\n", sp->altlen, - (unsigned) sp->altbuf)); - tmpc = *buf; - tmpi = *bufsize; - *buf = sp->altbuf; - *bufsize = sp->altsize; - hasread = sp->altlen; - sp->altlen = 0; - sp->altbuf = tmpc; - sp->altsize = tmpi; + TRC(fprintf(stderr, " %d bytes in altbuf (0x%x)\n", sp->altlen, + (unsigned) sp->altbuf)); + tmpc = *buf; + tmpi = *bufsize; + *buf = sp->altbuf; + *bufsize = sp->altsize; + hasread = sp->altlen; + sp->altlen = 0; + sp->altbuf = tmpc; + sp->altsize = tmpi; } - while (!(berlen = completeBER((unsigned char *)*buf, hasread))) + while (!(berlen = (*sp->complete)((unsigned char *)*buf, hasread))) { - if (!*bufsize) - { - if (!(*buf = malloc(*bufsize = CS_TCPIP_BUFCHUNK))) - return -1; + if (!*bufsize) + { + if (!(*buf = (char *)xmalloc(*bufsize = CS_TCPIP_BUFCHUNK))) + return -1; + } + else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK) + if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2))) + return -1; + if ((res = recv(h->iofile, *buf + hasread, CS_TCPIP_BUFCHUNK, 0)) < 0) + { +#ifdef WINDOWS + if (WSAGetLastError() == WSAEWOULDBLOCK) +#else +#ifdef EINPROGRESS + if (errno == EINPROGRESS || errno == EWOULDBLOCK) +#else + if (errno == EWOULDBLOCK) +#endif +#endif + break; + else + return -1; } - else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK) - if (!(*buf = realloc(*buf, *bufsize *= 2))) - return -1; - if ((res = read(h->iofile, *buf + hasread, CS_TCPIP_BUFCHUNK)) < 0) - if (errno == EWOULDBLOCK) - break; - else - return -1; - if (!res) - return 0; - hasread += res; - TRC(fprintf(stderr, " res=%d, hasread=%d\n", res, hasread)); + if (!res) + return 0; + hasread += res; + TRC(fprintf(stderr, " res=%d, hasread=%d\n", res, hasread)); } TRC(fprintf(stderr, " Out of read loop with hasread=%d, berlen=%d\n", - hasread, berlen)); + hasread, berlen)); /* move surplus buffer (or everything if we didn't get a BER rec.) */ if (hasread > berlen) { - tomove = req = hasread - berlen; - rest = tomove % CS_TCPIP_BUFCHUNK; - if (rest) - req += CS_TCPIP_BUFCHUNK - rest; - if (!sp->altbuf) - { - if (!(sp->altbuf = malloc(sp->altsize = req))) - return -1; - } else if (sp->altsize < req) - if (!(sp->altbuf = realloc(sp->altbuf, sp->altsize = req))) - return -1; - TRC(fprintf(stderr, " Moving %d bytes to altbuf(0x%x)\n", tomove, - (unsigned) sp->altbuf)); - memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove); + tomove = req = hasread - berlen; + rest = tomove % CS_TCPIP_BUFCHUNK; + if (rest) + req += CS_TCPIP_BUFCHUNK - rest; + if (!sp->altbuf) + { + if (!(sp->altbuf = (char *)xmalloc(sp->altsize = req))) + return -1; + } else if (sp->altsize < req) + if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req))) + return -1; + TRC(fprintf(stderr, " Moving %d bytes to altbuf(0x%x)\n", tomove, + (unsigned) sp->altbuf)); + memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove); } if (berlen < CS_TCPIP_BUFCHUNK - 1) - *(*buf + berlen) = '\0'; + *(*buf + berlen) = '\0'; return berlen ? berlen : 1; } @@ -390,35 +615,39 @@ int tcpip_get(COMSTACK h, char **buf, int *bufsize) int tcpip_put(COMSTACK h, char *buf, int size) { int res; - struct tcpip_state *state = h->private; + struct tcpip_state *state = (struct tcpip_state *)h->cprivate; TRC(fprintf(stderr, "tcpip_put: size=%d\n", size)); if (state->towrite < 0) { - state->towrite = size; - state->written = 0; + state->towrite = size; + state->written = 0; } else if (state->towrite != size) { - h->errno = CSWRONGBUF; - return -1; + h->cerrno = CSWRONGBUF; + return -1; } while (state->towrite > state->written) { - if ((res = write(h->iofile, buf + state->written, size - - state->written)) < 0) - { - if (errno == EAGAIN) - { - TRC(fprintf(stderr, " Flow control stop\n")); - return 1; - } - h->errno = CSYSERR; - return -1; - } - state->written += res; - TRC(fprintf(stderr, " Wrote %d, written=%d, nbytes=%d\n", - res, state->written, size)); + if ((res = send(h->iofile, buf + state->written, size - + state->written, 0)) < 0) + { +#ifdef WINDOWS + if (WSAGetLastError() == WSAEWOULDBLOCK) +#else + if (errno == EAGAIN) +#endif + { + TRC(fprintf(stderr, " Flow control stop\n")); + return 1; + } + h->cerrno = CSYSERR; + return -1; + } + state->written += res; + TRC(fprintf(stderr, " Wrote %d, written=%d, nbytes=%d\n", + res, state->written, size)); } state->towrite = state->written = -1; TRC(fprintf(stderr, " Ok\n")); @@ -427,13 +656,41 @@ int tcpip_put(COMSTACK h, char *buf, int size) int tcpip_close(COMSTACK h) { - tcpip_state *sp = h->private; + tcpip_state *sp = (struct tcpip_state *)h->cprivate; TRC(fprintf(stderr, "tcpip_close\n")); - close(h->iofile); + if (h->iofile != -1) +#ifdef WINDOWS + closesocket(h->iofile); +#else + close(h->iofile); +#endif if (sp->altbuf) - free(sp->altbuf); - free(sp); - free(h); + xfree(sp->altbuf); + xfree(sp); + xfree(h); return 0; } + +char *tcpip_addrstr(COMSTACK h) +{ + struct sockaddr_in addr; + tcpip_state *sp = (struct tcpip_state *)h->cprivate; + char *r, *buf = sp->buf; + int len; + struct hostent *host; + + len = sizeof(addr); + if (getpeername(h->iofile, (struct sockaddr*) &addr, &len) < 0) + { + h->cerrno = CSYSERR; + return 0; + } + if ((host = gethostbyaddr((char*)&addr.sin_addr, sizeof(addr.sin_addr), + AF_INET))) + r = (char*) host->h_name; + else + r = inet_ntoa(addr.sin_addr); + sprintf(buf, "tcp:%s", r); + return buf; +}