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