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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  * Network Utility Routines
  30  *
  31  *  by Kern Sibbald
  32  *
  33  * Adapted and enhanced for Bacula, originally written
  34  * for inclusion in the Apcupsd package
  35  *
  36  *   Version $Id$
  37  */
  38
  39
  40 #include "bacula.h"
  41 #include "jcr.h"
  42 #include <netdb.h>
  43
  44 #ifndef   INADDR_NONE
  45 #define   INADDR_NONE    -1
  46 #endif
  47
  48 #ifdef HAVE_WIN32
  49 #define socketRead(fd, buf, len)  recv(fd, buf, len, 0)
  50 #define socketWrite(fd, buf, len) send(fd, buf, len, 0)
  51 #define socketClose(fd)           closesocket(fd)
  52 #else
  53 #define socketRead(fd, buf, len)  read(fd, buf, len)
  54 #define socketWrite(fd, buf, len) write(fd, buf, len)
  55 #define socketClose(fd)           close(fd)
  56 #endif
  57
  58 static pthread_mutex_t ip_mutex = PTHREAD_MUTEX_INITIALIZER;
  59
  60 /*
  61  * Read a nbytes from the network.
  62  * It is possible that the total bytes require in several
  63  * read requests
  64  */
  65
  66 int32_t read_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
  67 {
  68    int32_t nleft, nread;
  69
  70 #ifdef HAVE_TLS
  71    if (bsock->tls) {
  72       /* TLS enabled */
  73       return (tls_bsock_readn(bsock, ptr, nbytes));
  74    }
  75 #endif /* HAVE_TLS */
  76
  77    nleft = nbytes;
  78    while (nleft > 0) {
  79       errno = 0;
  80       nread = socketRead(bsock->m_fd, ptr, nleft);
  81       if (bsock->is_timed_out() || bsock->is_terminated()) {
  82          return nread;
  83       }
  84       if (nread == -1) {
  85          if (errno == EINTR) {
  86             continue;
  87          }
  88          if (errno == EAGAIN) {
  89             bmicrosleep(0, 20000);  /* try again in 20ms */
  90             continue;
  91          }
  92       }
  93       if (nread <= 0) {
  94          return nread;             /* error, or EOF */
  95       }
  96       nleft -= nread;
  97       ptr += nread;
  98    }
  99    return nbytes - nleft;          /* return >= 0 */
 100 }
 101
 102 /*
 103  * Write nbytes to the network.
 104  * It may require several writes.
 105  */
 106
 107 int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
 108 {
 109    int32_t nleft, nwritten;
 110
 111    if (bsock->is_spooling()) {
 112       nwritten = fwrite(ptr, 1, nbytes, bsock->m_spool_fd);
 113       if (nwritten != nbytes) {
 114          berrno be;
 115          bsock->b_errno = errno;
 116          Qmsg1(bsock->jcr(), M_FATAL, 0, _("Attr spool write error. ERR=%s\n"),
 117                be.bstrerror());
 118          Dmsg2(400, "nwritten=%d nbytes=%d.\n", nwritten, nbytes);
 119          errno = bsock->b_errno;
 120          return -1;
 121       }
 122       return nbytes;
 123    }
 124
 125 #ifdef HAVE_TLS
 126    if (bsock->tls) {
 127       /* TLS enabled */
 128       return (tls_bsock_writen(bsock, ptr, nbytes));
 129    }
 130 #endif /* HAVE_TLS */
 131
 132    nleft = nbytes;
 133    while (nleft > 0) {
 134       do {
 135          errno = 0;
 136          nwritten = socketWrite(bsock->m_fd, ptr, nleft);
 137          if (bsock->is_timed_out() || bsock->is_terminated()) {
 138             return nwritten;
 139          }
 140       } while (nwritten == -1 && errno == EINTR);
 141       /*
 142        * If connection is non-blocking, we will get EAGAIN, so
 143        * use select() to keep from consuming all the CPU
 144        * and try again.
 145        */
 146       if (nwritten == -1 && errno == EAGAIN) {
 147          fd_set fdset;
 148          struct timeval tv;
 149
 150          FD_ZERO(&fdset);
 151          FD_SET((unsigned)bsock->m_fd, &fdset);
 152          tv.tv_sec = 1;
 153          tv.tv_usec = 0;
 154          select(bsock->m_fd + 1, NULL, &fdset, NULL, &tv);
 155          continue;
 156       }
 157       if (nwritten <= 0) {
 158          return nwritten;          /* error */
 159       }
 160       nleft -= nwritten;
 161       ptr += nwritten;
 162    }
 163    return nbytes - nleft;
 164 }
 165
 166 /*
 167  * Receive a message from the other end. Each message consists of
 168  * two packets. The first is a header that contains the size
 169  * of the data that follows in the second packet.
 170  * Returns number of bytes read (may return zero)
 171  * Returns -1 on signal (BNET_SIGNAL)
 172  * Returns -2 on hard end of file (BNET_HARDEOF)
 173  * Returns -3 on error  (BNET_ERROR)
 174  *
 175  *  Unfortunately, it is a bit complicated because we have these
 176  *    four return types:
 177  *    1. Normal data
 178  *    2. Signal including end of data stream
 179  *    3. Hard end of file
 180  *    4. Error
 181  *  Using is_bnet_stop() and is_bnet_error() you can figure this all out.
 182  */
 183 int32_t bnet_recv(BSOCK * bsock)
 184 {
 185    return bsock->recv();
 186 }
 187
 188
 189 /*
 190  * Return 1 if there are errors on this bsock or it is closed,
 191  *   i.e. stop communicating on this line.
 192  */
 193 bool is_bnet_stop(BSOCK * bsock)
 194 {
 195    return bsock->is_stop();
 196 }
 197
 198 /*
 199  * Return number of errors on socket
 200  */
 201 int is_bnet_error(BSOCK * bsock)
 202 {
 203    return bsock->is_error();
 204 }
 205
 206 /*
 207  * Call here after error during closing to suppress error
 208  *  messages which are due to the other end shutting down too.
 209  */
 210 void bnet_suppress_error_messages(BSOCK * bsock, bool flag)
 211 {
 212    bsock->m_suppress_error_msgs = flag;
 213 }
 214
 215 /*
 216  * Send a message over the network. The send consists of
 217  * two network packets. The first is sends a 32 bit integer containing
 218  * the length of the data packet which follows.
 219  *
 220  * Returns: false on failure
 221  *          true  on success
 222  */
 223 bool bnet_send(BSOCK *bsock)
 224 {
 225    return bsock->send();
 226 }
 227
 228
 229 /*
 230  * Establish a TLS connection -- server side
 231  *  Returns: true  on success
 232  *           false on failure
 233  */
 234 #ifdef HAVE_TLS
 235 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 236 {
 237    TLS_CONNECTION *tls;
 238    JCR *jcr = bsock->jcr();
 239
 240    tls = new_tls_connection(ctx, bsock->m_fd);
 241    if (!tls) {
 242       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 243       return false;
 244    }
 245
 246    bsock->tls = tls;
 247
 248    /* Initiate TLS Negotiation */
 249    if (!tls_bsock_accept(bsock)) {
 250       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS Negotiation failed.\n"));
 251       goto err;
 252    }
 253
 254    if (verify_list) {
 255       if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
 256          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 257                                          " Peer certificate did not match a required commonName\n"),
 258                                          bsock->host());
 259          goto err;
 260       }
 261    }
 262    Dmsg0(50, "TLS server negotiation established.\n");
 263    return true;
 264
 265 err:
 266    free_tls_connection(tls);
 267    bsock->tls = NULL;
 268    return false;
 269 }
 270
 271 /*
 272  * Establish a TLS connection -- client side
 273  * Returns: true  on success
 274  *          false on failure
 275  */
 276 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 277 {
 278    TLS_CONNECTION *tls;
 279    JCR *jcr = bsock->jcr();
 280
 281    tls  = new_tls_connection(ctx, bsock->m_fd);
 282    if (!tls) {
 283       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 284       return false;
 285    }
 286
 287    bsock->tls = tls;
 288
 289    /* Initiate TLS Negotiation */
 290    if (!tls_bsock_connect(bsock)) {
 291       goto err;
 292    }
 293
 294    /* If there's an Allowed CN verify list, use that to validate the remote
 295     * certificate's CN. Otherwise, we use standard host/CN matching. */
 296    if (verify_list) {
 297       if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
 298          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 299                                          " Peer certificate did not match a required commonName\n"),
 300                                          bsock->host());
 301          goto err;
 302       }
 303    } else {
 304       if (!tls_postconnect_verify_host(jcr, tls, bsock->host())) {
 305          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host name \"%s\" did not match presented certificate\n"),
 306                bsock->host());
 307          goto err;
 308       }
 309    }
 310    Dmsg0(50, "TLS client negotiation established.\n");
 311    return true;
 312
 313 err:
 314    free_tls_connection(tls);
 315    bsock->tls = NULL;
 316    return false;
 317 }
 318 #else
 319
 320 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 321 {
 322    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n"));
 323    return false;
 324 }
 325
 326 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 327 {
 328    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n"));
 329    return false;
 330 }
 331
 332 #endif /* HAVE_TLS */
 333
 334 /*
 335  * Wait for a specified time for data to appear on
 336  * the BSOCK connection.
 337  *
 338  *   Returns: 1 if data available
 339  *            0 if timeout
 340  *           -1 if error
 341  */
 342 int bnet_wait_data(BSOCK * bsock, int sec)
 343 {
 344    return bsock->wait_data(sec);
 345 }
 346
 347 /*
 348  * As above, but returns on interrupt
 349  */
 350 int bnet_wait_data_intr(BSOCK * bsock, int sec)
 351 {
 352    return bsock->wait_data_intr(sec);
 353 }
 354
 355 #ifndef NETDB_INTERNAL
 356 #define NETDB_INTERNAL  -1         /* See errno. */
 357 #endif
 358 #ifndef NETDB_SUCCESS
 359 #define NETDB_SUCCESS   0          /* No problem. */
 360 #endif
 361 #ifndef HOST_NOT_FOUND
 362 #define HOST_NOT_FOUND  1          /* Authoritative Answer Host not found. */
 363 #endif
 364 #ifndef TRY_AGAIN
 365 #define TRY_AGAIN       2          /* Non-Authoritative Host not found, or SERVERFAIL. */
 366 #endif
 367 #ifndef NO_RECOVERY
 368 #define NO_RECOVERY     3          /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
 369 #endif
 370 #ifndef NO_DATA
 371 #define NO_DATA         4          /* Valid name, no data record of requested type. */
 372 #endif
 373
 374 /*
 375  * Get human readable error for gethostbyname()
 376  */
 377 static const char *gethost_strerror()
 378 {
 379    const char *msg;
 380    berrno be;
 381    switch (h_errno) {
 382    case NETDB_INTERNAL:
 383       msg = be.bstrerror();
 384       break;
 385    case NETDB_SUCCESS:
 386       msg = _("No problem.");
 387       break;
 388    case HOST_NOT_FOUND:
 389       msg = _("Authoritative answer for host not found.");
 390       break;
 391    case TRY_AGAIN:
 392       msg = _("Non-authoritative for host not found, or ServerFail.");
 393       break;
 394    case NO_RECOVERY:
 395       msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
 396       break;
 397    case NO_DATA:
 398       msg = _("Valid name, no data record of resquested type.");
 399       break;
 400    default:
 401       msg = _("Unknown error.");
 402    }
 403    return msg;
 404 }
 405
 406
 407
 408
 409 static IPADDR *add_any(int family)
 410 {
 411    IPADDR *addr = New(IPADDR(family));
 412    addr->set_type(IPADDR::R_MULTIPLE);
 413    addr->set_addr_any();
 414    return addr;
 415 }
 416
 417 static const char *resolv_host(int family, const char *host, dlist * addr_list)
 418 {
 419    struct hostent *hp;
 420    const char *errmsg;
 421
 422    P(ip_mutex);                       /* gethostbyname() is not thread safe */
 423 #ifdef HAVE_GETHOSTBYNAME2
 424    if ((hp = gethostbyname2(host, family)) == NULL) {
 425 #else
 426    if ((hp = gethostbyname(host)) == NULL) {
 427 #endif
 428       /* may be the strerror give not the right result -:( */
 429       errmsg = gethost_strerror();
 430       V(ip_mutex);
 431       return errmsg;
 432    } else {
 433       char **p;
 434       for (p = hp->h_addr_list; *p != 0; p++) {
 435          IPADDR *addr =  New(IPADDR(hp->h_addrtype));
 436          addr->set_type(IPADDR::R_MULTIPLE);
 437          if (addr->get_family() == AF_INET) {
 438              addr->set_addr4((struct in_addr*)*p);
 439          }
 440 #ifdef HAVE_IPV6
 441          else {
 442              addr->set_addr6((struct in6_addr*)*p);
 443          }
 444 #endif
 445          addr_list->append(addr);
 446       }
 447       V(ip_mutex);
 448    }
 449    return NULL;
 450 }
 451
 452 /*
 453  * i host = 0 mean INADDR_ANY only ipv4
 454  */
 455 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
 456 {
 457    struct in_addr inaddr;
 458    IPADDR *addr = 0;
 459    const char *errmsg;
 460 #ifdef HAVE_IPV6
 461    struct in6_addr inaddr6;
 462 #endif
 463
 464    dlist *addr_list = New(dlist(addr, &addr->link));
 465    if (!host || host[0] == '\0') {
 466       if (family != 0) {
 467          addr_list->append(add_any(family));
 468       } else {
 469          addr_list->append(add_any(AF_INET));
 470 #ifdef HAVE_IPV6
 471          addr_list->append(add_any(AF_INET6));
 472 #endif
 473       }
 474    } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
 475       addr = New(IPADDR(AF_INET));
 476       addr->set_type(IPADDR::R_MULTIPLE);
 477       addr->set_addr4(&inaddr);
 478       addr_list->append(addr);
 479    } else
 480 #ifdef HAVE_IPV6
 481    if (inet_pton(AF_INET6, host, &inaddr6) > 1) {
 482       addr = New(IPADDR(AF_INET6));
 483       addr->set_type(IPADDR::R_MULTIPLE);
 484       addr->set_addr6(&inaddr6);
 485       addr_list->append(addr);
 486    } else
 487 #endif
 488    {
 489       if (family != 0) {
 490          errmsg = resolv_host(family, host, addr_list);
 491          if (errmsg) {
 492             *errstr = errmsg;
 493             free_addresses(addr_list);
 494             return 0;
 495          }
 496       } else {
 497 #ifdef HAVE_IPV6
 498          /* We try to resolv host for ipv6 and ipv4, the connection procedure
 499           * will try to reach the host for each protocols. We report only "Host
 500           * not found" ipv4 message (no need to have ipv6 and ipv4 messages).
 501           */
 502          resolv_host(AF_INET6, host, addr_list);
 503 #endif
 504          errmsg = resolv_host(AF_INET, host, addr_list);
 505
 506          if (addr_list->size() == 0) {
 507             *errstr = errmsg;
 508             free_addresses(addr_list);
 509             return 0;
 510          }
 511       }
 512    }
 513    return addr_list;
 514 }
 515
 516 /*
 517  * This is the "old" way of opening a connection.  The preferred way is
 518  *   now to do what this subroutine does, but inline. That allows the
 519  *   connect() call to return error status, ...
 520  */
 521 BSOCK *bnet_connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
 522                     utime_t heart_beat,
 523                     const char *name, char *host, char *service, int port,
 524                     int verbose)
 525 {
 526    BSOCK *bsock = new_bsock();
 527    if (!bsock->connect(jcr, retry_interval, max_retry_time, heart_beat,
 528                        name, host, service, port, verbose)) {
 529        bsock->destroy();
 530        bsock = NULL;
 531    }
 532    return bsock;
 533 }
 534
 535
 536
 537 /*
 538  * Return the string for the error that occurred
 539  * on the socket. Only the first error is retained.
 540  */
 541 const char *bnet_strerror(BSOCK * bsock)
 542 {
 543    return bsock->bstrerror();
 544 }
 545
 546 /*
 547  * Format and send a message
 548  *  Returns: false on error
 549  *           true  on success
 550  */
 551 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
 552 {
 553    va_list arg_ptr;
 554    int maxlen;
 555
 556    if (bs->errors || bs->is_terminated()) {
 557       return false;
 558    }
 559    /* This probably won't work, but we vsnprintf, then if we
 560     * get a negative length or a length greater than our buffer
 561     * (depending on which library is used), the printf was truncated, so
 562     * get a bigger buffer and try again.
 563     */
 564    for (;;) {
 565       maxlen = sizeof_pool_memory(bs->msg) - 1;
 566       va_start(arg_ptr, fmt);
 567       bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
 568       va_end(arg_ptr);
 569       if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
 570          break;
 571       }
 572       bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
 573    }
 574    return bs->send();
 575 }
 576
 577 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen)
 578 {
 579    return bs->get_peer(buf, buflen);
 580 }
 581
 582 /*
 583  * Set the network buffer size, suggested size is in size.
 584  *  Actual size obtained is returned in bs->msglen
 585  *
 586  *  Returns: 0 on failure
 587  *           1 on success
 588  */
 589 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
 590 {
 591    return bs->set_buffer_size(size, rw);
 592 }
 593
 594 /*
 595  * Set socket non-blocking
 596  * Returns previous socket flag
 597  */
 598 int bnet_set_nonblocking(BSOCK *bsock)
 599 {
 600    return bsock->set_nonblocking();
 601 }
 602
 603 /*
 604  * Set socket blocking
 605  * Returns previous socket flags
 606  */
 607 int bnet_set_blocking(BSOCK *bsock)
 608 {
 609    return bsock->set_blocking();
 610 }
 611
 612 /*
 613  * Restores socket flags
 614  */
 615 void bnet_restore_blocking (BSOCK *bsock, int flags)
 616 {
 617    bsock->restore_blocking(flags);
 618 }
 619
 620
 621 /*
 622  * Send a network "signal" to the other end
 623  *  This consists of sending a negative packet length
 624  *
 625  *  Returns: false on failure
 626  *           true  on success
 627  */
 628 bool bnet_sig(BSOCK * bs, int signal)
 629 {
 630    return bs->signal(signal);
 631 }
 632
 633 /*
 634  * Convert a network "signal" code into
 635  * human readable ASCII.
 636  */
 637 const char *bnet_sig_to_ascii(BSOCK * bs)
 638 {
 639    static char buf[30];
 640    switch (bs->msglen) {
 641    case BNET_EOD:
 642       return "BNET_EOD";           /* end of data stream */
 643    case BNET_EOD_POLL:
 644       return "BNET_EOD_POLL";
 645    case BNET_STATUS:
 646       return "BNET_STATUS";
 647    case BNET_TERMINATE:
 648       return "BNET_TERMINATE";     /* terminate connection */
 649    case BNET_POLL:
 650       return "BNET_POLL";
 651    case BNET_HEARTBEAT:
 652       return "BNET_HEARTBEAT";
 653    case BNET_HB_RESPONSE:
 654       return "BNET_HB_RESPONSE";
 655    case BNET_PROMPT:
 656       return "BNET_PROMPT";
 657    default:
 658       sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
 659       return buf;
 660    }
 661 }
 662
 663 /* Initialize internal socket structure.
 664  *  This probably should be done in net_open
 665  */
 666 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
 667                   struct sockaddr *client_addr)
 668 {
 669    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
 670    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 671    memset(bsock, 0, sizeof(BSOCK));
 672    bsock->m_fd = sockfd;
 673    bsock->tls = NULL;
 674    bsock->errors = 0;
 675    bsock->m_blocking = 1;
 676    bsock->msg = get_pool_memory(PM_MESSAGE);
 677    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 678    bsock->set_who(bstrdup(who));
 679    bsock->set_host(bstrdup(host));
 680    bsock->set_port(port);
 681    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
 682    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
 683    /*
 684     * ****FIXME**** reduce this to a few hours once
 685     *   heartbeats are implemented
 686     */
 687    bsock->timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
 688    bsock->set_jcr(jcr);
 689    return bsock;
 690 }
 691
 692 BSOCK *dup_bsock(BSOCK *osock)
 693 {
 694    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 695    memcpy(bsock, osock, sizeof(BSOCK));
 696    bsock->msg = get_pool_memory(PM_MESSAGE);
 697    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 698    if (osock->who()) {
 699       bsock->set_who(bstrdup(osock->who()));
 700    }
 701    if (osock->host()) {
 702       bsock->set_host(bstrdup(osock->host()));
 703    }
 704    if (osock->src_addr) {
 705       bsock->src_addr = New( IPADDR( *(osock->src_addr)) );
 706    }
 707    bsock->set_duped();
 708    return bsock;
 709 }
 710
 711 /* Close the network connection */
 712 void bnet_close(BSOCK * bsock)
 713 {
 714    bsock->close();
 715 }
 716
 717 void term_bsock(BSOCK * bsock)
 718 {
 719    bsock->destroy();
 720 }