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