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

   1 /*
   2  * Network Utility Routines
   3  *
   4  *  by Kern Sibbald
   5  *
   6  * Adapted and enhanced for Bacula, originally written
   7  * for inclusion in the Apcupsd package
   8  *
   9  *   Version $Id$
  10  */
  11 /*
  12    Bacula® - The Network Backup Solution
  13
  14    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
  15
  16    The main author of Bacula is Kern Sibbald, with contributions from
  17    many others, a complete list can be found in the file AUTHORS.
  18    This program is Free Software; you can redistribute it and/or
  19    modify it under the terms of version two of the GNU General Public
  20    License as published by the Free Software Foundation plus additions
  21    that are listed in the file LICENSE.
  22
  23    This program is distributed in the hope that it will be useful, but
  24    WITHOUT ANY WARRANTY; without even the implied warranty of
  25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  26    General Public License for more details.
  27
  28    You should have received a copy of the GNU General Public License
  29    along with this program; if not, write to the Free Software
  30    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  31    02110-1301, USA.
  32
  33    Bacula® is a registered trademark of John Walker.
  34    The licensor of Bacula is the Free Software Foundation Europe
  35    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  36    Switzerland, email:ftf@fsfeurope.org.
  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 static 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 static 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    int32_t nbytes;
 192    int32_t pktsiz;
 193
 194    if (!bsock) {
 195       return BNET_HARDEOF;
 196    }
 197    bsock->msg[0] = 0;
 198    bsock->msglen = 0;
 199    if (bsock->errors || bsock->terminated) {
 200       return BNET_HARDEOF;
 201    }
 202
 203    bsock->read_seqno++;            /* bump sequence number */
 204    bsock->timer_start = watchdog_time;  /* set start wait time */
 205    bsock->timed_out = 0;
 206    /* get data size -- in int32_t */
 207    if ((nbytes = read_nbytes(bsock, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
 208       bsock->timer_start = 0;      /* clear timer */
 209       /* probably pipe broken because client died */
 210       if (errno == 0) {
 211          bsock->b_errno = ENODATA;
 212       } else {
 213          bsock->b_errno = errno;
 214       }
 215       bsock->errors++;
 216       return BNET_HARDEOF;         /* assume hard EOF received */
 217    }
 218    bsock->timer_start = 0;         /* clear timer */
 219    if (nbytes != sizeof(int32_t)) {
 220       bsock->errors++;
 221       bsock->b_errno = EIO;
 222       Qmsg5(bsock->jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
 223             sizeof(int32_t), nbytes, bsock->who, bsock->host, bsock->port);
 224       return BNET_ERROR;
 225    }
 226
 227    pktsiz = ntohl(pktsiz);         /* decode no. of bytes that follow */
 228
 229    if (pktsiz == 0) {              /* No data transferred */
 230       bsock->timer_start = 0;      /* clear timer */
 231       bsock->in_msg_no++;
 232       bsock->msglen = 0;
 233       return 0;                    /* zero bytes read */
 234    }
 235
 236    /* If signal or packet size too big */
 237    if (pktsiz < 0 || pktsiz > 1000000) {
 238       if (pktsiz > 0) {            /* if packet too big */
 239          Qmsg3(bsock->jcr, M_FATAL, 0,
 240                _("Packet size too big from \"%s:%s:%d. Terminating connection.\n"),
 241                bsock->who, bsock->host, bsock->port);
 242          pktsiz = BNET_TERMINATE;  /* hang up */
 243       }
 244       if (pktsiz == BNET_TERMINATE) {
 245          bsock->terminated = 1;
 246       }
 247       bsock->timer_start = 0;      /* clear timer */
 248       bsock->b_errno = ENODATA;
 249       bsock->msglen = pktsiz;      /* signal code */
 250       return BNET_SIGNAL;          /* signal */
 251    }
 252
 253    /* Make sure the buffer is big enough + one byte for EOS */
 254    if (pktsiz >= (int32_t) sizeof_pool_memory(bsock->msg)) {
 255       bsock->msg = realloc_pool_memory(bsock->msg, pktsiz + 100);
 256    }
 257
 258    bsock->timer_start = watchdog_time;  /* set start wait time */
 259    bsock->timed_out = 0;
 260    /* now read the actual data */
 261    if ((nbytes = read_nbytes(bsock, bsock->msg, pktsiz)) <= 0) {
 262       bsock->timer_start = 0;      /* clear timer */
 263       if (errno == 0) {
 264          bsock->b_errno = ENODATA;
 265       } else {
 266          bsock->b_errno = errno;
 267       }
 268       bsock->errors++;
 269       Qmsg4(bsock->jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"),
 270             bsock->who, bsock->host, bsock->port, bnet_strerror(bsock));
 271       return BNET_ERROR;
 272    }
 273    bsock->timer_start = 0;         /* clear timer */
 274    bsock->in_msg_no++;
 275    bsock->msglen = nbytes;
 276    if (nbytes != pktsiz) {
 277       bsock->b_errno = EIO;
 278       bsock->errors++;
 279       Qmsg5(bsock->jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
 280             pktsiz, nbytes, bsock->who, bsock->host, bsock->port);
 281       return BNET_ERROR;
 282    }
 283    /* always add a zero by to properly terminate any
 284     * string that was send to us. Note, we ensured above that the
 285     * buffer is at least one byte longer than the message length.
 286     */
 287    bsock->msg[nbytes] = 0; /* terminate in case it is a string */
 288    sm_check(__FILE__, __LINE__, false);
 289    return nbytes;                  /* return actual length of message */
 290 }
 291
 292
 293 /*
 294  * Return 1 if there are errors on this bsock or it is closed,
 295  *   i.e. stop communicating on this line.
 296  */
 297 bool is_bnet_stop(BSOCK * bsock)
 298 {
 299    return bsock->errors || bsock->terminated;
 300 }
 301
 302 /*
 303  * Return number of errors on socket
 304  */
 305 int is_bnet_error(BSOCK * bsock)
 306 {
 307    errno = bsock->b_errno;
 308    return bsock->errors;
 309 }
 310
 311 /*
 312  * Call here after error during closing to suppress error
 313  *  messages which are due to the other end shutting down too.
 314  */
 315 void bnet_suppress_error_messages(BSOCK * bsock, bool flag)
 316 {
 317    bsock->suppress_error_msgs = flag;
 318 }
 319
 320
 321 /*
 322  * Transmit spooled data now to a BSOCK
 323  */
 324 int bnet_despool_to_bsock(BSOCK * bsock, void update_attr_spool_size(ssize_t size),
 325                           ssize_t tsize)
 326 {
 327    int32_t pktsiz;
 328    size_t nbytes;
 329    ssize_t last = 0, size = 0;
 330    int count = 0;
 331
 332    rewind(bsock->spool_fd);
 333    while (fread((char *)&pktsiz, 1, sizeof(int32_t), bsock->spool_fd) ==
 334           sizeof(int32_t)) {
 335       size += sizeof(int32_t);
 336       bsock->msglen = ntohl(pktsiz);
 337       if (bsock->msglen > 0) {
 338          if (bsock->msglen > (int32_t) sizeof_pool_memory(bsock->msg)) {
 339             bsock->msg = realloc_pool_memory(bsock->msg, bsock->msglen + 1);
 340          }
 341          nbytes = fread(bsock->msg, 1, bsock->msglen, bsock->spool_fd);
 342          if (nbytes != (size_t) bsock->msglen) {
 343             berrno be;
 344             Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, bsock->msglen);
 345             Qmsg1(bsock->jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
 346                   be.strerror());
 347             update_attr_spool_size(tsize - last);
 348             return 0;
 349          }
 350          size += nbytes;
 351          if ((++count & 0x3F) == 0) {
 352             update_attr_spool_size(size - last);
 353             last = size;
 354          }
 355       }
 356       bnet_send(bsock);
 357    }
 358    update_attr_spool_size(tsize - last);
 359    if (ferror(bsock->spool_fd)) {
 360       berrno be;
 361       Qmsg1(bsock->jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
 362             be.strerror());
 363       return 0;
 364    }
 365    return 1;
 366 }
 367
 368
 369 /*
 370  * Send a message over the network. The send consists of
 371  * two network packets. The first is sends a 32 bit integer containing
 372  * the length of the data packet which follows.
 373  *
 374  * Returns: false on failure
 375  *          true  on success
 376  */
 377 bool bnet_send(BSOCK * bsock)
 378 {
 379    int32_t rc;
 380    int32_t pktsiz;
 381
 382    if (bsock->errors || bsock->terminated || bsock->msglen > 1000000) {
 383       return false;
 384    }
 385    pktsiz = htonl((int32_t) bsock->msglen);
 386    /* send int32_t containing size of data packet */
 387    bsock->timer_start = watchdog_time;  /* start timer */
 388    bsock->timed_out = 0;
 389    rc = write_nbytes(bsock, (char *)&pktsiz, sizeof(int32_t));
 390    bsock->timer_start = 0;         /* clear timer */
 391    if (rc != sizeof(int32_t)) {
 392       if (bsock->msglen == BNET_TERMINATE) {    /* if we were terminating */
 393          bsock->terminated = 1;
 394          return false;             /* ignore any errors */
 395       }
 396       bsock->errors++;
 397       if (errno == 0) {
 398          bsock->b_errno = EIO;
 399       } else {
 400          bsock->b_errno = errno;
 401       }
 402       if (rc < 0) {
 403          if (!bsock->suppress_error_msgs && !bsock->timed_out) {
 404             Qmsg4(bsock->jcr, M_ERROR, 0,
 405                   _("Write error sending len to %s:%s:%d: ERR=%s\n"), bsock->who,
 406                   bsock->host, bsock->port, bnet_strerror(bsock));
 407          }
 408       } else {
 409          Qmsg5(bsock->jcr, M_ERROR, 0,
 410                _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
 411                sizeof(int32_t), bsock->who,
 412                bsock->host, bsock->port, rc);
 413       }
 414       return false;
 415    }
 416
 417    bsock->out_msg_no++;            /* increment message number */
 418    if (bsock->msglen <= 0) {       /* length only? */
 419       return true;                 /* yes, no data */
 420    }
 421
 422    /* send data packet */
 423    bsock->timer_start = watchdog_time;  /* start timer */
 424    bsock->timed_out = 0;
 425    rc = write_nbytes(bsock, bsock->msg, bsock->msglen);
 426    bsock->timer_start = 0;         /* clear timer */
 427    if (rc != bsock->msglen) {
 428       bsock->errors++;
 429       if (errno == 0) {
 430          bsock->b_errno = EIO;
 431       } else {
 432          bsock->b_errno = errno;
 433       }
 434       if (rc < 0) {
 435          if (!bsock->suppress_error_msgs) {
 436             Qmsg5(bsock->jcr, M_ERROR, 0,
 437                   _("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"),
 438                   bsock->msglen, bsock->who,
 439                   bsock->host, bsock->port, bnet_strerror(bsock));
 440          }
 441       } else {
 442          Qmsg5(bsock->jcr, M_ERROR, 0,
 443                _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
 444                bsock->msglen, bsock->who, bsock->host, bsock->port, rc);
 445       }
 446       return false;
 447    }
 448    return true;
 449 }
 450
 451 /*
 452  * Establish a TLS connection -- server side
 453  *  Returns: true  on success
 454  *           false on failure
 455  */
 456 #ifdef HAVE_TLS
 457 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 458 {
 459    TLS_CONNECTION *tls;
 460
 461    tls = new_tls_connection(ctx, bsock->fd);
 462    if (!tls) {
 463       Qmsg0(bsock->jcr, M_FATAL, 0, _("TLS connection initialization failed.\n"));
 464       return false;
 465    }
 466
 467    bsock->tls = tls;
 468
 469    /* Initiate TLS Negotiation */
 470    if (!tls_bsock_accept(bsock)) {
 471       Qmsg0(bsock->jcr, M_FATAL, 0, _("TLS Negotiation failed.\n"));
 472       goto err;
 473    }
 474
 475    if (verify_list) {
 476       if (!tls_postconnect_verify_cn(tls, verify_list)) {
 477          Qmsg1(bsock->jcr, M_FATAL, 0, _("TLS certificate verification failed."
 478                                          " Peer certificate did not match a required commonName\n"),
 479                                          bsock->host);
 480          goto err;
 481       }
 482    }
 483    return true;
 484
 485 err:
 486    free_tls_connection(tls);
 487    bsock->tls = NULL;
 488    return false;
 489 }
 490
 491 /*
 492  * Establish a TLS connection -- client side
 493  * Returns: true  on success
 494  *          false on failure
 495  */
 496 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock)
 497 {
 498    TLS_CONNECTION *tls;
 499
 500    tls  = new_tls_connection(ctx, bsock->fd);
 501    if (!tls) {
 502       Qmsg0(bsock->jcr, M_FATAL, 0, _("TLS connection initialization failed.\n"));
 503       return false;
 504    }
 505
 506    bsock->tls = tls;
 507
 508    /* Initiate TLS Negotiation */
 509    if (!tls_bsock_connect(bsock)) {
 510       goto err;
 511    }
 512
 513    if (!tls_postconnect_verify_host(tls, bsock->host)) {
 514       Qmsg1(bsock->jcr, M_FATAL, 0, _("TLS host certificate verification failed. Host %s did not match presented certificate\n"), bsock->host);
 515       goto err;
 516    }
 517    return true;
 518
 519 err:
 520    free_tls_connection(tls);
 521    bsock->tls = NULL;
 522    return false;
 523 }
 524 #else
 525 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 526 {
 527    Jmsg(bsock->jcr, M_ABORT, 0, _("TLS enabled but not configured.\n"));
 528    return false;
 529 }
 530 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock)
 531 {
 532    Jmsg(bsock->jcr, M_ABORT, 0, _("TLS enable but not configured.\n"));
 533    return false;
 534 }
 535 #endif /* HAVE_TLS */
 536
 537 /*
 538  * Wait for a specified time for data to appear on
 539  * the BSOCK connection.
 540  *
 541  *   Returns: 1 if data available
 542  *            0 if timeout
 543  *           -1 if error
 544  */
 545 int bnet_wait_data(BSOCK * bsock, int sec)
 546 {
 547    fd_set fdset;
 548    struct timeval tv;
 549
 550    FD_ZERO(&fdset);
 551    FD_SET((unsigned)bsock->fd, &fdset);
 552    for (;;) {
 553       tv.tv_sec = sec;
 554       tv.tv_usec = 0;
 555       switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) {
 556       case 0:                      /* timeout */
 557          bsock->b_errno = 0;
 558          return 0;
 559       case -1:
 560          bsock->b_errno = errno;
 561          if (errno == EINTR) {
 562             continue;
 563          }
 564          return -1;                /* error return */
 565       default:
 566          bsock->b_errno = 0;
 567          return 1;
 568       }
 569    }
 570 }
 571
 572 /*
 573  * As above, but returns on interrupt
 574  */
 575 int bnet_wait_data_intr(BSOCK * bsock, int sec)
 576 {
 577    fd_set fdset;
 578    struct timeval tv;
 579
 580    FD_ZERO(&fdset);
 581    FD_SET((unsigned)bsock->fd, &fdset);
 582    tv.tv_sec = sec;
 583    tv.tv_usec = 0;
 584    switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) {
 585    case 0:                      /* timeout */
 586       bsock->b_errno = 0;
 587       return 0;
 588    case -1:
 589       bsock->b_errno = errno;
 590       return -1;                /* error return */
 591    default:
 592       bsock->b_errno = 0;
 593    }
 594    return 1;
 595 }
 596
 597 #ifndef NETDB_INTERNAL
 598 #define NETDB_INTERNAL  -1         /* See errno. */
 599 #endif
 600 #ifndef NETDB_SUCCESS
 601 #define NETDB_SUCCESS   0          /* No problem. */
 602 #endif
 603 #ifndef HOST_NOT_FOUND
 604 #define HOST_NOT_FOUND  1          /* Authoritative Answer Host not found. */
 605 #endif
 606 #ifndef TRY_AGAIN
 607 #define TRY_AGAIN       2          /* Non-Authoritative Host not found, or SERVERFAIL. */
 608 #endif
 609 #ifndef NO_RECOVERY
 610 #define NO_RECOVERY     3          /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
 611 #endif
 612 #ifndef NO_DATA
 613 #define NO_DATA         4          /* Valid name, no data record of requested type. */
 614 #endif
 615
 616 /*
 617  * Get human readable error for gethostbyname()
 618  */
 619 static const char *gethost_strerror()
 620 {
 621    const char *msg;
 622    berrno be;
 623    switch (h_errno) {
 624    case NETDB_INTERNAL:
 625       msg = be.strerror();
 626       break;
 627    case NETDB_SUCCESS:
 628       msg = _("No problem.");
 629       break;
 630    case HOST_NOT_FOUND:
 631       msg = _("Authoritative answer for host not found.");
 632       break;
 633    case TRY_AGAIN:
 634       msg = _("Non-authoritative for host not found, or ServerFail.");
 635       break;
 636    case NO_RECOVERY:
 637       msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
 638       break;
 639    case NO_DATA:
 640       msg = _("Valid name, no data record of resquested type.");
 641       break;
 642    default:
 643       msg = _("Unknown error.");
 644    }
 645    return msg;
 646 }
 647
 648
 649
 650
 651 static IPADDR *add_any(int family)
 652 {
 653    IPADDR *addr = New(IPADDR(family));
 654    addr->set_type(IPADDR::R_MULTIPLE);
 655    addr->set_addr_any();
 656    return addr;
 657 }
 658
 659 static const char *resolv_host(int family, const char *host, dlist * addr_list)
 660 {
 661    struct hostent *hp;
 662    const char *errmsg;
 663
 664    P(ip_mutex);
 665 #ifdef HAVE_GETHOSTBYNAME2
 666    if ((hp = gethostbyname2(host, family)) == NULL) {
 667 #else
 668    if ((hp = gethostbyname(host)) == NULL) {
 669 #endif
 670       /* may be the strerror give not the right result -:( */
 671       errmsg = gethost_strerror();
 672       V(ip_mutex);
 673       return errmsg;
 674    } else {
 675       char **p;
 676       for (p = hp->h_addr_list; *p != 0; p++) {
 677          IPADDR *addr =  New(IPADDR(hp->h_addrtype));
 678          addr->set_type(IPADDR::R_MULTIPLE);
 679          if (addr->get_family() == AF_INET) {
 680              addr->set_addr4((struct in_addr*)*p);
 681          }
 682 #ifdef HAVE_IPV6
 683          else {
 684              addr->set_addr6((struct in6_addr*)*p);
 685          }
 686 #endif
 687          addr_list->append(addr);
 688       }
 689       V(ip_mutex);
 690    }
 691    return NULL;
 692 }
 693
 694 /*
 695  * i host = 0 mean INADDR_ANY only ipv4
 696  */
 697 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
 698 {
 699    struct in_addr inaddr;
 700    IPADDR *addr = 0;
 701    const char *errmsg;
 702 #ifdef HAVE_IPV6
 703    struct in6_addr inaddr6;
 704 #endif
 705
 706    dlist *addr_list = New(dlist(addr, &addr->link));
 707    if (!host || host[0] == '\0') {
 708       if (family != 0) {
 709          addr_list->append(add_any(family));
 710       } else {
 711          addr_list->append(add_any(AF_INET));
 712 #ifdef HAVE_IPV6
 713          addr_list->append(add_any(AF_INET6));
 714 #endif
 715       }
 716    } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
 717       addr = New(IPADDR(AF_INET));
 718       addr->set_type(IPADDR::R_MULTIPLE);
 719       addr->set_addr4(&inaddr);
 720       addr_list->append(addr);
 721    } else
 722 #ifdef HAVE_IPV6
 723    if (inet_pton(AF_INET6, host, &inaddr6) > 1) {
 724       addr = New(IPADDR(AF_INET6));
 725       addr->set_type(IPADDR::R_MULTIPLE);
 726       addr->set_addr6(&inaddr6);
 727       addr_list->append(addr);
 728    } else
 729 #endif
 730    {
 731       if (family != 0) {
 732          errmsg = resolv_host(family, host, addr_list);
 733          if (errmsg) {
 734             *errstr = errmsg;
 735             free_addresses(addr_list);
 736             return 0;
 737          }
 738       } else {
 739          errmsg = resolv_host(AF_INET, host, addr_list);
 740 #ifdef HAVE_IPV6
 741          if (errmsg) {
 742             errmsg = resolv_host(AF_INET6, host, addr_list);
 743          }
 744 #endif
 745          if (errmsg) {
 746             *errstr = errmsg;
 747             free_addresses(addr_list);
 748             return 0;
 749          }
 750       }
 751    }
 752    return addr_list;
 753 }
 754
 755 /*
 756  * Open a TCP connection to the UPS network server
 757  * Returns NULL
 758  * Returns BSOCK * pointer on success
 759  *
 760  */
 761 static BSOCK *bnet_open(JCR * jcr, const char *name, char *host, char *service,
 762                         int port, int *fatal)
 763 {
 764    int sockfd = -1;
 765    dlist *addr_list;
 766    IPADDR *ipaddr;
 767    bool connected = false;
 768    int turnon = 1;
 769    const char *errstr;
 770    int save_errno = 0;
 771
 772    /*
 773     * Fill in the structure serv_addr with the address of
 774     * the server that we want to connect with.
 775     */
 776    if ((addr_list = bnet_host2ipaddrs(host, 0, &errstr)) == NULL) {
 777       /* Note errstr is not malloc'ed */
 778       Qmsg2(jcr, M_ERROR, 0, _("gethostbyname() for host \"%s\" failed: ERR=%s\n"),
 779             host, errstr);
 780       Dmsg2(100, "bnet_host2ipaddrs() for host %s failed: ERR=%s\n",
 781             host, errstr);
 782       *fatal = 1;
 783       return NULL;
 784    }
 785
 786    foreach_dlist(ipaddr, addr_list) {
 787       ipaddr->set_port_net(htons(port));
 788       char allbuf[256 * 10];
 789       char curbuf[256];
 790       Dmsg2(100, "Current %sAll %s\n",
 791                    ipaddr->build_address_str(curbuf, sizeof(curbuf)),
 792                    build_addresses_str(addr_list, allbuf, sizeof(allbuf)));
 793       /* Open a TCP socket */
 794       if ((sockfd = socket(ipaddr->get_family(), SOCK_STREAM, 0)) < 0) {
 795          berrno be;
 796          save_errno = errno;
 797          *fatal = 1;
 798          Pmsg3(000, _("Socket open error. proto=%d port=%d. ERR=%s\n"),
 799             ipaddr->get_family(), ipaddr->get_port_host_order(), be.strerror());
 800          continue;
 801       }
 802       /*
 803        * Keep socket from timing out from inactivity
 804        */
 805       if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 806          berrno be;
 807          Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 808                be.strerror());
 809       }
 810       /* connect to server */
 811       if (connect(sockfd, ipaddr->get_sockaddr(), ipaddr->get_sockaddr_len()) < 0) {
 812          save_errno = errno;
 813          socketClose(sockfd);
 814          continue;
 815       }
 816       *fatal = 0;
 817       connected = true;
 818       break;
 819    }
 820
 821    if (!connected) {
 822       free_addresses(addr_list);
 823       errno = save_errno;
 824       return NULL;
 825    }
 826    /*
 827     * Keep socket from timing out from inactivity
 828     *   Do this a second time out of paranoia
 829     */
 830    if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 831       berrno be;
 832       Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 833             be.strerror());
 834    }
 835    BSOCK* ret =  init_bsock(jcr, sockfd, name, host, port, ipaddr->get_sockaddr());
 836    free_addresses(addr_list);
 837    return ret;
 838 }
 839
 840 /*
 841  * Try to connect to host for max_retry_time at retry_time intervals.
 842  */
 843 BSOCK *bnet_connect(JCR * jcr, int retry_interval, int max_retry_time,
 844                     const char *name, char *host, char *service, int port,
 845                     int verbose)
 846 {
 847    int i;
 848    BSOCK *bsock;
 849    int fatal = 0;
 850
 851    for (i = 0; (bsock = bnet_open(jcr, name, host, service, port, &fatal)) == NULL;
 852         i -= retry_interval) {
 853       berrno be;
 854       if (fatal || (jcr && job_canceled(jcr))) {
 855          return NULL;
 856       }
 857       Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
 858             name, host, port, be.strerror());
 859       if (i < 0) {
 860          i = 60 * 5;               /* complain again in 5 minutes */
 861          if (verbose)
 862             Qmsg4(jcr, M_WARNING, 0, _(
 863                "Could not connect to %s on %s:%d. ERR=%s\n"
 864                "Retrying ...\n"), name, host, port, be.strerror());
 865       }
 866       bmicrosleep(retry_interval, 0);
 867       max_retry_time -= retry_interval;
 868       if (max_retry_time <= 0) {
 869          Qmsg4(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"),
 870                name, host, port, be.strerror());
 871          return NULL;
 872       }
 873    }
 874    return bsock;
 875 }
 876
 877
 878 /*
 879  * Return the string for the error that occurred
 880  * on the socket. Only the first error is retained.
 881  */
 882 const char *bnet_strerror(BSOCK * bsock)
 883 {
 884    berrno be;
 885    if (bsock->errmsg == NULL) {
 886       bsock->errmsg = get_pool_memory(PM_MESSAGE);
 887    }
 888    pm_strcpy(bsock->errmsg, be.strerror(bsock->b_errno));
 889    return bsock->errmsg;
 890 }
 891
 892 /*
 893  * Format and send a message
 894  *  Returns: false on error
 895  *           true  on success
 896  */
 897 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
 898 {
 899    va_list arg_ptr;
 900    int maxlen;
 901
 902    if (bs->errors || bs->terminated) {
 903       return false;
 904    }
 905    /* This probably won't work, but we vsnprintf, then if we
 906     * get a negative length or a length greater than our buffer
 907     * (depending on which library is used), the printf was truncated, so
 908     * get a bigger buffer and try again.
 909     */
 910    for (;;) {
 911       maxlen = sizeof_pool_memory(bs->msg) - 1;
 912       va_start(arg_ptr, fmt);
 913       bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
 914       va_end(arg_ptr);
 915       if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
 916          break;
 917       }
 918       bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
 919    }
 920    return bnet_send(bs);
 921 }
 922
 923 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen) {
 924 #if !defined(HAVE_WIN32)
 925     if (bs->peer_addr.sin_family == 0) {
 926         socklen_t salen = sizeof(bs->peer_addr);
 927         int rval = (getpeername)(bs->fd, (struct sockaddr *)&bs->peer_addr, &salen);
 928         if (rval < 0) return rval;
 929     }
 930     if (!inet_ntop(bs->peer_addr.sin_family, &bs->peer_addr.sin_addr, buf, buflen))
 931         return -1;
 932
 933     return 0;
 934 #else
 935     return -1;
 936 #endif
 937 }
 938 /*
 939  * Set the network buffer size, suggested size is in size.
 940  *  Actual size obtained is returned in bs->msglen
 941  *
 942  *  Returns: 0 on failure
 943  *           1 on success
 944  */
 945 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
 946 {
 947    uint32_t dbuf_size, start_size;
 948 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
 949    int opt;
 950
 951    opt = IPTOS_THROUGHPUT;
 952    setsockopt(bs->fd, IPPROTO_IP, IP_TOS, (sockopt_val_t) & opt, sizeof(opt));
 953 #endif
 954
 955    if (size != 0) {
 956       dbuf_size = size;
 957    } else {
 958       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 959    }
 960    start_size = dbuf_size;
 961    if ((bs->msg = realloc_pool_memory(bs->msg, dbuf_size + 100)) == NULL) {
 962       Qmsg0(bs->jcr, M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
 963       return false;
 964    }
 965    if (rw & BNET_SETBUF_READ) {
 966       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 967               SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 968          berrno be;
 969          Qmsg1(bs->jcr, M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 970          dbuf_size -= TAPE_BSIZE;
 971       }
 972       Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
 973       if (dbuf_size != start_size) {
 974          Qmsg1(bs->jcr, M_WARNING, 0,
 975                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 976       }
 977       if (dbuf_size % TAPE_BSIZE != 0) {
 978          Qmsg1(bs->jcr, M_ABORT, 0,
 979                _("Network buffer size %d not multiple of tape block size.\n"),
 980                dbuf_size);
 981       }
 982    }
 983    if (size != 0) {
 984       dbuf_size = size;
 985    } else {
 986       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 987    }
 988    start_size = dbuf_size;
 989    if (rw & BNET_SETBUF_WRITE) {
 990       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 991               SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 992          berrno be;
 993          Qmsg1(bs->jcr, M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 994          dbuf_size -= TAPE_BSIZE;
 995       }
 996       Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
 997       if (dbuf_size != start_size) {
 998          Qmsg1(bs->jcr, M_WARNING, 0,
 999                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
1000       }
1001       if (dbuf_size % TAPE_BSIZE != 0) {
1002          Qmsg1(bs->jcr, M_ABORT, 0,
1003                _("Network buffer size %d not multiple of tape block size.\n"),
1004                dbuf_size);
1005       }
1006    }
1007
1008    bs->msglen = dbuf_size;
1009    return true;
1010 }
1011
1012 /*
1013  * Set socket non-blocking
1014  * Returns previous socket flag
1015  */
1016 int bnet_set_nonblocking (BSOCK *bsock) {
1017 #ifndef HAVE_WIN32
1018    int oflags;
1019
1020    /* Get current flags */
1021    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
1022       berrno be;
1023       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
1024    }
1025
1026    /* Set O_NONBLOCK flag */
1027    if ((fcntl(bsock->fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
1028       berrno be;
1029       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
1030    }
1031
1032    bsock->blocking = 0;
1033    return oflags;
1034 #else
1035    int flags;
1036    u_long ioctlArg = 1;
1037
1038    flags = bsock->blocking;
1039    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1040    bsock->blocking = 0;
1041
1042    return flags;
1043 #endif
1044 }
1045
1046 /*
1047  * Set socket blocking
1048  * Returns previous socket flags
1049  */
1050 int bnet_set_blocking (BSOCK *bsock)
1051 {
1052 #ifndef HAVE_WIN32
1053    int oflags;
1054    /* Get current flags */
1055    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
1056       berrno be;
1057       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
1058    }
1059
1060    /* Set O_NONBLOCK flag */
1061    if ((fcntl(bsock->fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
1062       berrno be;
1063       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
1064    }
1065
1066    bsock->blocking = 1;
1067    return oflags;
1068 #else
1069    int flags;
1070    u_long ioctlArg = 0;
1071
1072    flags = bsock->blocking;
1073    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1074    bsock->blocking = 1;
1075
1076    return flags;
1077 #endif
1078 }
1079
1080 /*
1081  * Restores socket flags
1082  */
1083 void bnet_restore_blocking (BSOCK *bsock, int flags)
1084 {
1085 #ifndef HAVE_WIN32
1086    if ((fcntl(bsock->fd, F_SETFL, flags)) < 0) {
1087       berrno be;
1088       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
1089    }
1090
1091    bsock->blocking = (flags & O_NONBLOCK);
1092 #else
1093    u_long ioctlArg = flags;
1094
1095    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1096    bsock->blocking = 1;
1097 #endif
1098 }
1099
1100
1101 /*
1102  * Send a network "signal" to the other end
1103  *  This consists of sending a negative packet length
1104  *
1105  *  Returns: false on failure
1106  *           true  on success
1107  */
1108 bool bnet_sig(BSOCK * bs, int sig)
1109 {
1110    bs->msglen = sig;
1111    if (sig == BNET_TERMINATE) {
1112       bs->suppress_error_msgs = true;
1113    }
1114    return bnet_send(bs);
1115 }
1116
1117 /*
1118  * Convert a network "signal" code into
1119  * human readable ASCII.
1120  */
1121 const char *bnet_sig_to_ascii(BSOCK * bs)
1122 {
1123    static char buf[30];
1124    switch (bs->msglen) {
1125    case BNET_EOD:
1126       return "BNET_EOD";           /* end of data stream */
1127    case BNET_EOD_POLL:
1128       return "BNET_EOD_POLL";
1129    case BNET_STATUS:
1130       return "BNET_STATUS";
1131    case BNET_TERMINATE:
1132       return "BNET_TERMINATE";     /* terminate connection */
1133    case BNET_POLL:
1134       return "BNET_POLL";
1135    case BNET_HEARTBEAT:
1136       return "BNET_HEARTBEAT";
1137    case BNET_HB_RESPONSE:
1138       return "BNET_HB_RESPONSE";
1139    case BNET_PROMPT:
1140       return "BNET_PROMPT";
1141    default:
1142       sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
1143       return buf;
1144    }
1145 }
1146
1147
1148 /* Initialize internal socket structure.
1149  *  This probably should be done in net_open
1150  */
1151 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
1152                   struct sockaddr *client_addr)
1153 {
1154    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
1155    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
1156    memset(bsock, 0, sizeof(BSOCK));
1157    bsock->fd = sockfd;
1158    bsock->tls = NULL;
1159    bsock->errors = 0;
1160    bsock->blocking = 1;
1161    bsock->msg = get_pool_memory(PM_MESSAGE);
1162    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1163    bsock->who = bstrdup(who);
1164    bsock->host = bstrdup(host);
1165    bsock->port = port;
1166    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
1167    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
1168    /*
1169     * ****FIXME**** reduce this to a few hours once
1170     *   heartbeats are implemented
1171     */
1172    bsock->timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
1173    bsock->jcr = jcr;
1174    return bsock;
1175 }
1176
1177 BSOCK *dup_bsock(BSOCK * osock)
1178 {
1179    BSOCK *bsock = (BSOCK *) malloc(sizeof(BSOCK));
1180    memcpy(bsock, osock, sizeof(BSOCK));
1181    bsock->msg = get_pool_memory(PM_MESSAGE);
1182    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1183    if (osock->who) {
1184       bsock->who = bstrdup(osock->who);
1185    }
1186    if (osock->host) {
1187       bsock->host = bstrdup(osock->host);
1188    }
1189    bsock->duped = true;
1190    return bsock;
1191 }
1192
1193 /* Close the network connection */
1194 void bnet_close(BSOCK * bsock)
1195 {
1196    BSOCK *next;
1197
1198    for (; bsock != NULL; bsock = next) {
1199       next = bsock->next;
1200       if (!bsock->duped) {
1201 #ifdef HAVE_TLS
1202          /* Shutdown tls cleanly. */
1203          if (bsock->tls) {
1204             tls_bsock_shutdown(bsock);
1205             free_tls_connection(bsock->tls);
1206             bsock->tls = NULL;
1207          }
1208 #endif /* HAVE_TLS */
1209          if (bsock->timed_out) {
1210             shutdown(bsock->fd, 2);     /* discard any pending I/O */
1211          }
1212          socketClose(bsock->fd);   /* normal close */
1213       }
1214       term_bsock(bsock);
1215    }
1216    return;
1217 }
1218
1219 void term_bsock(BSOCK * bsock)
1220 {
1221    if (bsock->msg) {
1222       free_pool_memory(bsock->msg);
1223       bsock->msg = NULL;
1224    } else {
1225       ASSERT(1 == 0);              /* double close */
1226    }
1227    if (bsock->errmsg) {
1228       free_pool_memory(bsock->errmsg);
1229       bsock->errmsg = NULL;
1230    }
1231    if (bsock->who) {
1232       free(bsock->who);
1233       bsock->who = NULL;
1234    }
1235    if (bsock->host) {
1236       free(bsock->host);
1237       bsock->host = NULL;
1238    }
1239    free(bsock);
1240 }