comstack/tcpip.c

   1 /*
   2  * Copyright (c) 1995-1997, Index Data
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: tcpip.c,v $
   7  * Revision 1.19  1998-02-11 11:53:33  adam
   8  * Changed code so that it compiles as C++.
   9  *
  10  * Revision 1.18  1997/09/29 07:15:25  adam
  11  * Changed use of setsockopt to avoid warnings on MSVC.
  12  *
  13  * Revision 1.17  1997/09/17 12:10:30  adam
  14  * YAZ version 1.4.
  15  *
  16  * Revision 1.16  1997/09/01 08:49:14  adam
  17  * New windows NT/95 port using MSV5.0. Minor changes only.
  18  *
  19  * Revision 1.15  1997/05/14 06:53:33  adam
  20  * C++ support.
  21  *
  22  * Revision 1.14  1997/05/01 15:06:32  adam
  23  * Moved WINSOCK init. code to tcpip_init routine.
  24  *
  25  * Revision 1.13  1996/11/01 08:45:18  adam
  26  * Bug fix: used close on MS-Windows. Fixed to closesocket.
  27  *
  28  * Revision 1.12  1996/07/06 19:58:30  quinn
  29  * System headerfiles gathered in yconfig
  30  *
  31  * Revision 1.11  1996/02/23  10:00:39  quinn
  32  * WAIS Work
  33  *
  34  * Revision 1.10  1996/02/20  12:52:11  quinn
  35  * WAIS protocol support.
  36  *
  37  * Revision 1.9  1996/02/10  12:23:11  quinn
  38  * Enablie inetd operations fro TCP/IP stack
  39  *
  40  * Revision 1.8  1995/11/01  13:54:27  quinn
  41  * Minor adjustments
  42  *
  43  * Revision 1.7  1995/10/30  12:41:16  quinn
  44  * Added hostname lookup for server.
  45  *
  46  * Revision 1.6  1995/09/29  17:12:00  quinn
  47  * Smallish
  48  *
  49  * Revision 1.5  1995/09/29  17:01:48  quinn
  50  * More Windows work
  51  *
  52  * Revision 1.4  1995/09/28  10:12:26  quinn
  53  * Windows-support changes
  54  *
  55  * Revision 1.3  1995/09/27  15:02:45  quinn
  56  * Modified function heads & prototypes.
  57  *
  58  * Revision 1.2  1995/06/15  12:30:06  quinn
  59  * Added @ as hostname alias for INADDR ANY.
  60  *
  61  * Revision 1.1  1995/06/14  09:58:20  quinn
  62  * Renamed yazlib to comstack.
  63  *
  64  * Revision 1.20  1995/05/16  08:51:16  quinn
  65  * License, documentation, and memory fixes
  66  *
  67  * Revision 1.19  1995/04/10  10:24:08  quinn
  68  * Some bug-fixes.
  69  *
  70  * Revision 1.18  1995/03/30  13:29:27  quinn
  71  * Added REUSEADDR in tcpip_bind
  72  *
  73  * Revision 1.17  1995/03/27  08:36:10  quinn
  74  * Some work on nonblocking operation in xmosi.c and rfct.c.
  75  * Added protocol parameter to cs_create()
  76  *
  77  * Revision 1.16  1995/03/21  15:53:41  quinn
  78  * Added rcvconnect
  79  *
  80  * Revision 1.15  1995/03/21  12:31:27  quinn
  81  * Added check for EINPROGRESS on connect.
  82  *
  83  * Revision 1.14  1995/03/20  09:47:21  quinn
  84  * Added server-side support to xmosi.c
  85  * Fixed possible problems in rfct
  86  * Other little mods
  87  *
  88  * Revision 1.13  1995/03/15  16:15:13  adam
  89  * Removed p_write.
  90  *
  91  * Revision 1.12  1995/03/15  15:36:27  quinn
  92  * Mods to support nonblocking I/O
  93  *
  94  * Revision 1.11  1995/03/15  08:37:57  quinn
  95  * Now we're pretty much set for nonblocking I/O.
  96  *
  97  * Revision 1.10  1995/03/14  17:00:07  quinn
  98  * Bug-fixes - added tracing info to tcpip.c
  99  *
 100  * Revision 1.9  1995/03/14  10:28:42  quinn
 101  * Adding server-side support to tcpip.c and fixing bugs in nonblocking I/O
 102  *
 103  * Revision 1.8  1995/03/10  14:22:50  quinn
 104  * Removed debug output.
 105  *
 106  * Revision 1.7  1995/03/10  11:44:59  quinn
 107  * Fixes and debugging
 108  *
 109  * Revision 1.6  1995/03/07  10:26:55  quinn
 110  * Initialized type field in the comstacks.
 111  *
 112  * Revision 1.5  1995/02/14  20:40:07  quinn
 113  * Various stuff.
 114  *
 115  * Revision 1.4  1995/02/14  11:54:49  quinn
 116  * Beginning to add full CCL.
 117  *
 118  * Revision 1.3  1995/02/10  18:58:10  quinn
 119  * Fixed tcpip_get (formerly tcpip_read).
 120  * Turned tst (cli) into a proper, event-driven thingy.
 121  *
 122  * Revision 1.2  1995/02/10  15:55:47  quinn
 123  * Small things.
 124  *
 125  * Revision 1.1  1995/02/09  15:51:52  quinn
 126  * Works better now.
 127  *
 128  */
 129
 130 #include <stdio.h>
 131 #include <string.h>
 132 #include <stdlib.h>
 133 #ifndef WINDOWS
 134 #include <unistd.h>
 135 #endif
 136 #include <errno.h>
 137 #include <fcntl.h>
 138
 139 #include <comstack.h>
 140 #include <tcpip.h>
 141
 142 /* Chas added the following 2, so we get the definition of completeBER */
 143 #include <odr.h>
 144 #include <prt.h>
 145
 146 int tcpip_close(COMSTACK h);
 147 int tcpip_put(COMSTACK h, char *buf, int size);
 148 int tcpip_get(COMSTACK h, char **buf, int *bufsize);
 149 int tcpip_connect(COMSTACK h, void *address);
 150 int tcpip_more(COMSTACK h);
 151 int tcpip_rcvconnect(COMSTACK h);
 152 int tcpip_bind(COMSTACK h, void *address, int mode);
 153 int tcpip_listen(COMSTACK h, char *addrp, int *addrlen);
 154 COMSTACK tcpip_accept(COMSTACK h);
 155 char *tcpip_addrstr(COMSTACK h);
 156 void *tcpip_straddr(COMSTACK h, const char *str);
 157
 158 /*
 159  * Determine length/completeness of incoming packages
 160  */
 161 /* Chas: Removed the definition of completeBERfrom here, use the one in the */
 162 /* include directory as that as the extern "C" around it */
 163 /*int completeBER(unsigned char *buf, int len); */ /* from the ODR module */
 164 int completeWAIS(unsigned char *buf, int len); /* from waislen.c */
 165
 166 #ifdef TRACE_TCPIP
 167 #define TRC(x) x
 168 #else
 169 #define TRC(X)
 170 #endif
 171
 172 typedef struct tcpip_state
 173 {
 174     char *altbuf; /* alternate buffer for surplus data */
 175     int altsize;  /* size as xmalloced */
 176     int altlen;   /* length of data or 0 if none */
 177
 178     int written;  /* -1 if we aren't writing */
 179     int towrite;  /* to verify against user input */
 180     int (*complete)(unsigned char *buf, int len); /* length/completeness */
 181     struct sockaddr_in addr;  /* returned by cs_straddr */
 182     char buf[128]; /* returned by cs_addrstr */
 183 } tcpip_state;
 184
 185 #ifdef WINDOWS
 186 static int tcpip_init (void)
 187 {
 188     static int initialized = 0;
 189     if (!initialized)
 190     {
 191         WORD requested;
 192         WSADATA wd;
 193
 194         requested = MAKEWORD(1, 1);
 195         if (WSAStartup(requested, &wd))
 196             return 0;
 197         initialized = 1;
 198     }
 199     return 1;
 200 }
 201 #else
 202 static int tcpip_init (void)
 203 {
 204     return 1;
 205 }
 206 #endif
 207 /*
 208  * This function is always called through the cs_create() macro.
 209  * s >= 0: socket has already been established for us.
 210  */
 211 COMSTACK tcpip_type(int s, int blocking, int protocol)
 212 {
 213     COMSTACK p;
 214     tcpip_state *state;
 215     int new_socket;
 216 #ifdef WINDOWS
 217     unsigned long tru = 1;
 218 #else
 219     struct protoent *proto;
 220 #endif
 221
 222     if (!tcpip_init ())
 223         return 0;
 224     if (s < 0)
 225     {
 226 #ifndef WINDOWS
 227         if (!(proto = getprotobyname("tcp")))
 228             return 0;
 229         if ((s = socket(AF_INET, SOCK_STREAM, proto->p_proto)) < 0)
 230 #else
 231         if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
 232 #endif
 233             return 0;
 234         new_socket = 1;
 235     }
 236     else
 237         new_socket = 0;
 238     if (!(p = (struct comstack *)xmalloc(sizeof(struct comstack))))
 239         return 0;
 240     if (!(state = (struct tcpip_state *)(p->cprivate =
 241                                          xmalloc(sizeof(tcpip_state)))))
 242         return 0;
 243
 244 #ifdef WINDOWS
 245     if (!(p->blocking = blocking) && ioctlsocket(s, FIONBIO, &tru) < 0)
 246 #else
 247     if (!(p->blocking = blocking) && fcntl(s, F_SETFL, O_NONBLOCK) < 0)
 248 #endif
 249         return 0;
 250
 251     p->iofile = s;
 252     p->type = tcpip_type;
 253     p->protocol = protocol;
 254
 255     p->f_connect = tcpip_connect;
 256     p->f_rcvconnect = tcpip_rcvconnect;
 257     p->f_get = tcpip_get;
 258     p->f_put = tcpip_put;
 259     p->f_close = tcpip_close;
 260     p->f_more = tcpip_more;
 261     p->f_bind = tcpip_bind;
 262     p->f_listen = tcpip_listen;
 263     p->f_accept = tcpip_accept;
 264     p->f_addrstr = tcpip_addrstr;
 265     p->f_straddr = tcpip_straddr;
 266
 267     p->state = new_socket ? CS_UNBND : CS_IDLE; /* state of line */
 268     p->event = CS_NONE;
 269     p->cerrno = 0;
 270     p->stackerr = 0;
 271
 272     state->altbuf = 0;
 273     state->altsize = state->altlen = 0;
 274     state->towrite = state->written = -1;
 275     if (protocol == PROTO_WAIS)
 276         state->complete = completeWAIS;
 277     else
 278         state->complete = completeBER;
 279
 280     p->timeout = COMSTACK_DEFAULT_TIMEOUT;
 281     TRC(fprintf(stderr, "Created new TCPIP comstack\n"));
 282
 283     return p;
 284 }
 285
 286 static int tcpip_strtoaddr_ex(const char *str, struct sockaddr_in *add)
 287 {
 288     struct hostent *hp;
 289     char *p, buf[512];
 290     short int port = 210;
 291     unsigned tmpadd;
 292
 293     if (!tcpip_init ())
 294         return 0;
 295     TRC(fprintf(stderr, "tcpip_strtoaddress: %s\n", str ? str : "NULL"));
 296     add->sin_family = AF_INET;
 297     strcpy(buf, str);
 298     if ((p = strchr(buf, ':')))
 299     {
 300         *p = 0;
 301         port = atoi(p + 1);
 302     }
 303     add->sin_port = htons(port);
 304     if (!strcmp("@", buf))
 305         add->sin_addr.s_addr = INADDR_ANY;
 306     else if ((hp = gethostbyname(buf)))
 307         memcpy(&add->sin_addr.s_addr, *hp->h_addr_list,
 308                sizeof(struct in_addr));
 309     else if ((tmpadd = (unsigned) inet_addr(buf)) != 0)
 310         memcpy(&add->sin_addr.s_addr, &tmpadd, sizeof(struct in_addr));
 311     else
 312         return 0;
 313     return 1;
 314 }
 315
 316 void *tcpip_straddr(COMSTACK h, const char *str)
 317 {
 318     tcpip_state *sp = (tcpip_state *)h->cprivate;
 319
 320     if (!tcpip_strtoaddr_ex (str, &sp->addr))
 321         return 0;
 322     return &sp->addr;
 323 }
 324
 325 struct sockaddr_in *tcpip_strtoaddr(const char *str)
 326 {
 327     static struct sockaddr_in add;
 328
 329     if (!tcpip_strtoaddr_ex (str, &add))
 330         return 0;
 331     return &add;
 332 }
 333
 334 int tcpip_more(COMSTACK h)
 335 {
 336     tcpip_state *sp = (tcpip_state *)h->cprivate;
 337
 338     return sp->altlen && (*sp->complete)((unsigned char *) sp->altbuf,
 339         sp->altlen);
 340 }
 341
 342 /*
 343  * connect(2) will block (sometimes) - nothing we can do short of doing
 344  * weird things like spawning subprocesses or threading or some weird junk
 345  * like that.
 346  */
 347 int tcpip_connect(COMSTACK h, void *address)
 348 {
 349     struct sockaddr_in *add = (struct sockaddr_in *)address;
 350
 351     TRC(fprintf(stderr, "tcpip_connect\n"));
 352     if (connect(h->iofile, (struct sockaddr *) add, sizeof(*add)) < 0)
 353     {
 354 #ifdef WINDOWS
 355         if (WSAGetLastError() == WSAEWOULDBLOCK)
 356 #else
 357         if (errno == EINPROGRESS)
 358 #endif
 359             return 1;
 360         return -1;
 361     }
 362     h->state = CS_DATAXFER;
 363     return 0;
 364 }
 365
 366 /*
 367  * nop
 368  */
 369 int tcpip_rcvconnect(COMSTACK h)
 370 {
 371     TRC(fprintf(stderr, "tcpip_rcvconnect\n"));
 372     return 0;
 373 }
 374
 375 int tcpip_bind(COMSTACK h, void *address, int mode)
 376 {
 377     struct sockaddr *addr = (struct sockaddr *)address;
 378 #ifdef WINDOWS
 379     BOOL one = 1;
 380 #else
 381     unsigned long one = 1;
 382 #endif
 383
 384     TRC(fprintf(stderr, "tcpip_bind\n"));
 385     if (setsockopt(h->iofile, SOL_SOCKET, SO_REUSEADDR, (char*)
 386         &one, sizeof(one)) < 0)
 387     {
 388         h->cerrno = CSYSERR;
 389         return -1;
 390     }
 391     if (bind(h->iofile, addr, sizeof(struct sockaddr_in)) < 0)
 392     {
 393         h->cerrno = CSYSERR;
 394         return -1;
 395     }
 396     if (mode == CS_SERVER && listen(h->iofile, 3) < 0)
 397     {
 398         h->cerrno = CSYSERR;
 399         return -1;
 400     }
 401     h->state = CS_IDLE;
 402     return 0;
 403 }
 404
 405 int tcpip_listen(COMSTACK h, char *raddr, int *addrlen)
 406 {
 407     struct sockaddr_in addr;
 408     int len = sizeof(addr);
 409
 410     TRC(fprintf(stderr, "tcpip_listen\n"));
 411     if (h->state != CS_IDLE)
 412     {
 413         h->cerrno = CSOUTSTATE;
 414         return -1;
 415     }
 416     if ((h->newfd = accept(h->iofile, (struct sockaddr*)&addr, &len)) < 0)
 417     {
 418 #ifdef WINDOWS
 419         if (WSAGetLastError() == WSAEWOULDBLOCK)
 420 #else
 421         if (errno == EWOULDBLOCK)
 422 #endif
 423
 424             h->cerrno = CSNODATA;
 425         else
 426             h->cerrno = CSYSERR;
 427         return -1;
 428     }
 429     if (addrlen && *addrlen > sizeof(struct sockaddr_in))
 430         memcpy(raddr, &addr, *addrlen = sizeof(struct sockaddr_in));
 431     else if (addrlen)
 432         *addrlen = 0;
 433     h->state = CS_INCON;
 434     return 0;
 435 }
 436
 437 COMSTACK tcpip_accept(COMSTACK h)
 438 {
 439     COMSTACK cnew;
 440     tcpip_state *state, *st = (tcpip_state *)h->cprivate;
 441 #ifdef WINDOWS
 442     unsigned long tru = 1;
 443 #endif
 444
 445     TRC(fprintf(stderr, "tcpip_accept\n"));
 446     if (h->state != CS_INCON)
 447     {
 448         h->cerrno = CSOUTSTATE;
 449         return 0;
 450     }
 451     if (!(cnew = (COMSTACK)xmalloc(sizeof(*cnew))))
 452     {
 453         h->cerrno = CSYSERR;
 454         return 0;
 455     }
 456     memcpy(cnew, h, sizeof(*h));
 457     cnew->iofile = h->newfd;
 458     if (!(state = (tcpip_state *)(cnew->cprivate = xmalloc(sizeof(tcpip_state)))))
 459     {
 460         h->cerrno = CSYSERR;
 461         return 0;
 462     }
 463 #ifdef WINDOWS
 464     if (!cnew->blocking && ioctlsocket(cnew->iofile, FIONBIO, &tru) < 0)
 465 #else
 466     if (!cnew->blocking && fcntl(cnew->iofile, F_SETFL, O_NONBLOCK) < 0)
 467 #endif
 468         return 0;
 469     state->altbuf = 0;
 470     state->altsize = state->altlen = 0;
 471     state->towrite = state->written = -1;
 472     state->complete = st->complete;
 473     cnew->state = CS_DATAXFER;
 474     h->state = CS_IDLE;
 475     return cnew;
 476 }
 477
 478 #define CS_TCPIP_BUFCHUNK 4096
 479
 480 /*
 481  * Return: -1 error, >1 good, len of buffer, ==1 incomplete buffer,
 482  * 0=connection closed.
 483  */
 484 int tcpip_get(COMSTACK h, char **buf, int *bufsize)
 485 {
 486     tcpip_state *sp = (tcpip_state *)h->cprivate;
 487     char *tmpc;
 488     int tmpi, berlen, rest, req, tomove;
 489     int hasread = 0, res;
 490
 491     TRC(fprintf(stderr, "tcpip_get: bufsize=%d\n", *bufsize));
 492     if (sp->altlen) /* switch buffers */
 493     {
 494         TRC(fprintf(stderr, "  %d bytes in altbuf (0x%x)\n", sp->altlen,
 495             (unsigned) sp->altbuf));
 496         tmpc = *buf;
 497         tmpi = *bufsize;
 498         *buf = sp->altbuf;
 499         *bufsize = sp->altsize;
 500         hasread = sp->altlen;
 501         sp->altlen = 0;
 502         sp->altbuf = tmpc;
 503         sp->altsize = tmpi;
 504     }
 505     while (!(berlen = (*sp->complete)((unsigned char *)*buf, hasread)))
 506     {
 507         if (!*bufsize)
 508         {
 509             if (!(*buf = (char *)xmalloc(*bufsize = CS_TCPIP_BUFCHUNK)))
 510                 return -1;
 511         }
 512         else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK)
 513             if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
 514                 return -1;
 515         if ((res = recv(h->iofile, *buf + hasread, CS_TCPIP_BUFCHUNK, 0)) < 0)
 516 #ifdef WINDOWS
 517             if (WSAGetLastError() == WSAEWOULDBLOCK)
 518 #else
 519             if (errno == EWOULDBLOCK)
 520 #endif
 521                 break;
 522             else
 523                 return -1;
 524         if (!res)
 525             return 0;
 526         hasread += res;
 527         TRC(fprintf(stderr, "  res=%d, hasread=%d\n", res, hasread));
 528     }
 529     TRC(fprintf(stderr, "  Out of read loop with hasread=%d, berlen=%d\n",
 530         hasread, berlen));
 531     /* move surplus buffer (or everything if we didn't get a BER rec.) */
 532     if (hasread > berlen)
 533     {
 534         tomove = req = hasread - berlen;
 535         rest = tomove % CS_TCPIP_BUFCHUNK;
 536         if (rest)
 537             req += CS_TCPIP_BUFCHUNK - rest;
 538         if (!sp->altbuf)
 539         {
 540             if (!(sp->altbuf = (char *)xmalloc(sp->altsize = req)))
 541                 return -1;
 542         } else if (sp->altsize < req)
 543             if (!(sp->altbuf =(char *)xrealloc(sp->altbuf, sp->altsize = req)))
 544                 return -1;
 545         TRC(fprintf(stderr, "  Moving %d bytes to altbuf(0x%x)\n", tomove,
 546             (unsigned) sp->altbuf));
 547         memcpy(sp->altbuf, *buf + berlen, sp->altlen = tomove);
 548     }
 549     if (berlen < CS_TCPIP_BUFCHUNK - 1)
 550         *(*buf + berlen) = '\0';
 551     return berlen ? berlen : 1;
 552 }
 553
 554 /*
 555  * Returns 1, 0 or -1
 556  * In nonblocking mode, you must call again with same buffer while
 557  * return value is 1.
 558  */
 559 int tcpip_put(COMSTACK h, char *buf, int size)
 560 {
 561     int res;
 562     struct tcpip_state *state = (struct tcpip_state *)h->cprivate;
 563
 564     TRC(fprintf(stderr, "tcpip_put: size=%d\n", size));
 565     if (state->towrite < 0)
 566     {
 567         state->towrite = size;
 568         state->written = 0;
 569     }
 570     else if (state->towrite != size)
 571     {
 572         h->cerrno = CSWRONGBUF;
 573         return -1;
 574     }
 575     while (state->towrite > state->written)
 576     {
 577         if ((res = send(h->iofile, buf + state->written, size -
 578             state->written, 0)) < 0)
 579         {
 580 #ifdef WINDOWS
 581             if (WSAGetLastError() == WSAEWOULDBLOCK)
 582 #else
 583             if (errno == EAGAIN)
 584 #endif
 585             {
 586                 TRC(fprintf(stderr, "  Flow control stop\n"));
 587                 return 1;
 588             }
 589             h->cerrno = CSYSERR;
 590             return -1;
 591         }
 592         state->written += res;
 593         TRC(fprintf(stderr, "  Wrote %d, written=%d, nbytes=%d\n",
 594             res, state->written, size));
 595     }
 596     state->towrite = state->written = -1;
 597     TRC(fprintf(stderr, "  Ok\n"));
 598     return 0;
 599 }
 600
 601 int tcpip_close(COMSTACK h)
 602 {
 603     tcpip_state *sp = (struct tcpip_state *)h->cprivate;
 604
 605     TRC(fprintf(stderr, "tcpip_close\n"));
 606     if (h->iofile != -1)
 607 #ifdef WINDOWS
 608         closesocket(h->iofile);
 609 #else
 610         close(h->iofile);
 611 #endif
 612     if (sp->altbuf)
 613         xfree(sp->altbuf);
 614     xfree(sp);
 615     xfree(h);
 616     return 0;
 617 }
 618
 619 char *tcpip_addrstr(COMSTACK h)
 620 {
 621     struct sockaddr_in addr;
 622     tcpip_state *sp = (struct tcpip_state *)h->cprivate;
 623     char *r, *buf = sp->buf;
 624     int len;
 625     struct hostent *host;
 626
 627     len = sizeof(addr);
 628     if (getpeername(h->iofile, (struct sockaddr*) &addr, &len) < 0)
 629     {
 630         h->cerrno = CSYSERR;
 631         return 0;
 632     }
 633     if ((host = gethostbyaddr((char*)&addr.sin_addr, sizeof(addr.sin_addr),
 634                               AF_INET)))
 635         r = (char*) host->h_name;
 636     else
 637         r = inet_ntoa(addr.sin_addr);
 638     sprintf(buf, "tcp:%s", r);
 639     return buf;
 640 }