git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/bnet.c

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