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