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