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