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)
 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 (!tls_postconnect_verify_host(tls, bsock->host())) {
 424       Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host %s did not match presented certificate\n"),
 425             bsock->host());
 426       goto err;
 427    }
 428    return true;
 429
 430 err:
 431    free_tls_connection(tls);
 432    bsock->tls = NULL;
 433    return false;
 434 }
 435 #else
 436 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 437 {
 438    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n"));
 439    return false;
 440 }
 441 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock)
 442 {
 443    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n"));
 444    return false;
 445 }
 446 #endif /* HAVE_TLS */
 447
 448 /*
 449  * Wait for a specified time for data to appear on
 450  * the BSOCK connection.
 451  *
 452  *   Returns: 1 if data available
 453  *            0 if timeout
 454  *           -1 if error
 455  */
 456 int bnet_wait_data(BSOCK * bsock, int sec)
 457 {
 458    fd_set fdset;
 459    struct timeval tv;
 460
 461    FD_ZERO(&fdset);
 462    FD_SET((unsigned)bsock->fd, &fdset);
 463    for (;;) {
 464       tv.tv_sec = sec;
 465       tv.tv_usec = 0;
 466       switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) {
 467       case 0:                      /* timeout */
 468          bsock->b_errno = 0;
 469          return 0;
 470       case -1:
 471          bsock->b_errno = errno;
 472          if (errno == EINTR) {
 473             continue;
 474          }
 475          return -1;                /* error return */
 476       default:
 477          bsock->b_errno = 0;
 478          return 1;
 479       }
 480    }
 481 }
 482
 483 /*
 484  * As above, but returns on interrupt
 485  */
 486 int bnet_wait_data_intr(BSOCK * bsock, int sec)
 487 {
 488    fd_set fdset;
 489    struct timeval tv;
 490
 491    FD_ZERO(&fdset);
 492    FD_SET((unsigned)bsock->fd, &fdset);
 493    tv.tv_sec = sec;
 494    tv.tv_usec = 0;
 495    switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) {
 496    case 0:                      /* timeout */
 497       bsock->b_errno = 0;
 498       return 0;
 499    case -1:
 500       bsock->b_errno = errno;
 501       return -1;                /* error return */
 502    default:
 503       bsock->b_errno = 0;
 504    }
 505    return 1;
 506 }
 507
 508 #ifndef NETDB_INTERNAL
 509 #define NETDB_INTERNAL  -1         /* See errno. */
 510 #endif
 511 #ifndef NETDB_SUCCESS
 512 #define NETDB_SUCCESS   0          /* No problem. */
 513 #endif
 514 #ifndef HOST_NOT_FOUND
 515 #define HOST_NOT_FOUND  1          /* Authoritative Answer Host not found. */
 516 #endif
 517 #ifndef TRY_AGAIN
 518 #define TRY_AGAIN       2          /* Non-Authoritative Host not found, or SERVERFAIL. */
 519 #endif
 520 #ifndef NO_RECOVERY
 521 #define NO_RECOVERY     3          /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
 522 #endif
 523 #ifndef NO_DATA
 524 #define NO_DATA         4          /* Valid name, no data record of requested type. */
 525 #endif
 526
 527 /*
 528  * Get human readable error for gethostbyname()
 529  */
 530 static const char *gethost_strerror()
 531 {
 532    const char *msg;
 533    berrno be;
 534    switch (h_errno) {
 535    case NETDB_INTERNAL:
 536       msg = be.strerror();
 537       break;
 538    case NETDB_SUCCESS:
 539       msg = _("No problem.");
 540       break;
 541    case HOST_NOT_FOUND:
 542       msg = _("Authoritative answer for host not found.");
 543       break;
 544    case TRY_AGAIN:
 545       msg = _("Non-authoritative for host not found, or ServerFail.");
 546       break;
 547    case NO_RECOVERY:
 548       msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
 549       break;
 550    case NO_DATA:
 551       msg = _("Valid name, no data record of resquested type.");
 552       break;
 553    default:
 554       msg = _("Unknown error.");
 555    }
 556    return msg;
 557 }
 558
 559
 560
 561
 562 static IPADDR *add_any(int family)
 563 {
 564    IPADDR *addr = New(IPADDR(family));
 565    addr->set_type(IPADDR::R_MULTIPLE);
 566    addr->set_addr_any();
 567    return addr;
 568 }
 569
 570 static const char *resolv_host(int family, const char *host, dlist * addr_list)
 571 {
 572    struct hostent *hp;
 573    const char *errmsg;
 574
 575    P(ip_mutex);                       /* gethostbyname() is not thread safe */
 576 #ifdef HAVE_GETHOSTBYNAME2
 577    if ((hp = gethostbyname2(host, family)) == NULL) {
 578 #else
 579    if ((hp = gethostbyname(host)) == NULL) {
 580 #endif
 581       /* may be the strerror give not the right result -:( */
 582       errmsg = gethost_strerror();
 583       V(ip_mutex);
 584       return errmsg;
 585    } else {
 586       char **p;
 587       for (p = hp->h_addr_list; *p != 0; p++) {
 588          IPADDR *addr =  New(IPADDR(hp->h_addrtype));
 589          addr->set_type(IPADDR::R_MULTIPLE);
 590          if (addr->get_family() == AF_INET) {
 591              addr->set_addr4((struct in_addr*)*p);
 592          }
 593 #ifdef HAVE_IPV6
 594          else {
 595              addr->set_addr6((struct in6_addr*)*p);
 596          }
 597 #endif
 598          addr_list->append(addr);
 599       }
 600       V(ip_mutex);
 601    }
 602    return NULL;
 603 }
 604
 605 /*
 606  * i host = 0 mean INADDR_ANY only ipv4
 607  */
 608 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
 609 {
 610    struct in_addr inaddr;
 611    IPADDR *addr = 0;
 612    const char *errmsg;
 613 #ifdef HAVE_IPV6
 614    struct in6_addr inaddr6;
 615 #endif
 616
 617    dlist *addr_list = New(dlist(addr, &addr->link));
 618    if (!host || host[0] == '\0') {
 619       if (family != 0) {
 620          addr_list->append(add_any(family));
 621       } else {
 622          addr_list->append(add_any(AF_INET));
 623 #ifdef HAVE_IPV6
 624          addr_list->append(add_any(AF_INET6));
 625 #endif
 626       }
 627    } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
 628       addr = New(IPADDR(AF_INET));
 629       addr->set_type(IPADDR::R_MULTIPLE);
 630       addr->set_addr4(&inaddr);
 631       addr_list->append(addr);
 632    } else
 633 #ifdef HAVE_IPV6
 634    if (inet_pton(AF_INET6, host, &inaddr6) > 1) {
 635       addr = New(IPADDR(AF_INET6));
 636       addr->set_type(IPADDR::R_MULTIPLE);
 637       addr->set_addr6(&inaddr6);
 638       addr_list->append(addr);
 639    } else
 640 #endif
 641    {
 642       if (family != 0) {
 643          errmsg = resolv_host(family, host, addr_list);
 644          if (errmsg) {
 645             *errstr = errmsg;
 646             free_addresses(addr_list);
 647             return 0;
 648          }
 649       } else {
 650          errmsg = resolv_host(AF_INET, host, addr_list);
 651 #ifdef HAVE_IPV6
 652          if (errmsg) {
 653             errmsg = resolv_host(AF_INET6, host, addr_list);
 654          }
 655 #endif
 656          if (errmsg) {
 657             *errstr = errmsg;
 658             free_addresses(addr_list);
 659             return 0;
 660          }
 661       }
 662    }
 663    return addr_list;
 664 }
 665
 666 /*
 667  * Open a TCP connection to the UPS network server
 668  * Returns NULL
 669  * Returns BSOCK * pointer on success
 670  *
 671  */
 672 static BSOCK *bnet_open(JCR * jcr, const char *name, char *host, char *service,
 673                         int port, int *fatal)
 674 {
 675    int sockfd = -1;
 676    dlist *addr_list;
 677    IPADDR *ipaddr;
 678    bool connected = false;
 679    int turnon = 1;
 680    const char *errstr;
 681    int save_errno = 0;
 682
 683    /*
 684     * Fill in the structure serv_addr with the address of
 685     * the server that we want to connect with.
 686     */
 687    if ((addr_list = bnet_host2ipaddrs(host, 0, &errstr)) == NULL) {
 688       /* Note errstr is not malloc'ed */
 689       Qmsg2(jcr, M_ERROR, 0, _("gethostbyname() for host \"%s\" failed: ERR=%s\n"),
 690             host, errstr);
 691       Dmsg2(100, "bnet_host2ipaddrs() for host %s failed: ERR=%s\n",
 692             host, errstr);
 693       *fatal = 1;
 694       return NULL;
 695    }
 696
 697    foreach_dlist(ipaddr, addr_list) {
 698       ipaddr->set_port_net(htons(port));
 699       char allbuf[256 * 10];
 700       char curbuf[256];
 701       Dmsg2(100, "Current %sAll %s\n",
 702                    ipaddr->build_address_str(curbuf, sizeof(curbuf)),
 703                    build_addresses_str(addr_list, allbuf, sizeof(allbuf)));
 704       /* Open a TCP socket */
 705       if ((sockfd = socket(ipaddr->get_family(), SOCK_STREAM, 0)) < 0) {
 706          berrno be;
 707          save_errno = errno;
 708          *fatal = 1;
 709          Pmsg3(000, _("Socket open error. proto=%d port=%d. ERR=%s\n"),
 710             ipaddr->get_family(), ipaddr->get_port_host_order(), be.strerror());
 711          continue;
 712       }
 713       /*
 714        * Keep socket from timing out from inactivity
 715        */
 716       if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 717          berrno be;
 718          Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 719                be.strerror());
 720       }
 721       /* connect to server */
 722       if (connect(sockfd, ipaddr->get_sockaddr(), ipaddr->get_sockaddr_len()) < 0) {
 723          save_errno = errno;
 724          socketClose(sockfd);
 725          continue;
 726       }
 727       *fatal = 0;
 728       connected = true;
 729       break;
 730    }
 731
 732    if (!connected) {
 733       free_addresses(addr_list);
 734       errno = save_errno;
 735       return NULL;
 736    }
 737    /*
 738     * Keep socket from timing out from inactivity
 739     *   Do this a second time out of paranoia
 740     */
 741    if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 742       berrno be;
 743       Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 744             be.strerror());
 745    }
 746    BSOCK* ret =  init_bsock(jcr, sockfd, name, host, port, ipaddr->get_sockaddr());
 747    free_addresses(addr_list);
 748    return ret;
 749 }
 750
 751 /*
 752  * Try to connect to host for max_retry_time at retry_time intervals.
 753  */
 754 BSOCK *bnet_connect(JCR * jcr, int retry_interval, int max_retry_time,
 755                     const char *name, char *host, char *service, int port,
 756                     int verbose)
 757 {
 758    int i;
 759    BSOCK *bsock;
 760    int fatal = 0;
 761
 762    for (i = 0; (bsock = bnet_open(jcr, name, host, service, port, &fatal)) == NULL;
 763         i -= retry_interval) {
 764       berrno be;
 765       if (fatal || (jcr && job_canceled(jcr))) {
 766          return NULL;
 767       }
 768       Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
 769             name, host, port, be.strerror());
 770       if (i < 0) {
 771          i = 60 * 5;               /* complain again in 5 minutes */
 772          if (verbose)
 773             Qmsg4(jcr, M_WARNING, 0, _(
 774                "Could not connect to %s on %s:%d. ERR=%s\n"
 775                "Retrying ...\n"), name, host, port, be.strerror());
 776       }
 777       bmicrosleep(retry_interval, 0);
 778       max_retry_time -= retry_interval;
 779       if (max_retry_time <= 0) {
 780          Qmsg4(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"),
 781                name, host, port, be.strerror());
 782          return NULL;
 783       }
 784    }
 785    return bsock;
 786 }
 787
 788
 789 /*
 790  * Return the string for the error that occurred
 791  * on the socket. Only the first error is retained.
 792  */
 793 const char *bnet_strerror(BSOCK * bsock)
 794 {
 795    berrno be;
 796    if (bsock->errmsg == NULL) {
 797       bsock->errmsg = get_pool_memory(PM_MESSAGE);
 798    }
 799    pm_strcpy(bsock->errmsg, be.strerror(bsock->b_errno));
 800    return bsock->errmsg;
 801 }
 802
 803 /*
 804  * Format and send a message
 805  *  Returns: false on error
 806  *           true  on success
 807  */
 808 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
 809 {
 810    va_list arg_ptr;
 811    int maxlen;
 812
 813    if (bs->errors || bs->terminated) {
 814       return false;
 815    }
 816    /* This probably won't work, but we vsnprintf, then if we
 817     * get a negative length or a length greater than our buffer
 818     * (depending on which library is used), the printf was truncated, so
 819     * get a bigger buffer and try again.
 820     */
 821    for (;;) {
 822       maxlen = sizeof_pool_memory(bs->msg) - 1;
 823       va_start(arg_ptr, fmt);
 824       bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
 825       va_end(arg_ptr);
 826       if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
 827          break;
 828       }
 829       bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
 830    }
 831    return bs->send();
 832 // return bnet_send(bs);
 833 }
 834
 835 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen) {
 836 #if !defined(HAVE_WIN32)
 837     if (bs->peer_addr.sin_family == 0) {
 838         socklen_t salen = sizeof(bs->peer_addr);
 839         int rval = (getpeername)(bs->fd, (struct sockaddr *)&bs->peer_addr, &salen);
 840         if (rval < 0) return rval;
 841     }
 842     if (!inet_ntop(bs->peer_addr.sin_family, &bs->peer_addr.sin_addr, buf, buflen))
 843         return -1;
 844
 845     return 0;
 846 #else
 847     return -1;
 848 #endif
 849 }
 850 /*
 851  * Set the network buffer size, suggested size is in size.
 852  *  Actual size obtained is returned in bs->msglen
 853  *
 854  *  Returns: 0 on failure
 855  *           1 on success
 856  */
 857 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
 858 {
 859    uint32_t dbuf_size, start_size;
 860 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
 861    int opt;
 862
 863    opt = IPTOS_THROUGHPUT;
 864    setsockopt(bs->fd, IPPROTO_IP, IP_TOS, (sockopt_val_t) & opt, sizeof(opt));
 865 #endif
 866
 867    if (size != 0) {
 868       dbuf_size = size;
 869    } else {
 870       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 871    }
 872    start_size = dbuf_size;
 873    if ((bs->msg = realloc_pool_memory(bs->msg, dbuf_size + 100)) == NULL) {
 874       Qmsg0(bs->jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
 875       return false;
 876    }
 877    if (rw & BNET_SETBUF_READ) {
 878       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 879               SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 880          berrno be;
 881          Qmsg1(bs->jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 882          dbuf_size -= TAPE_BSIZE;
 883       }
 884       Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
 885       if (dbuf_size != start_size) {
 886          Qmsg1(bs->jcr(), M_WARNING, 0,
 887                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 888       }
 889       if (dbuf_size % TAPE_BSIZE != 0) {
 890          Qmsg1(bs->jcr(), M_ABORT, 0,
 891                _("Network buffer size %d not multiple of tape block size.\n"),
 892                dbuf_size);
 893       }
 894    }
 895    if (size != 0) {
 896       dbuf_size = size;
 897    } else {
 898       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 899    }
 900    start_size = dbuf_size;
 901    if (rw & BNET_SETBUF_WRITE) {
 902       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 903               SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 904          berrno be;
 905          Qmsg1(bs->jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 906          dbuf_size -= TAPE_BSIZE;
 907       }
 908       Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
 909       if (dbuf_size != start_size) {
 910          Qmsg1(bs->jcr(), M_WARNING, 0,
 911                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 912       }
 913       if (dbuf_size % TAPE_BSIZE != 0) {
 914          Qmsg1(bs->jcr(), M_ABORT, 0,
 915                _("Network buffer size %d not multiple of tape block size.\n"),
 916                dbuf_size);
 917       }
 918    }
 919
 920    bs->msglen = dbuf_size;
 921    return true;
 922 }
 923
 924 /*
 925  * Set socket non-blocking
 926  * Returns previous socket flag
 927  */
 928 int bnet_set_nonblocking (BSOCK *bsock) {
 929 #ifndef HAVE_WIN32
 930    int oflags;
 931
 932    /* Get current flags */
 933    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
 934       berrno be;
 935       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
 936    }
 937
 938    /* Set O_NONBLOCK flag */
 939    if ((fcntl(bsock->fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
 940       berrno be;
 941       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
 942    }
 943
 944    bsock->blocking = 0;
 945    return oflags;
 946 #else
 947    int flags;
 948    u_long ioctlArg = 1;
 949
 950    flags = bsock->blocking;
 951    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
 952    bsock->blocking = 0;
 953
 954    return flags;
 955 #endif
 956 }
 957
 958 /*
 959  * Set socket blocking
 960  * Returns previous socket flags
 961  */
 962 int bnet_set_blocking (BSOCK *bsock)
 963 {
 964 #ifndef HAVE_WIN32
 965    int oflags;
 966    /* Get current flags */
 967    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
 968       berrno be;
 969       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
 970    }
 971
 972    /* Set O_NONBLOCK flag */
 973    if ((fcntl(bsock->fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
 974       berrno be;
 975       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
 976    }
 977
 978    bsock->blocking = 1;
 979    return oflags;
 980 #else
 981    int flags;
 982    u_long ioctlArg = 0;
 983
 984    flags = bsock->blocking;
 985    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
 986    bsock->blocking = 1;
 987
 988    return flags;
 989 #endif
 990 }
 991
 992 /*
 993  * Restores socket flags
 994  */
 995 void bnet_restore_blocking (BSOCK *bsock, int flags)
 996 {
 997 #ifndef HAVE_WIN32
 998    if ((fcntl(bsock->fd, F_SETFL, flags)) < 0) {
 999       berrno be;
1000       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
1001    }
1002
1003    bsock->blocking = (flags & O_NONBLOCK);
1004 #else
1005    u_long ioctlArg = flags;
1006
1007    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1008    bsock->blocking = 1;
1009 #endif
1010 }
1011
1012
1013 /*
1014  * Send a network "signal" to the other end
1015  *  This consists of sending a negative packet length
1016  *
1017  *  Returns: false on failure
1018  *           true  on success
1019  */
1020 bool bnet_sig(BSOCK * bs, int signal)
1021 {
1022    return bs->signal(signal);
1023 }
1024
1025 /*
1026  * Convert a network "signal" code into
1027  * human readable ASCII.
1028  */
1029 const char *bnet_sig_to_ascii(BSOCK * bs)
1030 {
1031    static char buf[30];
1032    switch (bs->msglen) {
1033    case BNET_EOD:
1034       return "BNET_EOD";           /* end of data stream */
1035    case BNET_EOD_POLL:
1036       return "BNET_EOD_POLL";
1037    case BNET_STATUS:
1038       return "BNET_STATUS";
1039    case BNET_TERMINATE:
1040       return "BNET_TERMINATE";     /* terminate connection */
1041    case BNET_POLL:
1042       return "BNET_POLL";
1043    case BNET_HEARTBEAT:
1044       return "BNET_HEARTBEAT";
1045    case BNET_HB_RESPONSE:
1046       return "BNET_HB_RESPONSE";
1047    case BNET_PROMPT:
1048       return "BNET_PROMPT";
1049    default:
1050       sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
1051       return buf;
1052    }
1053 }
1054
1055
1056 /* Initialize internal socket structure.
1057  *  This probably should be done in net_open
1058  */
1059 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
1060                   struct sockaddr *client_addr)
1061 {
1062    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
1063    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
1064    memset(bsock, 0, sizeof(BSOCK));
1065    bsock->fd = sockfd;
1066    bsock->tls = NULL;
1067    bsock->errors = 0;
1068    bsock->blocking = 1;
1069    bsock->msg = get_pool_memory(PM_MESSAGE);
1070    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1071    bsock->set_who(bstrdup(who));
1072    bsock->set_host(bstrdup(host));
1073    bsock->set_port(port);
1074    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
1075    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
1076    /*
1077     * ****FIXME**** reduce this to a few hours once
1078     *   heartbeats are implemented
1079     */
1080    bsock->timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
1081    bsock->set_jcr(jcr);
1082    return bsock;
1083 }
1084
1085 BSOCK *dup_bsock(BSOCK * osock)
1086 {
1087    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
1088    memcpy(bsock, osock, sizeof(BSOCK));
1089    bsock->msg = get_pool_memory(PM_MESSAGE);
1090    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1091    if (osock->who()) {
1092       bsock->set_who(bstrdup(osock->who()));
1093    }
1094    if (osock->host()) {
1095       bsock->set_host(bstrdup(osock->host()));
1096    }
1097    bsock->duped = true;
1098    return bsock;
1099 }
1100
1101 /* Close the network connection */
1102 void bnet_close(BSOCK * bsock)
1103 {
1104    bsock->close();                    /* this calls destroy */
1105 }
1106
1107 void term_bsock(BSOCK * bsock)
1108 {
1109    bsock->destroy();
1110 }