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