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 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen) {
 913 #if !defined(HAVE_WIN32)
 914     if (bs->peer_addr.sin_family == 0) {
 915         socklen_t salen = sizeof(bs->peer_addr);
 916         int rval = (getpeername)(bs->fd, (struct sockaddr *)&bs->peer_addr, &salen);
 917         if (rval < 0) return rval;
 918     }
 919     if (!inet_ntop(bs->peer_addr.sin_family, &bs->peer_addr.sin_addr, buf, buflen))
 920         return -1;
 921
 922     return 0;
 923 #else
 924     return -1;
 925 #endif
 926 }
 927 /*
 928  * Set the network buffer size, suggested size is in size.
 929  *  Actual size obtained is returned in bs->msglen
 930  *
 931  *  Returns: 0 on failure
 932  *           1 on success
 933  */
 934 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
 935 {
 936    uint32_t dbuf_size, start_size;
 937 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
 938    int opt;
 939
 940    opt = IPTOS_THROUGHPUT;
 941    setsockopt(bs->fd, IPPROTO_IP, IP_TOS, (sockopt_val_t) & opt, sizeof(opt));
 942 #endif
 943
 944    if (size != 0) {
 945       dbuf_size = size;
 946    } else {
 947       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 948    }
 949    start_size = dbuf_size;
 950    if ((bs->msg = realloc_pool_memory(bs->msg, dbuf_size + 100)) == NULL) {
 951       Qmsg0(bs->jcr, M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
 952       return false;
 953    }
 954    if (rw & BNET_SETBUF_READ) {
 955       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 956               SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 957          berrno be;
 958          Qmsg1(bs->jcr, M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 959          dbuf_size -= TAPE_BSIZE;
 960       }
 961       Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
 962       if (dbuf_size != start_size) {
 963          Qmsg1(bs->jcr, M_WARNING, 0,
 964                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 965       }
 966       if (dbuf_size % TAPE_BSIZE != 0) {
 967          Qmsg1(bs->jcr, M_ABORT, 0,
 968                _("Network buffer size %d not multiple of tape block size.\n"),
 969                dbuf_size);
 970       }
 971    }
 972    if (size != 0) {
 973       dbuf_size = size;
 974    } else {
 975       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 976    }
 977    start_size = dbuf_size;
 978    if (rw & BNET_SETBUF_WRITE) {
 979       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET,
 980               SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 981          berrno be;
 982          Qmsg1(bs->jcr, M_ERROR, 0, _("sockopt error: %s\n"), be.strerror());
 983          dbuf_size -= TAPE_BSIZE;
 984       }
 985       Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
 986       if (dbuf_size != start_size) {
 987          Qmsg1(bs->jcr, M_WARNING, 0,
 988                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 989       }
 990       if (dbuf_size % TAPE_BSIZE != 0) {
 991          Qmsg1(bs->jcr, M_ABORT, 0,
 992                _("Network buffer size %d not multiple of tape block size.\n"),
 993                dbuf_size);
 994       }
 995    }
 996
 997    bs->msglen = dbuf_size;
 998    return true;
 999 }
1000
1001 /*
1002  * Set socket non-blocking
1003  * Returns previous socket flag
1004  */
1005 int bnet_set_nonblocking (BSOCK *bsock) {
1006 #ifndef HAVE_WIN32
1007    int oflags;
1008
1009    /* Get current flags */
1010    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
1011       berrno be;
1012       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
1013    }
1014
1015    /* Set O_NONBLOCK flag */
1016    if ((fcntl(bsock->fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
1017       berrno be;
1018       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
1019    }
1020
1021    bsock->blocking = 0;
1022    return oflags;
1023 #else
1024    int flags;
1025    u_long ioctlArg = 1;
1026
1027    flags = bsock->blocking;
1028    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1029    bsock->blocking = 0;
1030
1031    return flags;
1032 #endif
1033 }
1034
1035 /*
1036  * Set socket blocking
1037  * Returns previous socket flags
1038  */
1039 int bnet_set_blocking (BSOCK *bsock)
1040 {
1041 #ifndef HAVE_WIN32
1042    int oflags;
1043    /* Get current flags */
1044    if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) {
1045       berrno be;
1046       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror());
1047    }
1048
1049    /* Set O_NONBLOCK flag */
1050    if ((fcntl(bsock->fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
1051       berrno be;
1052       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
1053    }
1054
1055    bsock->blocking = 1;
1056    return oflags;
1057 #else
1058    int flags;
1059    u_long ioctlArg = 0;
1060
1061    flags = bsock->blocking;
1062    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1063    bsock->blocking = 1;
1064
1065    return flags;
1066 #endif
1067 }
1068
1069 /*
1070  * Restores socket flags
1071  */
1072 void bnet_restore_blocking (BSOCK *bsock, int flags)
1073 {
1074 #ifndef HAVE_WIN32
1075    if ((fcntl(bsock->fd, F_SETFL, flags)) < 0) {
1076       berrno be;
1077       Jmsg1(bsock->jcr, M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror());
1078    }
1079
1080    bsock->blocking = (flags & O_NONBLOCK);
1081 #else
1082    u_long ioctlArg = flags;
1083
1084    ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
1085    bsock->blocking = 1;
1086 #endif
1087 }
1088
1089
1090 /*
1091  * Send a network "signal" to the other end
1092  *  This consists of sending a negative packet length
1093  *
1094  *  Returns: false on failure
1095  *           true  on success
1096  */
1097 bool bnet_sig(BSOCK * bs, int sig)
1098 {
1099    bs->msglen = sig;
1100    if (sig == BNET_TERMINATE) {
1101       bs->suppress_error_msgs = true;
1102    }
1103    return bnet_send(bs);
1104 }
1105
1106 /*
1107  * Convert a network "signal" code into
1108  * human readable ASCII.
1109  */
1110 const char *bnet_sig_to_ascii(BSOCK * bs)
1111 {
1112    static char buf[30];
1113    switch (bs->msglen) {
1114    case BNET_EOD:
1115       return "BNET_EOD";           /* end of data stream */
1116    case BNET_EOD_POLL:
1117       return "BNET_EOD_POLL";
1118    case BNET_STATUS:
1119       return "BNET_STATUS";
1120    case BNET_TERMINATE:
1121       return "BNET_TERMINATE";     /* terminate connection */
1122    case BNET_POLL:
1123       return "BNET_POLL";
1124    case BNET_HEARTBEAT:
1125       return "BNET_HEARTBEAT";
1126    case BNET_HB_RESPONSE:
1127       return "BNET_HB_RESPONSE";
1128    case BNET_PROMPT:
1129       return "BNET_PROMPT";
1130    default:
1131       sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
1132       return buf;
1133    }
1134 }
1135
1136
1137 /* Initialize internal socket structure.
1138  *  This probably should be done in net_open
1139  */
1140 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
1141                   struct sockaddr *client_addr)
1142 {
1143    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
1144    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
1145    memset(bsock, 0, sizeof(BSOCK));
1146    bsock->fd = sockfd;
1147    bsock->tls = NULL;
1148    bsock->errors = 0;
1149    bsock->blocking = 1;
1150    bsock->msg = get_pool_memory(PM_MESSAGE);
1151    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1152    bsock->who = bstrdup(who);
1153    bsock->host = bstrdup(host);
1154    bsock->port = port;
1155    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
1156    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
1157    /*
1158     * ****FIXME**** reduce this to a few hours once
1159     *   heartbeats are implemented
1160     */
1161    bsock->timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
1162    bsock->jcr = jcr;
1163    return bsock;
1164 }
1165
1166 BSOCK *dup_bsock(BSOCK * osock)
1167 {
1168    BSOCK *bsock = (BSOCK *) malloc(sizeof(BSOCK));
1169    memcpy(bsock, osock, sizeof(BSOCK));
1170    bsock->msg = get_pool_memory(PM_MESSAGE);
1171    bsock->errmsg = get_pool_memory(PM_MESSAGE);
1172    if (osock->who) {
1173       bsock->who = bstrdup(osock->who);
1174    }
1175    if (osock->host) {
1176       bsock->host = bstrdup(osock->host);
1177    }
1178    bsock->duped = true;
1179    return bsock;
1180 }
1181
1182 /* Close the network connection */
1183 void bnet_close(BSOCK * bsock)
1184 {
1185    BSOCK *next;
1186
1187    for (; bsock != NULL; bsock = next) {
1188       next = bsock->next;
1189       if (!bsock->duped) {
1190 #ifdef HAVE_TLS
1191          /* Shutdown tls cleanly. */
1192          if (bsock->tls) {
1193             tls_bsock_shutdown(bsock);
1194             free_tls_connection(bsock->tls);
1195             bsock->tls = NULL;
1196          }
1197 #endif /* HAVE_TLS */
1198          if (bsock->timed_out) {
1199             shutdown(bsock->fd, 2);     /* discard any pending I/O */
1200          }
1201          socketClose(bsock->fd);   /* normal close */
1202       }
1203       term_bsock(bsock);
1204    }
1205    return;
1206 }
1207
1208 void term_bsock(BSOCK * bsock)
1209 {
1210    if (bsock->msg) {
1211       free_pool_memory(bsock->msg);
1212       bsock->msg = NULL;
1213    } else {
1214       ASSERT(1 == 0);              /* double close */
1215    }
1216    if (bsock->errmsg) {
1217       free_pool_memory(bsock->errmsg);
1218       bsock->errmsg = NULL;
1219    }
1220    if (bsock->who) {
1221       free(bsock->who);
1222       bsock->who = NULL;
1223    }
1224    if (bsock->host) {
1225       free(bsock->host);
1226       bsock->host = NULL;
1227    }
1228    free(bsock);
1229 }