comstack/tcpip.c

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