git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/bnet.c

   1 /*
   2  * Network Utility Routines
   3  *
   4  *  by Kern Sibbald
   5  *
   6  * Adapted and enhanced for Bacula, originally written
   7  * for inclusion in the Apcupsd package
   8  *
   9  *   Version $Id$
  10  */
  11 /*
  12    Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
  13
  14    This program is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation; either version 2 of
  17    the License, or (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  22    General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public
  25    License along with this program; if not, write to the Free
  26    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  27    MA 02111-1307, USA.
  28
  29  */
  30
  31
  32 #include "bacula.h"
  33
  34 extern time_t watchdog_time;
  35
  36 #ifndef   INADDR_NONE
  37 #define   INADDR_NONE    -1
  38 #endif
  39
  40 #ifndef ENODATA                       /* not defined on BSD systems */
  41 #define ENODATA EPIPE
  42 #endif
  43
  44
  45 /*
  46  * Read a nbytes from the network.
  47  * It is possible that the total bytes require in several
  48  * read requests
  49  */
  50
  51 static int32_t read_nbytes(BSOCK *bsock, char *ptr, int32_t nbytes)
  52 {
  53    int32_t nleft, nread;
  54
  55    nleft = nbytes;
  56    while (nleft > 0) {
  57       do {
  58          errno = 0;
  59          nread = read(bsock->fd, ptr, nleft);
  60       } while (!bsock->timed_out && nread == -1 && (errno == EINTR || errno == EAGAIN));
  61       if (nread <= 0) {
  62          return nread;               /* error, or EOF */
  63       }
  64       nleft -= nread;
  65       ptr += nread;
  66    }
  67    return nbytes - nleft;            /* return >= 0 */
  68 }
  69
  70 /*
  71  * Write nbytes to the network.
  72  * It may require several writes.
  73  */
  74
  75 static int32_t write_nbytes(BSOCK *bsock, char *ptr, int32_t nbytes)
  76 {
  77    int32_t nleft, nwritten;
  78
  79    if (bsock->spool) {
  80       nwritten = fwrite(ptr, 1, nbytes, bsock->spool_fd);
  81       if (nwritten != nbytes) {
  82          Emsg1(M_ERROR, 0, _("Spool write error. ERR=%s\n"), strerror(errno));
  83          Dmsg2(400, "nwritten=%d nbytes=%d.\n", nwritten, nbytes);
  84          return -1;
  85       }
  86       return nbytes;
  87    }
  88    nleft = nbytes;
  89    while (nleft > 0) {
  90       do {
  91          errno = 0;
  92          nwritten = write(bsock->fd, ptr, nleft);
  93       } while (!bsock->timed_out && nwritten == -1 && (errno == EINTR || errno == EAGAIN));
  94       if (nwritten <= 0) {
  95          return nwritten;            /* error */
  96       }
  97       nleft -= nwritten;
  98       ptr += nwritten;
  99    }
 100    return nbytes-nleft;
 101 }
 102
 103 /*
 104  * Receive a message from the other end. Each message consists of
 105  * two packets. The first is a header that contains the size
 106  * of the data that follows in the second packet.
 107  * Returns number of bytes read
 108  * Returns 0 on end of file
 109  * Returns -1 on hard end of file (i.e. network connection close)
 110  * Returns -2 on error
 111  */
 112 /* EXTPROTO */
 113 int32_t
 114 bnet_recv(BSOCK *bsock)
 115 {
 116    int32_t nbytes;
 117    int32_t pktsiz;
 118
 119    if (bsock->errors || bsock->terminated) {
 120       return -2;
 121    }
 122
 123    bsock->read_seqno++;               /* bump sequence number */
 124    bsock->timer_start = watchdog_time;  /* set start wait time */
 125    bsock->timed_out = 0;
 126    /* get data size -- in int32_t */
 127    if ((nbytes = read_nbytes(bsock, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
 128       bsock->timer_start = 0;         /* clear timer */
 129       /* probably pipe broken because client died */
 130       if (errno == 0) {
 131          bsock->b_errno = ENODATA;
 132       } else {
 133          bsock->b_errno = errno;
 134       }
 135       bsock->errors++;
 136       return -1;                      /* assume hard EOF received */
 137    }
 138    bsock->timer_start = 0;            /* clear timer */
 139    if (nbytes != sizeof(int32_t)) {
 140       bsock->errors++;
 141       bsock->b_errno = EIO;
 142       Emsg3(M_ERROR, 0, "Read %d expected %d from %s\n", nbytes, sizeof(int32_t),
 143             bsock->who);
 144       return -2;
 145    }
 146
 147    pktsiz = ntohl(pktsiz);            /* decode no. of bytes that follow */
 148
 149    /* If signal or packet size too big */
 150    if (pktsiz <= 0 || pktsiz > 10000000) {
 151       if (pktsiz == BNET_TERMINATE) {
 152          bsock->terminated = 1;
 153       }
 154       bsock->b_errno = ENODATA;
 155       bsock->msglen = pktsiz;         /* return size */
 156       return 0;                       /* soft EOF */
 157    }
 158
 159    /* Make sure the buffer is big enough + one byte for EOS */
 160    if (pktsiz >= (int32_t)sizeof_pool_memory(bsock->msg)) {
 161       bsock->msg = realloc_pool_memory(bsock->msg, pktsiz + 100);
 162    }
 163
 164    bsock->timer_start = watchdog_time;  /* set start wait time */
 165    bsock->timed_out = 0;
 166    /* now read the actual data */
 167    if ((nbytes = read_nbytes(bsock, bsock->msg, pktsiz)) <=  0) {
 168       bsock->timer_start = 0;         /* clear timer */
 169       if (errno == 0) {
 170          bsock->b_errno = ENODATA;
 171       } else {
 172          bsock->b_errno = errno;
 173       }
 174       bsock->errors++;
 175       Emsg4(M_ERROR, 0, "Read error from %s:%s:%d: ERR=%s\n",
 176             bsock->who, bsock->host, bsock->port, bnet_strerror(bsock));
 177       return -2;
 178    }
 179    bsock->timer_start = 0;            /* clear timer */
 180    bsock->in_msg_no++;
 181    bsock->msglen = nbytes;
 182    if (nbytes != pktsiz) {
 183       bsock->b_errno = EIO;
 184       bsock->errors++;
 185       Emsg5(M_ERROR, 0, "Read expected %d got %d from %s:%s:%d\n", pktsiz, nbytes,
 186             bsock->who, bsock->host, bsock->port);
 187       return -2;
 188    }
 189    /* always add a zero by to properly terminate any
 190     * string that was send to us. Note, we ensured above that the
 191     * buffer is at least one byte longer than the message length.
 192     */
 193    bsock->msg[nbytes] = 0;            /* terminate in case it is a string */
 194    sm_check(__FILE__, __LINE__, False);
 195    return nbytes;                     /* return actual length of message */
 196 }
 197
 198 int bnet_despool(BSOCK *bsock)
 199 {
 200    int32_t pktsiz;
 201    size_t nbytes;
 202
 203    rewind(bsock->spool_fd);
 204    while (fread((char *)&pktsiz, 1, sizeof(int32_t), bsock->spool_fd) == sizeof(int32_t)) {
 205       bsock->msglen = ntohl(pktsiz);
 206       if (bsock->msglen > 0) {
 207          if (bsock->msglen > (int32_t)sizeof_pool_memory(bsock->msg)) {
 208             bsock->msg = realloc_pool_memory(bsock->msg, bsock->msglen);
 209          }
 210          nbytes = fread(bsock->msg, 1, bsock->msglen, bsock->spool_fd);
 211          if (nbytes != (size_t)bsock->msglen) {
 212             Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, bsock->msglen);
 213             Emsg1(M_ERROR, 0, _("fread error. ERR=%s\n"), strerror(errno));
 214             return 0;
 215          }
 216       }
 217       bnet_send(bsock);
 218    }
 219    if (ferror(bsock->spool_fd)) {
 220       Emsg1(M_ERROR, 0, _("fread error. ERR=%s\n"), strerror(errno));
 221       return 0;
 222    }
 223    return 1;
 224 }
 225
 226 /*
 227  * Send a message over the network. The send consists of
 228  * two network packets. The first is sends a 32 bit integer containing
 229  * the length of the data packet which follows.
 230  *
 231  * Returns: 0 on failure
 232  *          1 on success
 233  */
 234 int
 235 bnet_send(BSOCK *bsock)
 236 {
 237    int32_t rc;
 238    int32_t pktsiz;
 239
 240    if (bsock->errors || bsock->terminated) {
 241       return 0;
 242    }
 243    pktsiz = htonl((int32_t)bsock->msglen);
 244    /* send int32_t containing size of data packet */
 245    bsock->timer_start = watchdog_time; /* start timer */
 246    bsock->timed_out = 0;
 247    rc = write_nbytes(bsock, (char *)&pktsiz, sizeof(int32_t));
 248    bsock->timer_start = 0;            /* clear timer */
 249    if (rc != sizeof(int32_t)) {
 250       bsock->errors++;
 251       if (errno == 0) {
 252          bsock->b_errno = EIO;
 253       } else {
 254          bsock->b_errno = errno;
 255       }
 256       if (rc < 0) {
 257          /****FIXME***** use Mmsg */
 258          Emsg4(M_ERROR, 0, "Write error sending to %s:%s:%d: ERR=%s\n",
 259                bsock->who, bsock->host, bsock->port,  bnet_strerror(bsock));
 260       } else {
 261          Emsg5(M_ERROR, 0, "Wrote %d bytes to %s:%s:%d, but only %d accepted.\n",
 262                bsock->who, bsock->host, bsock->port, bsock->msglen, rc);
 263       }
 264       return 0;
 265    }
 266
 267    bsock->out_msg_no++;               /* increment message number */
 268    if (bsock->msglen <= 0) {          /* length only? */
 269       return 1;                       /* yes, no data */
 270    }
 271
 272    /* send data packet */
 273    bsock->timer_start = watchdog_time; /* start timer */
 274    bsock->timed_out = 0;
 275    rc = write_nbytes(bsock, bsock->msg, bsock->msglen);
 276    bsock->timer_start = 0;            /* clear timer */
 277    if (rc != bsock->msglen) {
 278       bsock->errors++;
 279       if (errno == 0) {
 280          bsock->b_errno = EIO;
 281       } else {
 282          bsock->b_errno = errno;
 283       }
 284       if (rc < 0) {
 285          /************FIXME********* use Pmsg() **/
 286          Emsg4(M_ERROR, 0, "Write error sending to %s:%s:%d: ERR=%s\n",
 287                bsock->who, bsock->host, bsock->port,  bnet_strerror(bsock));
 288       } else {
 289          Emsg5(M_ERROR, 0, "Wrote %d bytes to %s:%s:%d, but only %d accepted.\n",
 290                bsock->who, bsock->host, bsock->port, bsock->msglen, rc);
 291       }
 292       return 0;
 293    }
 294    return 1;
 295 }
 296
 297 /*
 298  * Wait for a specified time for data to appear on
 299  * the BSOCK connection.
 300  *
 301  *   Returns: 1 if data available
 302  *            0 if timeout
 303  *           -1 if error
 304  */
 305 int
 306 bnet_wait_data(BSOCK *bsock, int sec)
 307 {
 308    fd_set fdset;
 309    struct timeval tv;
 310
 311    FD_ZERO(&fdset);
 312    FD_SET(bsock->fd, &fdset);
 313    tv.tv_sec = sec;
 314    tv.tv_usec = 0;
 315    for ( ;; ) {
 316       switch(select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) {
 317          case 0:                         /* timeout */
 318             bsock->b_errno = 0;
 319             return 0;
 320          case -1:
 321             bsock->b_errno = errno;
 322             if (errno == EINTR || errno == EAGAIN) {
 323                continue;
 324             }
 325             return -1;                  /* error return */
 326          default:
 327             bsock->b_errno = 0;
 328             return 1;
 329       }
 330    }
 331 }
 332
 333 /*
 334  * Convert a hostname or dotted IP address into
 335  * a s_addr.  We handle only IPv4.
 336  */
 337 static uint32_t *bget_host_ip(char *host)
 338 {
 339    struct in_addr inaddr;
 340    uint32_t *addr_list;               /* this really should be struct in_addr */
 341    struct hostent *hp;
 342    char **p;
 343    int i;
 344
 345    if ((inaddr.s_addr = inet_addr(host)) != INADDR_NONE) {
 346       addr_list = (uint32_t *) malloc(sizeof(uint32_t) * 2);
 347       addr_list[0] = inaddr.s_addr;
 348       addr_list[1] = (uint32_t) -1;
 349    } else {
 350       /******FIXME***** use gethostbyname_r or mutex ****/
 351       if ((hp = gethostbyname(host)) == NULL) {
 352          Dmsg2(0, "gethostbyname() for %s failed: ERR=%s\n", host, strerror(errno));
 353          return NULL;
 354       }
 355       if (hp->h_length != sizeof(inaddr.s_addr) || hp->h_addrtype != AF_INET) {
 356           Emsg2(M_WARNING, 0, "gethostbyname() network address length error.\n\
 357 Wanted %d got %d bytes for s_addr.\n", sizeof(inaddr.s_addr), hp->h_length);
 358           return NULL;
 359       }
 360       i = 0;
 361       for (p = hp->h_addr_list; *p != 0; p++) {
 362          i++;
 363       }
 364       i++;
 365       addr_list = (uint32_t *) malloc(sizeof(uint32_t) * i);
 366       i = 0;
 367       for (p = hp->h_addr_list; *p != 0; p++) {
 368          addr_list[i++] = (*(struct in_addr **)p)->s_addr;
 369       }
 370       addr_list[i] = (uint32_t) -1;
 371    }
 372    return addr_list;
 373 }
 374
 375 /*
 376  * Open a TCP connection to the UPS network server
 377  * Returns NULL
 378  * Returns BSOCK * pointer on success
 379  *
 380  *  ***FIXME*** implement service from /etc/services
 381  */
 382 static BSOCK *
 383 bnet_open(char *name, char *host, char *service, int port)
 384 {
 385    int sockfd;
 386    struct sockaddr_in tcp_serv_addr;     /* socket information */
 387    uint32_t *addr_list;
 388    int i, connected = 0;
 389    int turnon = 1;
 390
 391    /*
 392     * Fill in the structure serv_addr with the address of
 393     * the server that we want to connect with.
 394     */
 395    memset((char *)&tcp_serv_addr, 0,  sizeof(tcp_serv_addr));
 396    tcp_serv_addr.sin_family = AF_INET;
 397    tcp_serv_addr.sin_port = htons(port);
 398
 399    if ((addr_list=bget_host_ip(host)) == NULL) {
 400      return NULL;
 401    }
 402
 403    /* Open a TCP socket */
 404    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 405       free(addr_list);
 406       return NULL;
 407    }
 408
 409    /*
 410     * Receive notification when connection dies.
 411     */
 412    if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &turnon, sizeof(turnon)) < 0) {
 413       Emsg1(M_WARNING, 0, "Cannot set SO_KEEPALIVE on socket: %s\n" , strerror(errno));
 414    }
 415
 416    for (i = 0; addr_list[i] != ((uint32_t) -1); i++) {
 417       /* connect to server */
 418       tcp_serv_addr.sin_addr.s_addr = addr_list[i];
 419       if (connect(sockfd, (struct sockaddr *)&tcp_serv_addr, sizeof(tcp_serv_addr)) < 0) {
 420          continue;
 421       }
 422       connected = 1;
 423       break;
 424    }
 425
 426    free(addr_list);
 427    if (!connected) {
 428       close(sockfd);
 429       return NULL;
 430    }
 431    return init_bsock(sockfd, name, host, port);
 432 }
 433
 434 /*
 435  * Try to connect to host for max_retry_time at retry_time intervals.
 436  */
 437 BSOCK *
 438 bnet_connect(void *jcr, int retry_interval, int max_retry_time, char *name,
 439              char *host, char *service, int port, int verbose)
 440 {
 441    int i;
 442    BSOCK *bsock;
 443
 444    for (i=0; (bsock = bnet_open(name, host, service, port)) == NULL; i -= retry_interval) {
 445      Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
 446               name, host, port, strerror(errno));
 447       if (i <= 0) {
 448          i = 60 * 5;                  /* complain again in 5 minutes */
 449          if (verbose)
 450             Jmsg(jcr, M_WARNING, 0, "Could not connect to %s on %s:%d. ERR=%s\n\
 451 Retrying ...\n", name, host, port, strerror(errno));
 452       }
 453       sleep(retry_interval);
 454       max_retry_time -= retry_interval;
 455       if (max_retry_time <= 0) {
 456          Jmsg(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"),
 457               name, host, port, strerror(errno));
 458          return NULL;
 459       }
 460    }
 461    return bsock;
 462 }
 463
 464
 465 /*
 466  * Return the string for the error that occurred
 467  * on the socket. Only the first error is retained.
 468  */
 469 char *bnet_strerror(BSOCK *bsock)
 470 {
 471    /*  ***FIXME*** not thread safe */
 472    return strerror(bsock->b_errno);
 473 }
 474
 475 /*
 476  * Format and send a message
 477  *  Returns: 0 on failure
 478  *           1 on success
 479  */
 480 int
 481 bnet_fsend(BSOCK *bs, char *fmt, ...)
 482 {
 483    va_list arg_ptr;
 484    int maxlen;
 485
 486    /* This probably won't work, but we vsnprintf, then if we
 487     * get a negative length or a length greater than our buffer
 488     * (depending on which library is used), the printf was truncated, so
 489     * get a biger buffer and try again.
 490     */
 491 again:
 492    maxlen = sizeof_pool_memory(bs->msg) - 1;
 493    va_start(arg_ptr, fmt);
 494    bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
 495    va_end(arg_ptr);
 496    if (bs->msglen < 0 || bs->msglen >= maxlen) {
 497       bs->msg = realloc_pool_memory(bs->msg, maxlen + 200);
 498       goto again;
 499    }
 500    return bnet_send(bs) < 0 ? 0 : 1;
 501 }
 502
 503 /*
 504  * Set the network buffer size, suggested size is in size.
 505  *  Actual size obtained is returned in bs->msglen
 506  *
 507  *  Returns: 0 on failure
 508  *           1 on success
 509  */
 510 int bnet_set_buffer_size(BSOCK *bs, uint32_t size, int rw)
 511 {
 512    uint32_t dbuf_size;
 513 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
 514    int opt;
 515
 516     opt = IPTOS_THROUGHPUT;
 517     setsockopt(bs->fd, IPPROTO_IP, IP_TOS, (char *)&opt, sizeof(opt));
 518 #endif
 519
 520    dbuf_size = size;
 521    if ((bs->msg = realloc_pool_memory(bs->msg, dbuf_size+100)) == NULL) {
 522       Emsg0(M_FATAL, 0, "Could not malloc 32K BSOCK data buffer\n");
 523       return 0;
 524    }
 525    if (rw & BNET_SETBUF_READ) {
 526       while ((dbuf_size > TAPE_BSIZE) &&
 527          (setsockopt(bs->fd, SOL_SOCKET, SO_RCVBUF, (char *)&dbuf_size, sizeof(dbuf_size)) < 0)) {
 528          Emsg1(M_ERROR, 0, "sockopt error: %s\n", strerror(errno));
 529          dbuf_size -= TAPE_BSIZE;
 530       }
 531       Dmsg1(20, "set network buffer size=%d\n", dbuf_size);
 532       if (dbuf_size != MAX_NETWORK_BUFFER_SIZE)
 533          Emsg1(M_WARNING, 0, "Warning network buffer = %d bytes not max size.\n", dbuf_size);
 534       if (dbuf_size % TAPE_BSIZE != 0) {
 535          Emsg1(M_ABORT, 0, "Network buffer size %d not multiple of tape block size.\n",
 536               dbuf_size);
 537       }
 538    }
 539    dbuf_size = size;
 540    if (rw & BNET_SETBUF_WRITE) {
 541       while ((dbuf_size > TAPE_BSIZE) &&
 542          (setsockopt(bs->fd, SOL_SOCKET, SO_SNDBUF, (char *)&dbuf_size, sizeof(dbuf_size)) < 0)) {
 543          Emsg1(M_ERROR, 0, "sockopt error: %s\n", strerror(errno));
 544          dbuf_size -= TAPE_BSIZE;
 545       }
 546       Dmsg1(20, "set network buffer size=%d\n", dbuf_size);
 547       if (dbuf_size != MAX_NETWORK_BUFFER_SIZE)
 548          Emsg1(M_WARNING, 0, "Warning network buffer = %d bytes not max size.\n", dbuf_size);
 549       if (dbuf_size % TAPE_BSIZE != 0) {
 550          Emsg1(M_ABORT, 0, "Network buffer size %d not multiple of tape block size.\n",
 551               dbuf_size);
 552       }
 553    }
 554
 555    bs->msglen = dbuf_size;
 556    return 1;
 557 }
 558
 559 /*
 560  * Send a network "signal" to the other end
 561  *  This consists of sending a negative packet length
 562  *
 563  *  Returns: 0 on failure
 564  *           1 on success
 565  */
 566 int bnet_sig(BSOCK *bs, int sig)
 567 {
 568    bs->msglen = sig;
 569    return bnet_send(bs);
 570 }
 571
 572 /*
 573  * Convert a network "signal" code into
 574  * human readable ASCII.
 575  */
 576 char *bnet_sig_to_ascii(BSOCK *bs)
 577 {
 578    static char buf[30];
 579    switch (bs->msglen) {
 580       case BNET_NONO:                 /* for compatibility */
 581       case BNET_EOD:
 582          return "BNET_EOD";           /* end of data stream */
 583       case BNET_EOD_POLL:
 584          return "BNET_EOD_POLL";
 585       case BNET_STATUS:
 586          return "BNET_STATUS";
 587       case BNET_TERMINATE:
 588          return "BNET_TERMINATE";     /* terminate connection */
 589       case BNET_POLL:
 590          return "BNET_POLL";
 591       case BNET_HEARTBEAT:
 592          return "BNET_HEARTBEAT";
 593       case BNET_HB_RESPONSE:
 594          return "BNET_HB_RESPONSE";
 595       case BNET_PROMPT:
 596          return "BNET_PROMPT";
 597       default:
 598          sprintf(buf, "Unknown sig %d", bs->msglen);
 599          return buf;
 600    }
 601 }
 602
 603
 604 /* Initialize internal socket structure.
 605  *  This probably should be done in net_open
 606  */
 607 BSOCK *
 608 init_bsock(int sockfd, char *who, char *host, int port)
 609 {
 610    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 611    if (bsock == NULL) {
 612       Emsg0(M_ABORT, 0, "Out of memory in init_bsock.\n");
 613    }
 614    memset(bsock, 0, sizeof(BSOCK));
 615    bsock->fd = sockfd;
 616    bsock->errors = 0;
 617    bsock->msg = get_pool_memory(PM_MESSAGE);
 618    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 619    bsock->who = bstrdup(who);
 620    bsock->host = bstrdup(host);
 621    bsock->port = port;
 622    /*
 623     * ****FIXME**** reduce this to a few hours once
 624     *   heartbeats are implemented
 625     */
 626    bsock->timeout = 60 * 60 * 6 * 24; /* 6 days timeout */
 627    return bsock;
 628 }
 629
 630 BSOCK *
 631 dup_bsock(BSOCK *osock)
 632 {
 633    BSOCK *bsock = (BSOCK *) malloc(sizeof(BSOCK));
 634    if (bsock == NULL) {
 635       Emsg0(M_ABORT, 0, "Out of memory in dup_bsock.\n");
 636    }
 637    memcpy(bsock, osock, sizeof(BSOCK));
 638    bsock->msg = get_pool_memory(PM_MESSAGE);
 639    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 640    bsock->duped = TRUE;
 641    return bsock;
 642 }
 643
 644 /* Close the network connection */
 645 void
 646 bnet_close(BSOCK *bsock)
 647 {
 648    BSOCK *next;
 649
 650    for ( ; bsock != NULL; bsock = next) {
 651       next = bsock->next;
 652       if (!bsock->duped) {
 653 //       shutdown(bsock->fd, SHUT_RDWR);
 654          close(bsock->fd);
 655          term_bsock(bsock);
 656       } else {
 657          free(bsock);
 658       }
 659    }
 660    return;
 661 }
 662
 663 void
 664 term_bsock(BSOCK *bsock)
 665 {
 666    free_pool_memory(bsock->msg);
 667    free_pool_memory(bsock->errmsg);
 668    free(bsock->who);
 669    free(bsock->host);
 670    free(bsock);
 671 }
 672