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