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