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