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, 200000);  /* try again in 200ms */
  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 = 10;
 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->errors || bsock->is_terminated();
 196 }
 197
 198 /*
 199  * Return number of errors on socket
 200  */
 201 int is_bnet_error(BSOCK * bsock)
 202 {
 203    errno = bsock->b_errno;
 204    return bsock->errors;
 205 }
 206
 207 /*
 208  * Call here after error during closing to suppress error
 209  *  messages which are due to the other end shutting down too.
 210  */
 211 void bnet_suppress_error_messages(BSOCK * bsock, bool flag)
 212 {
 213    bsock->m_suppress_error_msgs = flag;
 214 }
 215
 216 /*
 217  * Send a message over the network. The send consists of
 218  * two network packets. The first is sends a 32 bit integer containing
 219  * the length of the data packet which follows.
 220  *
 221  * Returns: false on failure
 222  *          true  on success
 223  */
 224 bool bnet_send(BSOCK *bsock)
 225 {
 226    return bsock->send();
 227 }
 228
 229
 230 /*
 231  * Establish a TLS connection -- server side
 232  *  Returns: true  on success
 233  *           false on failure
 234  */
 235 #ifdef HAVE_TLS
 236 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 237 {
 238    TLS_CONNECTION *tls;
 239    JCR *jcr = bsock->jcr();
 240
 241    tls = new_tls_connection(ctx, bsock->m_fd);
 242    if (!tls) {
 243       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 244       return false;
 245    }
 246
 247    bsock->tls = tls;
 248
 249    /* Initiate TLS Negotiation */
 250    if (!tls_bsock_accept(bsock)) {
 251       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS Negotiation failed.\n"));
 252       goto err;
 253    }
 254
 255    if (verify_list) {
 256       if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
 257          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 258                                          " Peer certificate did not match a required commonName\n"),
 259                                          bsock->host());
 260          goto err;
 261       }
 262    }
 263    Dmsg0(50, "TLS server negotiation established.\n");
 264    return true;
 265
 266 err:
 267    free_tls_connection(tls);
 268    bsock->tls = NULL;
 269    return false;
 270 }
 271
 272 /*
 273  * Establish a TLS connection -- client side
 274  * Returns: true  on success
 275  *          false on failure
 276  */
 277 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 278 {
 279    TLS_CONNECTION *tls;
 280    JCR *jcr = bsock->jcr();
 281
 282    tls  = new_tls_connection(ctx, bsock->m_fd);
 283    if (!tls) {
 284       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 285       return false;
 286    }
 287
 288    bsock->tls = tls;
 289
 290    /* Initiate TLS Negotiation */
 291    if (!tls_bsock_connect(bsock)) {
 292       goto err;
 293    }
 294
 295    /* If there's an Allowed CN verify list, use that to validate the remote
 296     * certificate's CN. Otherwise, we use standard host/CN matching. */
 297    if (verify_list) {
 298       if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
 299          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 300                                          " Peer certificate did not match a required commonName\n"),
 301                                          bsock->host());
 302          goto err;
 303       }
 304    } else {
 305       if (!tls_postconnect_verify_host(jcr, tls, bsock->host())) {
 306          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host name \"%s\" did not match presented certificate\n"),
 307                bsock->host());
 308          goto err;
 309       }
 310    }
 311    Dmsg0(50, "TLS client negotiation established.\n");
 312    return true;
 313
 314 err:
 315    free_tls_connection(tls);
 316    bsock->tls = NULL;
 317    return false;
 318 }
 319 #else
 320
 321 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 322 {
 323    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n"));
 324    return false;
 325 }
 326
 327 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 328 {
 329    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n"));
 330    return false;
 331 }
 332
 333 #endif /* HAVE_TLS */
 334
 335 /*
 336  * Wait for a specified time for data to appear on
 337  * the BSOCK connection.
 338  *
 339  *   Returns: 1 if data available
 340  *            0 if timeout
 341  *           -1 if error
 342  */
 343 int bnet_wait_data(BSOCK * bsock, int sec)
 344 {
 345    return bsock->wait_data(sec);
 346 }
 347
 348 /*
 349  * As above, but returns on interrupt
 350  */
 351 int bnet_wait_data_intr(BSOCK * bsock, int sec)
 352 {
 353    return bsock->wait_data_intr(sec);
 354 }
 355
 356 #ifndef NETDB_INTERNAL
 357 #define NETDB_INTERNAL  -1         /* See errno. */
 358 #endif
 359 #ifndef NETDB_SUCCESS
 360 #define NETDB_SUCCESS   0          /* No problem. */
 361 #endif
 362 #ifndef HOST_NOT_FOUND
 363 #define HOST_NOT_FOUND  1          /* Authoritative Answer Host not found. */
 364 #endif
 365 #ifndef TRY_AGAIN
 366 #define TRY_AGAIN       2          /* Non-Authoritative Host not found, or SERVERFAIL. */
 367 #endif
 368 #ifndef NO_RECOVERY
 369 #define NO_RECOVERY     3          /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
 370 #endif
 371 #ifndef NO_DATA
 372 #define NO_DATA         4          /* Valid name, no data record of requested type. */
 373 #endif
 374
 375 /*
 376  * Get human readable error for gethostbyname()
 377  */
 378 static const char *gethost_strerror()
 379 {
 380    const char *msg;
 381    berrno be;
 382    switch (h_errno) {
 383    case NETDB_INTERNAL:
 384       msg = be.bstrerror();
 385       break;
 386    case NETDB_SUCCESS:
 387       msg = _("No problem.");
 388       break;
 389    case HOST_NOT_FOUND:
 390       msg = _("Authoritative answer for host not found.");
 391       break;
 392    case TRY_AGAIN:
 393       msg = _("Non-authoritative for host not found, or ServerFail.");
 394       break;
 395    case NO_RECOVERY:
 396       msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
 397       break;
 398    case NO_DATA:
 399       msg = _("Valid name, no data record of resquested type.");
 400       break;
 401    default:
 402       msg = _("Unknown error.");
 403    }
 404    return msg;
 405 }
 406
 407
 408
 409
 410 static IPADDR *add_any(int family)
 411 {
 412    IPADDR *addr = New(IPADDR(family));
 413    addr->set_type(IPADDR::R_MULTIPLE);
 414    addr->set_addr_any();
 415    return addr;
 416 }
 417
 418 static const char *resolv_host(int family, const char *host, dlist * addr_list)
 419 {
 420    struct hostent *hp;
 421    const char *errmsg;
 422
 423    P(ip_mutex);                       /* gethostbyname() is not thread safe */
 424 #ifdef HAVE_GETHOSTBYNAME2
 425    if ((hp = gethostbyname2(host, family)) == NULL) {
 426 #else
 427    if ((hp = gethostbyname(host)) == NULL) {
 428 #endif
 429       /* may be the strerror give not the right result -:( */
 430       errmsg = gethost_strerror();
 431       V(ip_mutex);
 432       return errmsg;
 433    } else {
 434       char **p;
 435       for (p = hp->h_addr_list; *p != 0; p++) {
 436          IPADDR *addr =  New(IPADDR(hp->h_addrtype));
 437          addr->set_type(IPADDR::R_MULTIPLE);
 438          if (addr->get_family() == AF_INET) {
 439              addr->set_addr4((struct in_addr*)*p);
 440          }
 441 #ifdef HAVE_IPV6
 442          else {
 443              addr->set_addr6((struct in6_addr*)*p);
 444          }
 445 #endif
 446          addr_list->append(addr);
 447       }
 448       V(ip_mutex);
 449    }
 450    return NULL;
 451 }
 452
 453 /*
 454  * i host = 0 mean INADDR_ANY only ipv4
 455  */
 456 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
 457 {
 458    struct in_addr inaddr;
 459    IPADDR *addr = 0;
 460    const char *errmsg;
 461 #ifdef HAVE_IPV6
 462    struct in6_addr inaddr6;
 463 #endif
 464
 465    dlist *addr_list = New(dlist(addr, &addr->link));
 466    if (!host || host[0] == '\0') {
 467       if (family != 0) {
 468          addr_list->append(add_any(family));
 469       } else {
 470          addr_list->append(add_any(AF_INET));
 471 #ifdef HAVE_IPV6
 472          addr_list->append(add_any(AF_INET6));
 473 #endif
 474       }
 475    } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
 476       addr = New(IPADDR(AF_INET));
 477       addr->set_type(IPADDR::R_MULTIPLE);
 478       addr->set_addr4(&inaddr);
 479       addr_list->append(addr);
 480    } else
 481 #ifdef HAVE_IPV6
 482    if (inet_pton(AF_INET6, host, &inaddr6) > 1) {
 483       addr = New(IPADDR(AF_INET6));
 484       addr->set_type(IPADDR::R_MULTIPLE);
 485       addr->set_addr6(&inaddr6);
 486       addr_list->append(addr);
 487    } else
 488 #endif
 489    {
 490       if (family != 0) {
 491          errmsg = resolv_host(family, host, addr_list);
 492          if (errmsg) {
 493             *errstr = errmsg;
 494             free_addresses(addr_list);
 495             return 0;
 496          }
 497       } else {
 498          errmsg = resolv_host(AF_INET, host, addr_list);
 499 #ifdef HAVE_IPV6
 500          if (errmsg) {
 501             errmsg = resolv_host(AF_INET6, host, addr_list);
 502          }
 503 #endif
 504          if (errmsg) {
 505             *errstr = errmsg;
 506             free_addresses(addr_list);
 507             return 0;
 508          }
 509       }
 510    }
 511    return addr_list;
 512 }
 513
 514 /*
 515  * This is the "old" way of opening a connection.  The preferred way is
 516  *   now to do what this subroutine does, but inline. That allows the
 517  *   connect() call to return error status, ...
 518  */
 519 BSOCK *bnet_connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
 520                     utime_t heart_beat,
 521                     const char *name, char *host, char *service, int port,
 522                     int verbose)
 523 {
 524    BSOCK *bsock = new_bsock();
 525    if (!bsock->connect(jcr, retry_interval, max_retry_time, heart_beat,
 526                        name, host, service, port, verbose)) {
 527        bsock->destroy();
 528        bsock = NULL;
 529    }
 530    return bsock;
 531 }
 532
 533
 534
 535 /*
 536  * Return the string for the error that occurred
 537  * on the socket. Only the first error is retained.
 538  */
 539 const char *bnet_strerror(BSOCK * bsock)
 540 {
 541    return bsock->bstrerror();
 542 }
 543
 544 /*
 545  * Format and send a message
 546  *  Returns: false on error
 547  *           true  on success
 548  */
 549 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
 550 {
 551    va_list arg_ptr;
 552    int maxlen;
 553
 554    if (bs->errors || bs->is_terminated()) {
 555       return false;
 556    }
 557    /* This probably won't work, but we vsnprintf, then if we
 558     * get a negative length or a length greater than our buffer
 559     * (depending on which library is used), the printf was truncated, so
 560     * get a bigger buffer and try again.
 561     */
 562    for (;;) {
 563       maxlen = sizeof_pool_memory(bs->msg) - 1;
 564       va_start(arg_ptr, fmt);
 565       bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
 566       va_end(arg_ptr);
 567       if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
 568          break;
 569       }
 570       bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
 571    }
 572    return bs->send();
 573 }
 574
 575 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen)
 576 {
 577    return bs->get_peer(buf, buflen);
 578 }
 579
 580 /*
 581  * Set the network buffer size, suggested size is in size.
 582  *  Actual size obtained is returned in bs->msglen
 583  *
 584  *  Returns: 0 on failure
 585  *           1 on success
 586  */
 587 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
 588 {
 589    return bs->set_buffer_size(size, rw);
 590 }
 591
 592 /*
 593  * Set socket non-blocking
 594  * Returns previous socket flag
 595  */
 596 int bnet_set_nonblocking(BSOCK *bsock)
 597 {
 598    return bsock->set_nonblocking();
 599 }
 600
 601 /*
 602  * Set socket blocking
 603  * Returns previous socket flags
 604  */
 605 int bnet_set_blocking(BSOCK *bsock)
 606 {
 607    return bsock->set_blocking();
 608 }
 609
 610 /*
 611  * Restores socket flags
 612  */
 613 void bnet_restore_blocking (BSOCK *bsock, int flags)
 614 {
 615    bsock->restore_blocking(flags);
 616 }
 617
 618
 619 /*
 620  * Send a network "signal" to the other end
 621  *  This consists of sending a negative packet length
 622  *
 623  *  Returns: false on failure
 624  *           true  on success
 625  */
 626 bool bnet_sig(BSOCK * bs, int signal)
 627 {
 628    return bs->signal(signal);
 629 }
 630
 631 /*
 632  * Convert a network "signal" code into
 633  * human readable ASCII.
 634  */
 635 const char *bnet_sig_to_ascii(BSOCK * bs)
 636 {
 637    static char buf[30];
 638    switch (bs->msglen) {
 639    case BNET_EOD:
 640       return "BNET_EOD";           /* end of data stream */
 641    case BNET_EOD_POLL:
 642       return "BNET_EOD_POLL";
 643    case BNET_STATUS:
 644       return "BNET_STATUS";
 645    case BNET_TERMINATE:
 646       return "BNET_TERMINATE";     /* terminate connection */
 647    case BNET_POLL:
 648       return "BNET_POLL";
 649    case BNET_HEARTBEAT:
 650       return "BNET_HEARTBEAT";
 651    case BNET_HB_RESPONSE:
 652       return "BNET_HB_RESPONSE";
 653    case BNET_PROMPT:
 654       return "BNET_PROMPT";
 655    default:
 656       sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
 657       return buf;
 658    }
 659 }
 660
 661 /* Initialize internal socket structure.
 662  *  This probably should be done in net_open
 663  */
 664 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
 665                   struct sockaddr *client_addr)
 666 {
 667    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
 668    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 669    memset(bsock, 0, sizeof(BSOCK));
 670    bsock->m_fd = sockfd;
 671    bsock->tls = NULL;
 672    bsock->errors = 0;
 673    bsock->m_blocking = 1;
 674    bsock->msg = get_pool_memory(PM_MESSAGE);
 675    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 676    bsock->set_who(bstrdup(who));
 677    bsock->set_host(bstrdup(host));
 678    bsock->set_port(port);
 679    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
 680    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
 681    /*
 682     * ****FIXME**** reduce this to a few hours once
 683     *   heartbeats are implemented
 684     */
 685    bsock->timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
 686    bsock->set_jcr(jcr);
 687    return bsock;
 688 }
 689
 690 BSOCK *dup_bsock(BSOCK *osock)
 691 {
 692    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 693    memcpy(bsock, osock, sizeof(BSOCK));
 694    bsock->msg = get_pool_memory(PM_MESSAGE);
 695    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 696    if (osock->who()) {
 697       bsock->set_who(bstrdup(osock->who()));
 698    }
 699    if (osock->host()) {
 700       bsock->set_host(bstrdup(osock->host()));
 701    }
 702    bsock->set_duped();
 703    return bsock;
 704 }
 705
 706 /* Close the network connection */
 707 void bnet_close(BSOCK * bsock)
 708 {
 709    bsock->close();
 710 }
 711
 712 void term_bsock(BSOCK * bsock)
 713 {
 714    bsock->destroy();
 715 }