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, utime_t 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    time_t begin_time = time(NULL);
 762    time_t now;
 763
 764    for (i = 0; (bsock = bnet_open(jcr, name, host, service, port, &fatal)) == NULL;
 765         i -= retry_interval) {
 766       berrno be;
 767       if (fatal || (jcr && job_canceled(jcr))) {
 768          return NULL;
 769       }
 770       Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
 771             name, host, port, be.strerror());
 772       if (i < 0) {
 773          i = 60 * 5;               /* complain again in 5 minutes */
 774          if (verbose)
 775             Qmsg4(jcr, M_WARNING, 0, _(
 776                "Could not connect to %s on %s:%d. ERR=%s\n"
 777                "Retrying ...\n"), name, host, port, be.strerror());
 778       }
 779       bmicrosleep(retry_interval, 0);
 780       now = time(NULL);
 781       if (begin_time + max_retry_time <= now) {
 782          Qmsg4(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"),
 783                name, host, port, be.strerror());
 784          return NULL;
 785       }
 786    }
 787    return bsock;
 788 }
 789
 790
 791 /*
 792  * Return the string for the error that occurred
 793  * on the socket. Only the first error is retained.
 794  */
 795 const char *bnet_strerror(BSOCK * bsock)
 796 {
 797    berrno be;
 798    if (bsock->errmsg == NULL) {
 799       bsock->errmsg = get_pool_memory(PM_MESSAGE);
 800    }
 801    pm_strcpy(bsock->errmsg, be.strerror(bsock->b_errno));
 802    return bsock->errmsg;
 803 }
 804
 805 /*
 806  * Format and send a message
 807  *  Returns: false on error
 808  *           true  on success
 809  */
 810 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
 811 {
 812    va_list arg_ptr;
 813    int maxlen;
 814
 815    if (bs->errors || bs->terminated) {
 816       return false;
 817    }
 818    /* This probably won't work, but we vsnprintf, then if we
 819     * get a negative length or a length greater than our buffer
 820     * (depending on which library is used), the printf was truncated, so
 821     * get a bigger buffer and try again.
 822     */
 823    for (;;) {
 824       maxlen = sizeof_pool_memory(bs->msg) - 1;
 825       va_start(arg_ptr, fmt);
 826       bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
 827       va_end(arg_ptr);
 828       if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
 829          break;
 830       }
 831       bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
 832    }
 833    return bs->send();
 834 // return bnet_send(bs);
 835 }
 836
 837 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen) {
 838 #if !defined(HAVE_WIN32)
 839     if (bs->peer_addr.sin_family == 0) {
 840         socklen_t salen = sizeof(bs->peer_addr);
 841         int rval = (getpeername)(bs->fd, (struct sockaddr *)&bs->peer_addr, &salen);
 842         if (rval < 0) return rval;
 843     }
 844     if (!inet_ntop(bs->peer_addr.sin_family, &bs->peer_addr.sin_addr, buf, buflen))
 845         return -1;
 846
 847     return 0;
 848 #else
 849     return -1;
 850 #endif
 851 }
 852 /*
 853  * Set the network buffer size, suggested size is in size.
 854  *  Actual size obtained is returned in bs->msglen
 855  *
 856  *  Returns: 0 on failure
 857  *           1 on success
 858  */
 859 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
 860 {
 861    uint32_t dbuf_size, start_size;
 862 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
 863    int opt;
 864
 865    opt = IPTOS_THROUGHPUT;
 866    setsockopt(bs->fd, IPPROTO_IP, IP_TOS, (sockopt_val_t) & opt, sizeof(opt));
 867 #endif
 868
 869    if (size != 0) {
 870       dbuf_size = size;
 871    } else {
 872       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 873    }
 874    start_size = dbuf_size;
 875    if ((bs->msg = realloc_pool_memory(bs->msg, dbuf_size + 100)) == NULL) {
 876       Qmsg0(bs->jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
 877       return false;
 878    }
 879    if (rw & BNET_SETBUF_READ) {
 880       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 881               SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 882          berrno be;
 883          Qmsg1(bs->jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 884          dbuf_size -= TAPE_BSIZE;
 885       }
 886       Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
 887       if (dbuf_size != start_size) {
 888          Qmsg1(bs->jcr(), M_WARNING, 0,
 889                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 890       }
 891       if (dbuf_size % TAPE_BSIZE != 0) {
 892          Qmsg1(bs->jcr(), M_ABORT, 0,
 893                _("Network buffer size %d not multiple of tape block size.\n"),
 894                dbuf_size);
 895       }
 896    }
 897    if (size != 0) {
 898       dbuf_size = size;
 899    } else {
 900       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 901    }
 902    start_size = dbuf_size;
 903    if (rw & BNET_SETBUF_WRITE) {
 904       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 905               SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 906          berrno be;
 907          Qmsg1(bs->jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 908          dbuf_size -= TAPE_BSIZE;
 909       }
 910       Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
 911       if (dbuf_size != start_size) {
 912          Qmsg1(bs->jcr(), M_WARNING, 0,
 913                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 914       }
 915       if (dbuf_size % TAPE_BSIZE != 0) {
 916          Qmsg1(bs->jcr(), M_ABORT, 0,
 917                _("Network buffer size %d not multiple of tape block size.\n"),
 918                dbuf_size);
 919       }
 920    }
 921
 922    bs->msglen = dbuf_size;
 923    return true;
 924 }
 925
 926 /*
 927  * Set socket non-blocking
 928  * Returns previous socket flag
 929  */
 930 int bnet_set_nonblocking (BSOCK *bsock) {
 931 #ifndef HAVE_WIN32
 932    int oflags;
 933
 934    /* Get current flags */
 935    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
 936       berrno be;
 937       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
 938    }
 939
 940    /* Set O_NONBLOCK flag */
 941    if ((fcntl(bsock->fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
 942       berrno be;
 943       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
 944    }
 945
 946    bsock->blocking = 0;
 947    return oflags;
 948 #else
 949    int flags;
 950    u_long ioctlArg = 1;
 951
 952    flags = bsock->blocking;
 953    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
 954    bsock->blocking = 0;
 955
 956    return flags;
 957 #endif
 958 }
 959
 960 /*
 961  * Set socket blocking
 962  * Returns previous socket flags
 963  */
 964 int bnet_set_blocking (BSOCK *bsock)
 965 {
 966 #ifndef HAVE_WIN32
 967    int oflags;
 968    /* Get current flags */
 969    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
 970       berrno be;
 971       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
 972    }
 973
 974    /* Set O_NONBLOCK flag */
 975    if ((fcntl(bsock->fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
 976       berrno be;
 977       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
 978    }
 979
 980    bsock->blocking = 1;
 981    return oflags;
 982 #else
 983    int flags;
 984    u_long ioctlArg = 0;
 985
 986    flags = bsock->blocking;
 987    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
 988    bsock->blocking = 1;
 989
 990    return flags;
 991 #endif
 992 }
 993
 994 /*
 995  * Restores socket flags
 996  */
 997 void bnet_restore_blocking (BSOCK *bsock, int flags)
 998 {
 999 #ifndef HAVE_WIN32
1000    if ((fcntl(bsock->fd, F_SETFL, flags)) < 0) {
1001       berrno be;
1002       Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
1003    }
1004
1005    bsock->blocking = (flags & O_NONBLOCK);
1006 #else
1007    u_long ioctlArg = flags;
1008
1009    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1010    bsock->blocking = 1;
1011 #endif
1012 }
1013
1014
1015 /*
1016  * Send a network "signal" to the other end
1017  *  This consists of sending a negative packet length
1018  *
1019  *  Returns: false on failure
1020  *           true  on success
1021  */
1022 bool bnet_sig(BSOCK * bs, int signal)
1023 {
1024    return bs->signal(signal);
1025 }
1026
1027 /*
1028  * Convert a network "signal" code into
1029  * human readable ASCII.
1030  */
1031 const char *bnet_sig_to_ascii(BSOCK * bs)
1032 {
1033    static char buf[30];
1034    switch (bs->msglen) {
1035    case BNET_EOD:
1036       return "BNET_EOD";           /* end of data stream */
1037    case BNET_EOD_POLL:
1038       return "BNET_EOD_POLL";
1039    case BNET_STATUS:
1040       return "BNET_STATUS";
1041    case BNET_TERMINATE:
1042       return "BNET_TERMINATE";     /* terminate connection */
1043    case BNET_POLL:
1044       return "BNET_POLL";
1045    case BNET_HEARTBEAT:
1046       return "BNET_HEARTBEAT";
1047    case BNET_HB_RESPONSE:
1048       return "BNET_HB_RESPONSE";
1049    case BNET_PROMPT:
1050       return "BNET_PROMPT";
1051    default:
1052       sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
1053       return buf;
1054    }
1055 }
1056
1057
1058 /* Initialize internal socket structure.
1059  *  This probably should be done in net_open
1060  */
1061 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
1062                   struct sockaddr *client_addr)
1063 {
1064    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
1065    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
1066    memset(bsock, 0, sizeof(BSOCK));
1067    bsock->fd = sockfd;
1068    bsock->tls = NULL;
1069    bsock->errors = 0;
1070    bsock->blocking = 1;
1071    bsock->msg = get_pool_memory(PM_MESSAGE);
1072    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1073    bsock->set_who(bstrdup(who));
1074    bsock->set_host(bstrdup(host));
1075    bsock->set_port(port);
1076    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
1077    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
1078    /*
1079     * ****FIXME**** reduce this to a few hours once
1080     *   heartbeats are implemented
1081     */
1082    bsock->timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
1083    bsock->set_jcr(jcr);
1084    return bsock;
1085 }
1086
1087 BSOCK *dup_bsock(BSOCK * osock)
1088 {
1089    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
1090    memcpy(bsock, osock, sizeof(BSOCK));
1091    bsock->msg = get_pool_memory(PM_MESSAGE);
1092    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1093    if (osock->who()) {
1094       bsock->set_who(bstrdup(osock->who()));
1095    }
1096    if (osock->host()) {
1097       bsock->set_host(bstrdup(osock->host()));
1098    }
1099    bsock->duped = true;
1100    return bsock;
1101 }
1102
1103 /* Close the network connection */
1104 void bnet_close(BSOCK * bsock)
1105 {
1106    bsock->close();                    /* this calls destroy */
1107 }
1108
1109 void term_bsock(BSOCK * bsock)
1110 {
1111    bsock->destroy();
1112 }