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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2006 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 plus additions
  11    that are listed 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 John Walker.
  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 extern time_t watchdog_time;
  45
  46 #ifndef   INADDR_NONE
  47 #define   INADDR_NONE    -1
  48 #endif
  49
  50 #ifndef ENODATA                    /* not defined on BSD systems */
  51 #define ENODATA EPIPE
  52 #endif
  53
  54 #ifdef HAVE_WIN32
  55 #define socketRead(fd, buf, len)  recv(fd, buf, len, 0)
  56 #define socketWrite(fd, buf, len) send(fd, buf, len, 0)
  57 #define socketClose(fd)           closesocket(fd)
  58 #else
  59 #define socketRead(fd, buf, len)  read(fd, buf, len)
  60 #define socketWrite(fd, buf, len) write(fd, buf, len)
  61 #define socketClose(fd)           close(fd)
  62 #endif
  63
  64 static pthread_mutex_t ip_mutex = PTHREAD_MUTEX_INITIALIZER;
  65
  66 /*
  67  * Read a nbytes from the network.
  68  * It is possible that the total bytes require in several
  69  * read requests
  70  */
  71
  72 int32_t read_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
  73 {
  74    int32_t nleft, nread;
  75
  76 #ifdef HAVE_TLS
  77    if (bsock->tls) {
  78       /* TLS enabled */
  79       return (tls_bsock_readn(bsock, ptr, nbytes));
  80    }
  81 #endif /* HAVE_TLS */
  82
  83    nleft = nbytes;
  84    while (nleft > 0) {
  85       errno = 0;
  86       nread = socketRead(bsock->fd, ptr, nleft);
  87       if (bsock->timed_out || bsock->terminated) {
  88          return nread;
  89       }
  90       if (nread == -1) {
  91          if (errno == EINTR) {
  92             continue;
  93          }
  94          if (errno == EAGAIN) {
  95             bmicrosleep(0, 200000);  /* try again in 200ms */
  96             continue;
  97          }
  98       }
  99       if (nread <= 0) {
 100          return nread;             /* error, or EOF */
 101       }
 102       nleft -= nread;
 103       ptr += nread;
 104    }
 105    return nbytes - nleft;          /* return >= 0 */
 106 }
 107
 108 /*
 109  * Write nbytes to the network.
 110  * It may require several writes.
 111  */
 112
 113 int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
 114 {
 115    int32_t nleft, nwritten;
 116
 117    if (bsock->spool) {
 118       nwritten = fwrite(ptr, 1, nbytes, bsock->spool_fd);
 119       if (nwritten != nbytes) {
 120          berrno be;
 121          bsock->b_errno = errno;
 122          Qmsg1(bsock->jcr(), M_FATAL, 0, _("Attr spool write error. ERR=%s\n"),
 123                be.strerror());
 124          Dmsg2(400, "nwritten=%d nbytes=%d.\n", nwritten, nbytes);
 125          errno = bsock->b_errno;
 126          return -1;
 127       }
 128       return nbytes;
 129    }
 130
 131 #ifdef HAVE_TLS
 132    if (bsock->tls) {
 133       /* TLS enabled */
 134       return (tls_bsock_writen(bsock, ptr, nbytes));
 135    }
 136 #endif /* HAVE_TLS */
 137
 138    nleft = nbytes;
 139    while (nleft > 0) {
 140       do {
 141          errno = 0;
 142          nwritten = socketWrite(bsock->fd, ptr, nleft);
 143          if (bsock->timed_out || bsock->terminated) {
 144             return nwritten;
 145          }
 146       } while (nwritten == -1 && errno == EINTR);
 147       /*
 148        * If connection is non-blocking, we will get EAGAIN, so
 149        * use select() to keep from consuming all the CPU
 150        * and try again.
 151        */
 152       if (nwritten == -1 && errno == EAGAIN) {
 153          fd_set fdset;
 154          struct timeval tv;
 155
 156          FD_ZERO(&fdset);
 157          FD_SET((unsigned)bsock->fd, &fdset);
 158          tv.tv_sec = 10;
 159          tv.tv_usec = 0;
 160          select(bsock->fd + 1, NULL, &fdset, NULL, &tv);
 161          continue;
 162       }
 163       if (nwritten <= 0) {
 164          return nwritten;          /* error */
 165       }
 166       nleft -= nwritten;
 167       ptr += nwritten;
 168    }
 169    return nbytes - nleft;
 170 }
 171
 172 /*
 173  * Receive a message from the other end. Each message consists of
 174  * two packets. The first is a header that contains the size
 175  * of the data that follows in the second packet.
 176  * Returns number of bytes read (may return zero)
 177  * Returns -1 on signal (BNET_SIGNAL)
 178  * Returns -2 on hard end of file (BNET_HARDEOF)
 179  * Returns -3 on error  (BNET_ERROR)
 180  *
 181  *  Unfortunately, it is a bit complicated because we have these
 182  *    four return types:
 183  *    1. Normal data
 184  *    2. Signal including end of data stream
 185  *    3. Hard end of file
 186  *    4. Error
 187  *  Using is_bnet_stop() and is_bnet_error() you can figure this all out.
 188  */
 189 int32_t bnet_recv(BSOCK * bsock)
 190 {
 191    return bsock->recv();
 192 }
 193
 194
 195 /*
 196  * Return 1 if there are errors on this bsock or it is closed,
 197  *   i.e. stop communicating on this line.
 198  */
 199 bool is_bnet_stop(BSOCK * bsock)
 200 {
 201    return bsock->errors || bsock->terminated;
 202 }
 203
 204 /*
 205  * Return number of errors on socket
 206  */
 207 int is_bnet_error(BSOCK * bsock)
 208 {
 209    errno = bsock->b_errno;
 210    return bsock->errors;
 211 }
 212
 213 /*
 214  * Call here after error during closing to suppress error
 215  *  messages which are due to the other end shutting down too.
 216  */
 217 void bnet_suppress_error_messages(BSOCK * bsock, bool flag)
 218 {
 219    bsock->suppress_error_msgs = flag;
 220 }
 221
 222
 223 /*
 224  * Transmit spooled data now to a BSOCK
 225  */
 226 int bnet_despool_to_bsock(BSOCK * bsock, void update_attr_spool_size(ssize_t size),
 227                           ssize_t tsize)
 228 {
 229    int32_t pktsiz;
 230    size_t nbytes;
 231    ssize_t last = 0, size = 0;
 232    int count = 0;
 233
 234    rewind(bsock->spool_fd);
 235    while (fread((char *)&pktsiz, 1, sizeof(int32_t), bsock->spool_fd) ==
 236           sizeof(int32_t)) {
 237       size += sizeof(int32_t);
 238       bsock->msglen = ntohl(pktsiz);
 239       if (bsock->msglen > 0) {
 240          if (bsock->msglen > (int32_t) sizeof_pool_memory(bsock->msg)) {
 241             bsock->msg = realloc_pool_memory(bsock->msg, bsock->msglen + 1);
 242          }
 243          nbytes = fread(bsock->msg, 1, bsock->msglen, bsock->spool_fd);
 244          if (nbytes != (size_t) bsock->msglen) {
 245             berrno be;
 246             Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, bsock->msglen);
 247             Qmsg1(bsock->jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
 248                   be.strerror());
 249             update_attr_spool_size(tsize - last);
 250             return 0;
 251          }
 252          size += nbytes;
 253          if ((++count & 0x3F) == 0) {
 254             update_attr_spool_size(size - last);
 255             last = size;
 256          }
 257       }
 258       bnet_send(bsock);
 259    }
 260    update_attr_spool_size(tsize - last);
 261    if (ferror(bsock->spool_fd)) {
 262       berrno be;
 263       Qmsg1(bsock->jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
 264             be.strerror());
 265       return 0;
 266    }
 267    return 1;
 268 }
 269
 270
 271 /*
 272  * Send a message over the network. The send consists of
 273  * two network packets. The first is sends a 32 bit integer containing
 274  * the length of the data packet which follows.
 275  *
 276  * Returns: false on failure
 277  *          true  on success
 278  */
 279 bool bnet_send(BSOCK *bsock)
 280 {
 281    return bsock->send();
 282 }
 283
 284 #ifdef xxx
 285 bool bnet_send(BSOCK * bsock)
 286 {
 287    int32_t rc;
 288    int32_t pktsiz;
 289
 290    if (bsock->errors || bsock->terminated || bsock->msglen > 1000000) {
 291       return false;
 292    }
 293    pktsiz = htonl((int32_t)bsock->msglen);
 294    /* send int32_t containing size of data packet */
 295    bsock->timer_start = watchdog_time;  /* start timer */
 296    bsock->timed_out = 0;
 297    rc = write_nbytes(bsock, (char *)&pktsiz, sizeof(int32_t));
 298    bsock->timer_start = 0;         /* clear timer */
 299    if (rc != sizeof(int32_t)) {
 300       if (bsock->msglen == BNET_TERMINATE) {    /* if we were terminating */
 301          bsock->terminated = 1;
 302          return false;             /* ignore any errors */
 303       }
 304       bsock->errors++;
 305       if (errno == 0) {
 306          bsock->b_errno = EIO;
 307       } else {
 308          bsock->b_errno = errno;
 309       }
 310       if (rc < 0) {
 311          if (!bsock->suppress_error_msgs && !bsock->timed_out) {
 312             Qmsg4(bsock->jcr(), M_ERROR, 0,
 313                   _("Write error sending len to %s:%s:%d: ERR=%s\n"), bsock->who,
 314                   bsock->host(), bsock->port(), bnet_strerror(bsock));
 315          }
 316       } else {
 317          Qmsg5(bsock->jcr(), M_ERROR, 0,
 318                _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
 319                sizeof(int32_t), bsock->who(),
 320                bsock->host(), bsock->port(), rc);
 321       }
 322       return false;
 323    }
 324
 325    bsock->out_msg_no++;            /* increment message number */
 326    if (bsock->msglen <= 0) {       /* length only? */
 327       return true;                 /* yes, no data */
 328    }
 329
 330    /* send data packet */
 331    bsock->timer_start = watchdog_time;  /* start timer */
 332    bsock->timed_out = 0;
 333    rc = write_nbytes(bsock, bsock->msg, bsock->msglen);
 334    bsock->timer_start = 0;         /* clear timer */
 335    if (rc != bsock->msglen) {
 336       bsock->errors++;
 337       if (errno == 0) {
 338          bsock->b_errno = EIO;
 339       } else {
 340          bsock->b_errno = errno;
 341       }
 342       if (rc < 0) {
 343          if (!bsock->suppress_error_msgs) {
 344             Qmsg5(bsock->jcr(), M_ERROR, 0,
 345                   _("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"),
 346                   bsock->msglen, bsock->who(),
 347                   bsock->host(), bsock->port(), bnet_strerror(bsock));
 348          }
 349       } else {
 350          Qmsg5(bsock->jcr(), M_ERROR, 0,
 351                _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
 352                bsock->msglen, bsock->who(), bsock->host(),
 353                bsock->port(), rc);
 354       }
 355       return false;
 356    }
 357    return true;
 358 }
 359 #endif
 360
 361 /*
 362  * Establish a TLS connection -- server side
 363  *  Returns: true  on success
 364  *           false on failure
 365  */
 366 #ifdef HAVE_TLS
 367 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 368 {
 369    TLS_CONNECTION *tls;
 370
 371    tls = new_tls_connection(ctx, bsock->fd);
 372    if (!tls) {
 373       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 374       return false;
 375    }
 376
 377    bsock->tls = tls;
 378
 379    /* Initiate TLS Negotiation */
 380    if (!tls_bsock_accept(bsock)) {
 381       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS Negotiation failed.\n"));
 382       goto err;
 383    }
 384
 385    if (verify_list) {
 386       if (!tls_postconnect_verify_cn(tls, verify_list)) {
 387          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 388                                          " Peer certificate did not match a required commonName\n"),
 389                                          bsock->host());
 390          goto err;
 391       }
 392    }
 393    return true;
 394
 395 err:
 396    free_tls_connection(tls);
 397    bsock->tls = NULL;
 398    return false;
 399 }
 400
 401 /*
 402  * Establish a TLS connection -- client side
 403  * Returns: true  on success
 404  *          false on failure
 405  */
 406 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 407 {
 408    TLS_CONNECTION *tls;
 409
 410    tls  = new_tls_connection(ctx, bsock->fd);
 411    if (!tls) {
 412       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 413       return false;
 414    }
 415
 416    bsock->tls = tls;
 417
 418    /* Initiate TLS Negotiation */
 419    if (!tls_bsock_connect(bsock)) {
 420       goto err;
 421    }
 422
 423    /* If there's an Allowed CN verify list, use that to validate the remote
 424     * certificate's CN. Otherwise, we use standard host/CN matching. */
 425    if (verify_list) {
 426       if (!tls_postconnect_verify_cn(tls, verify_list)) {
 427          Qmsg1(bsock->jcr, M_FATAL, 0, _("TLS certificate verification failed."
 428                                          " Peer certificate did not match a required commonName\n"),
 429                                          bsock->host);
 430          goto err;
 431       }
 432    } else {
 433       if (!tls_postconnect_verify_host(tls, bsock->host())) {
 434          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host %s did not match presented certificate\n"),
 435                bsock->host());
 436          goto err;
 437       }
 438    }
 439
 440    return true;
 441
 442 err:
 443    free_tls_connection(tls);
 444    bsock->tls = NULL;
 445    return false;
 446 }
 447 #else
 448 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 449 {
 450    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n"));
 451    return false;
 452 }
 453 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list, int verify_hostname)
 454 {
 455    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n"));
 456    return false;
 457 }
 458 #endif /* HAVE_TLS */
 459
 460 /*
 461  * Wait for a specified time for data to appear on
 462  * the BSOCK connection.
 463  *
 464  *   Returns: 1 if data available
 465  *            0 if timeout
 466  *           -1 if error
 467  */
 468 int bnet_wait_data(BSOCK * bsock, int sec)
 469 {
 470    fd_set fdset;
 471    struct timeval tv;
 472
 473    FD_ZERO(&fdset);
 474    FD_SET((unsigned)bsock->fd, &fdset);
 475    for (;;) {
 476       tv.tv_sec = sec;
 477       tv.tv_usec = 0;
 478       switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) {
 479       case 0:                      /* timeout */
 480          bsock->b_errno = 0;
 481          return 0;
 482       case -1:
 483          bsock->b_errno = errno;
 484          if (errno == EINTR) {
 485             continue;
 486          }
 487          return -1;                /* error return */
 488       default:
 489          bsock->b_errno = 0;
 490          return 1;
 491       }
 492    }
 493 }
 494
 495 /*
 496  * As above, but returns on interrupt
 497  */
 498 int bnet_wait_data_intr(BSOCK * bsock, int sec)
 499 {
 500    fd_set fdset;
 501    struct timeval tv;
 502
 503    FD_ZERO(&fdset);
 504    FD_SET((unsigned)bsock->fd, &fdset);
 505    tv.tv_sec = sec;
 506    tv.tv_usec = 0;
 507    switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) {
 508    case 0:                      /* timeout */
 509       bsock->b_errno = 0;
 510       return 0;
 511    case -1:
 512       bsock->b_errno = errno;
 513       return -1;                /* error return */
 514    default:
 515       bsock->b_errno = 0;
 516    }
 517    return 1;
 518 }
 519
 520 #ifndef NETDB_INTERNAL
 521 #define NETDB_INTERNAL  -1         /* See errno. */
 522 #endif
 523 #ifndef NETDB_SUCCESS
 524 #define NETDB_SUCCESS   0          /* No problem. */
 525 #endif
 526 #ifndef HOST_NOT_FOUND
 527 #define HOST_NOT_FOUND  1          /* Authoritative Answer Host not found. */
 528 #endif
 529 #ifndef TRY_AGAIN
 530 #define TRY_AGAIN       2          /* Non-Authoritative Host not found, or SERVERFAIL. */
 531 #endif
 532 #ifndef NO_RECOVERY
 533 #define NO_RECOVERY     3          /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
 534 #endif
 535 #ifndef NO_DATA
 536 #define NO_DATA         4          /* Valid name, no data record of requested type. */
 537 #endif
 538
 539 /*
 540  * Get human readable error for gethostbyname()
 541  */
 542 static const char *gethost_strerror()
 543 {
 544    const char *msg;
 545    berrno be;
 546    switch (h_errno) {
 547    case NETDB_INTERNAL:
 548       msg = be.strerror();
 549       break;
 550    case NETDB_SUCCESS:
 551       msg = _("No problem.");
 552       break;
 553    case HOST_NOT_FOUND:
 554       msg = _("Authoritative answer for host not found.");
 555       break;
 556    case TRY_AGAIN:
 557       msg = _("Non-authoritative for host not found, or ServerFail.");
 558       break;
 559    case NO_RECOVERY:
 560       msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
 561       break;
 562    case NO_DATA:
 563       msg = _("Valid name, no data record of resquested type.");
 564       break;
 565    default:
 566       msg = _("Unknown error.");
 567    }
 568    return msg;
 569 }
 570
 571
 572
 573
 574 static IPADDR *add_any(int family)
 575 {
 576    IPADDR *addr = New(IPADDR(family));
 577    addr->set_type(IPADDR::R_MULTIPLE);
 578    addr->set_addr_any();
 579    return addr;
 580 }
 581
 582 static const char *resolv_host(int family, const char *host, dlist * addr_list)
 583 {
 584    struct hostent *hp;
 585    const char *errmsg;
 586
 587    P(ip_mutex);                       /* gethostbyname() is not thread safe */
 588 #ifdef HAVE_GETHOSTBYNAME2
 589    if ((hp = gethostbyname2(host, family)) == NULL) {
 590 #else
 591    if ((hp = gethostbyname(host)) == NULL) {
 592 #endif
 593       /* may be the strerror give not the right result -:( */
 594       errmsg = gethost_strerror();
 595       V(ip_mutex);
 596       return errmsg;
 597    } else {
 598       char **p;
 599       for (p = hp->h_addr_list; *p != 0; p++) {
 600          IPADDR *addr =  New(IPADDR(hp->h_addrtype));
 601          addr->set_type(IPADDR::R_MULTIPLE);
 602          if (addr->get_family() == AF_INET) {
 603              addr->set_addr4((struct in_addr*)*p);
 604          }
 605 #ifdef HAVE_IPV6
 606          else {
 607              addr->set_addr6((struct in6_addr*)*p);
 608          }
 609 #endif
 610          addr_list->append(addr);
 611       }
 612       V(ip_mutex);
 613    }
 614    return NULL;
 615 }
 616
 617 /*
 618  * i host = 0 mean INADDR_ANY only ipv4
 619  */
 620 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
 621 {
 622    struct in_addr inaddr;
 623    IPADDR *addr = 0;
 624    const char *errmsg;
 625 #ifdef HAVE_IPV6
 626    struct in6_addr inaddr6;
 627 #endif
 628
 629    dlist *addr_list = New(dlist(addr, &addr->link));
 630    if (!host || host[0] == '\0') {
 631       if (family != 0) {
 632          addr_list->append(add_any(family));
 633       } else {
 634          addr_list->append(add_any(AF_INET));
 635 #ifdef HAVE_IPV6
 636          addr_list->append(add_any(AF_INET6));
 637 #endif
 638       }
 639    } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
 640       addr = New(IPADDR(AF_INET));
 641       addr->set_type(IPADDR::R_MULTIPLE);
 642       addr->set_addr4(&inaddr);
 643       addr_list->append(addr);
 644    } else
 645 #ifdef HAVE_IPV6
 646    if (inet_pton(AF_INET6, host, &inaddr6) > 1) {
 647       addr = New(IPADDR(AF_INET6));
 648       addr->set_type(IPADDR::R_MULTIPLE);
 649       addr->set_addr6(&inaddr6);
 650       addr_list->append(addr);
 651    } else
 652 #endif
 653    {
 654       if (family != 0) {
 655          errmsg = resolv_host(family, host, addr_list);
 656          if (errmsg) {
 657             *errstr = errmsg;
 658             free_addresses(addr_list);
 659             return 0;
 660          }
 661       } else {
 662          errmsg = resolv_host(AF_INET, host, addr_list);
 663 #ifdef HAVE_IPV6
 664          if (errmsg) {
 665             errmsg = resolv_host(AF_INET6, host, addr_list);
 666          }
 667 #endif
 668          if (errmsg) {
 669             *errstr = errmsg;
 670             free_addresses(addr_list);
 671             return 0;
 672          }
 673       }
 674    }
 675    return addr_list;
 676 }
 677
 678 /*
 679  * Open a TCP connection to the UPS network server
 680  * Returns NULL
 681  * Returns BSOCK * pointer on success
 682  *
 683  */
 684 static BSOCK *bnet_open(JCR * jcr, const char *name, char *host, char *service,
 685                         int port, int *fatal)
 686 {
 687    int sockfd = -1;
 688    dlist *addr_list;
 689    IPADDR *ipaddr;
 690    bool connected = false;
 691    int turnon = 1;
 692    const char *errstr;
 693    int save_errno = 0;
 694
 695    /*
 696     * Fill in the structure serv_addr with the address of
 697     * the server that we want to connect with.
 698     */
 699    if ((addr_list = bnet_host2ipaddrs(host, 0, &errstr)) == NULL) {
 700       /* Note errstr is not malloc'ed */
 701       Qmsg2(jcr, M_ERROR, 0, _("gethostbyname() for host \"%s\" failed: ERR=%s\n"),
 702             host, errstr);
 703       Dmsg2(100, "bnet_host2ipaddrs() for host %s failed: ERR=%s\n",
 704             host, errstr);
 705       *fatal = 1;
 706       return NULL;
 707    }
 708
 709    foreach_dlist(ipaddr, addr_list) {
 710       ipaddr->set_port_net(htons(port));
 711       char allbuf[256 * 10];
 712       char curbuf[256];
 713       Dmsg2(100, "Current %sAll %s\n",
 714                    ipaddr->build_address_str(curbuf, sizeof(curbuf)),
 715                    build_addresses_str(addr_list, allbuf, sizeof(allbuf)));
 716       /* Open a TCP socket */
 717       if ((sockfd = socket(ipaddr->get_family(), SOCK_STREAM, 0)) < 0) {
 718          berrno be;
 719          save_errno = errno;
 720          *fatal = 1;
 721          Pmsg3(000, _("Socket open error. proto=%d port=%d. ERR=%s\n"),
 722             ipaddr->get_family(), ipaddr->get_port_host_order(), be.strerror());
 723          continue;
 724       }
 725       /*
 726        * Keep socket from timing out from inactivity
 727        */
 728       if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 729          berrno be;
 730          Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 731                be.strerror());
 732       }
 733       /* connect to server */
 734       if (connect(sockfd, ipaddr->get_sockaddr(), ipaddr->get_sockaddr_len()) < 0) {
 735          save_errno = errno;
 736          socketClose(sockfd);
 737          continue;
 738       }
 739       *fatal = 0;
 740       connected = true;
 741       break;
 742    }
 743
 744    if (!connected) {
 745       free_addresses(addr_list);
 746       errno = save_errno;
 747       return NULL;
 748    }
 749    /*
 750     * Keep socket from timing out from inactivity
 751     *   Do this a second time out of paranoia
 752     */
 753    if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 754       berrno be;
 755       Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 756             be.strerror());
 757    }
 758    BSOCK* ret =  init_bsock(jcr, sockfd, name, host, port, ipaddr->get_sockaddr());
 759    free_addresses(addr_list);
 760    return ret;
 761 }
 762
 763 /*
 764  * Try to connect to host for max_retry_time at retry_time intervals.
 765  */
 766 BSOCK *bnet_connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
 767                     const char *name, char *host, char *service, int port,
 768                     int verbose)
 769 {
 770    int i;
 771    BSOCK *bsock;
 772    int fatal = 0;
 773    time_t begin_time = time(NULL);
 774    time_t now;
 775
 776    for (i = 0; (bsock = bnet_open(jcr, name, host, service, port, &fatal)) == NULL;
 777         i -= retry_interval) {
 778       berrno be;
 779       if (fatal || (jcr && job_canceled(jcr))) {
 780          return NULL;
 781       }
 782       Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
 783             name, host, port, be.strerror());
 784       if (i < 0) {
 785          i = 60 * 5;               /* complain again in 5 minutes */
 786          if (verbose)
 787             Qmsg4(jcr, M_WARNING, 0, _(
 788                "Could not connect to %s on %s:%d. ERR=%s\n"
 789                "Retrying ...\n"), name, host, port, be.strerror());
 790       }
 791       bmicrosleep(retry_interval, 0);
 792       now = time(NULL);
 793       if (begin_time + max_retry_time <= now) {
 794          Qmsg4(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"),
 795                name, host, port, be.strerror());
 796          return NULL;
 797       }
 798    }
 799    return bsock;
 800 }
 801
 802
 803 /*
 804  * Return the string for the error that occurred
 805  * on the socket. Only the first error is retained.
 806  */
 807 const char *bnet_strerror(BSOCK * bsock)
 808 {
 809    berrno be;
 810    if (bsock->errmsg == NULL) {
 811       bsock->errmsg = get_pool_memory(PM_MESSAGE);
 812    }
 813    pm_strcpy(bsock->errmsg, be.strerror(bsock->b_errno));
 814    return bsock->errmsg;
 815 }
 816
 817 /*
 818  * Format and send a message
 819  *  Returns: false on error
 820  *           true  on success
 821  */
 822 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
 823 {
 824    va_list arg_ptr;
 825    int maxlen;
 826
 827    if (bs->errors || bs->terminated) {
 828       return false;
 829    }
 830    /* This probably won't work, but we vsnprintf, then if we
 831     * get a negative length or a length greater than our buffer
 832     * (depending on which library is used), the printf was truncated, so
 833     * get a bigger buffer and try again.
 834     */
 835    for (;;) {
 836       maxlen = sizeof_pool_memory(bs->msg) - 1;
 837       va_start(arg_ptr, fmt);
 838       bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
 839       va_end(arg_ptr);
 840       if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
 841          break;
 842       }
 843       bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
 844    }
 845    return bs->send();
 846 // return bnet_send(bs);
 847 }
 848
 849 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen) {
 850 #if !defined(HAVE_WIN32)
 851     if (bs->peer_addr.sin_family == 0) {
 852         socklen_t salen = sizeof(bs->peer_addr);
 853         int rval = (getpeername)(bs->fd, (struct sockaddr *)&bs->peer_addr, &salen);
 854         if (rval < 0) return rval;
 855     }
 856     if (!inet_ntop(bs->peer_addr.sin_family, &bs->peer_addr.sin_addr, buf, buflen))
 857         return -1;
 858
 859     return 0;
 860 #else
 861     return -1;
 862 #endif
 863 }
 864 /*
 865  * Set the network buffer size, suggested size is in size.
 866  *  Actual size obtained is returned in bs->msglen
 867  *
 868  *  Returns: 0 on failure
 869  *           1 on success
 870  */
 871 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
 872 {
 873    uint32_t dbuf_size, start_size;
 874 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
 875    int opt;
 876
 877    opt = IPTOS_THROUGHPUT;
 878    setsockopt(bs->fd, IPPROTO_IP, IP_TOS, (sockopt_val_t) & opt, sizeof(opt));
 879 #endif
 880
 881    if (size != 0) {
 882       dbuf_size = size;
 883    } else {
 884       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 885    }
 886    start_size = dbuf_size;
 887    if ((bs->msg = realloc_pool_memory(bs->msg, dbuf_size + 100)) == NULL) {
 888       Qmsg0(bs->jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
 889       return false;
 890    }
 891    if (rw & BNET_SETBUF_READ) {
 892       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 893               SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 894          berrno be;
 895          Qmsg1(bs->jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 896          dbuf_size -= TAPE_BSIZE;
 897       }
 898       Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
 899       if (dbuf_size != start_size) {
 900          Qmsg1(bs->jcr(), M_WARNING, 0,
 901                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 902       }
 903       if (dbuf_size % TAPE_BSIZE != 0) {
 904          Qmsg1(bs->jcr(), M_ABORT, 0,
 905                _("Network buffer size %d not multiple of tape block size.\n"),
 906                dbuf_size);
 907       }
 908    }
 909    if (size != 0) {
 910       dbuf_size = size;
 911    } else {
 912       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 913    }
 914    start_size = dbuf_size;
 915    if (rw & BNET_SETBUF_WRITE) {
 916       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 917               SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 918          berrno be;
 919          Qmsg1(bs->jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 920          dbuf_size -= TAPE_BSIZE;
 921       }
 922       Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
 923       if (dbuf_size != start_size) {
 924          Qmsg1(bs->jcr(), M_WARNING, 0,
 925                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 926       }
 927       if (dbuf_size % TAPE_BSIZE != 0) {
 928          Qmsg1(bs->jcr(), M_ABORT, 0,
 929                _("Network buffer size %d not multiple of tape block size.\n"),
 930                dbuf_size);
 931       }
 932    }
 933
 934    bs->msglen = dbuf_size;
 935    return true;
 936 }
 937
 938 /*
 939  * Set socket non-blocking
 940  * Returns previous socket flag
 941  */
 942 int bnet_set_nonblocking (BSOCK *bsock) {
 943 #ifndef HAVE_WIN32
 944    int oflags;
 945
 946    /* Get current flags */
 947    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
 948       berrno be;
 949       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
 950    }
 951
 952    /* Set O_NONBLOCK flag */
 953    if ((fcntl(bsock->fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
 954       berrno be;
 955       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
 956    }
 957
 958    bsock->blocking = 0;
 959    return oflags;
 960 #else
 961    int flags;
 962    u_long ioctlArg = 1;
 963
 964    flags = bsock->blocking;
 965    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
 966    bsock->blocking = 0;
 967
 968    return flags;
 969 #endif
 970 }
 971
 972 /*
 973  * Set socket blocking
 974  * Returns previous socket flags
 975  */
 976 int bnet_set_blocking (BSOCK *bsock)
 977 {
 978 #ifndef HAVE_WIN32
 979    int oflags;
 980    /* Get current flags */
 981    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
 982       berrno be;
 983       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
 984    }
 985
 986    /* Set O_NONBLOCK flag */
 987    if ((fcntl(bsock->fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
 988       berrno be;
 989       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
 990    }
 991
 992    bsock->blocking = 1;
 993    return oflags;
 994 #else
 995    int flags;
 996    u_long ioctlArg = 0;
 997
 998    flags = bsock->blocking;
 999    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1000    bsock->blocking = 1;
1001
1002    return flags;
1003 #endif
1004 }
1005
1006 /*
1007  * Restores socket flags
1008  */
1009 void bnet_restore_blocking (BSOCK *bsock, int flags)
1010 {
1011 #ifndef HAVE_WIN32
1012    if ((fcntl(bsock->fd, F_SETFL, flags)) < 0) {
1013       berrno be;
1014       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
1015    }
1016
1017    bsock->blocking = (flags & O_NONBLOCK);
1018 #else
1019    u_long ioctlArg = flags;
1020
1021    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1022    bsock->blocking = 1;
1023 #endif
1024 }
1025
1026
1027 /*
1028  * Send a network "signal" to the other end
1029  *  This consists of sending a negative packet length
1030  *
1031  *  Returns: false on failure
1032  *           true  on success
1033  */
1034 bool bnet_sig(BSOCK * bs, int signal)
1035 {
1036    return bs->signal(signal);
1037 }
1038
1039 /*
1040  * Convert a network "signal" code into
1041  * human readable ASCII.
1042  */
1043 const char *bnet_sig_to_ascii(BSOCK * bs)
1044 {
1045    static char buf[30];
1046    switch (bs->msglen) {
1047    case BNET_EOD:
1048       return "BNET_EOD";           /* end of data stream */
1049    case BNET_EOD_POLL:
1050       return "BNET_EOD_POLL";
1051    case BNET_STATUS:
1052       return "BNET_STATUS";
1053    case BNET_TERMINATE:
1054       return "BNET_TERMINATE";     /* terminate connection */
1055    case BNET_POLL:
1056       return "BNET_POLL";
1057    case BNET_HEARTBEAT:
1058       return "BNET_HEARTBEAT";
1059    case BNET_HB_RESPONSE:
1060       return "BNET_HB_RESPONSE";
1061    case BNET_PROMPT:
1062       return "BNET_PROMPT";
1063    default:
1064       sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
1065       return buf;
1066    }
1067 }
1068
1069
1070 /* Initialize internal socket structure.
1071  *  This probably should be done in net_open
1072  */
1073 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
1074                   struct sockaddr *client_addr)
1075 {
1076    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
1077    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
1078    memset(bsock, 0, sizeof(BSOCK));
1079    bsock->fd = sockfd;
1080    bsock->tls = NULL;
1081    bsock->errors = 0;
1082    bsock->blocking = 1;
1083    bsock->msg = get_pool_memory(PM_MESSAGE);
1084    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1085    bsock->set_who(bstrdup(who));
1086    bsock->set_host(bstrdup(host));
1087    bsock->set_port(port);
1088    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
1089    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
1090    /*
1091     * ****FIXME**** reduce this to a few hours once
1092     *   heartbeats are implemented
1093     */
1094    bsock->timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
1095    bsock->set_jcr(jcr);
1096    return bsock;
1097 }
1098
1099 BSOCK *dup_bsock(BSOCK * osock)
1100 {
1101    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
1102    memcpy(bsock, osock, sizeof(BSOCK));
1103    bsock->msg = get_pool_memory(PM_MESSAGE);
1104    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1105    if (osock->who()) {
1106       bsock->set_who(bstrdup(osock->who()));
1107    }
1108    if (osock->host()) {
1109       bsock->set_host(bstrdup(osock->host()));
1110    }
1111    bsock->duped = true;
1112    return bsock;
1113 }
1114
1115 /* Close the network connection */
1116 void bnet_close(BSOCK * bsock)
1117 {
1118    bsock->close();                    /* this calls destroy */
1119 }
1120
1121 void term_bsock(BSOCK * bsock)
1122 {
1123    bsock->destroy();
1124 }