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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of John Walker.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  * Network Utility Routines
  30  *
  31  *  by Kern Sibbald
  32  *
  33  * Adapted and enhanced for Bacula, originally written
  34  * for inclusion in the Apcupsd package
  35  *
  36  *   Version $Id$
  37  */
  38
  39
  40 #include "bacula.h"
  41 #include "jcr.h"
  42 #include <netdb.h>
  43
  44 extern time_t watchdog_time;
  45
  46 #ifndef   INADDR_NONE
  47 #define   INADDR_NONE    -1
  48 #endif
  49
  50 #ifdef HAVE_WIN32
  51 #define socketRead(fd, buf, len)  recv(fd, buf, len, 0)
  52 #define socketWrite(fd, buf, len) send(fd, buf, len, 0)
  53 #define socketClose(fd)           closesocket(fd)
  54 #else
  55 #define socketRead(fd, buf, len)  read(fd, buf, len)
  56 #define socketWrite(fd, buf, len) write(fd, buf, len)
  57 #define socketClose(fd)           close(fd)
  58 #endif
  59
  60 static pthread_mutex_t ip_mutex = PTHREAD_MUTEX_INITIALIZER;
  61
  62 /*
  63  * Read a nbytes from the network.
  64  * It is possible that the total bytes require in several
  65  * read requests
  66  */
  67
  68 int32_t read_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
  69 {
  70    int32_t nleft, nread;
  71
  72 #ifdef HAVE_TLS
  73    if (bsock->tls) {
  74       /* TLS enabled */
  75       return (tls_bsock_readn(bsock, ptr, nbytes));
  76    }
  77 #endif /* HAVE_TLS */
  78
  79    nleft = nbytes;
  80    while (nleft > 0) {
  81       errno = 0;
  82       nread = socketRead(bsock->m_fd, ptr, nleft);
  83       if (bsock->is_timed_out() || bsock->is_terminated()) {
  84          return nread;
  85       }
  86       if (nread == -1) {
  87          if (errno == EINTR) {
  88             continue;
  89          }
  90          if (errno == EAGAIN) {
  91             bmicrosleep(0, 200000);  /* try again in 200ms */
  92             continue;
  93          }
  94       }
  95       if (nread <= 0) {
  96          return nread;             /* error, or EOF */
  97       }
  98       nleft -= nread;
  99       ptr += nread;
 100    }
 101    return nbytes - nleft;          /* return >= 0 */
 102 }
 103
 104 /*
 105  * Write nbytes to the network.
 106  * It may require several writes.
 107  */
 108
 109 int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
 110 {
 111    int32_t nleft, nwritten;
 112
 113    if (bsock->is_spooling()) {
 114       nwritten = fwrite(ptr, 1, nbytes, bsock->m_spool_fd);
 115       if (nwritten != nbytes) {
 116          berrno be;
 117          bsock->b_errno = errno;
 118          Qmsg1(bsock->jcr(), M_FATAL, 0, _("Attr spool write error. ERR=%s\n"),
 119                be.bstrerror());
 120          Dmsg2(400, "nwritten=%d nbytes=%d.\n", nwritten, nbytes);
 121          errno = bsock->b_errno;
 122          return -1;
 123       }
 124       return nbytes;
 125    }
 126
 127 #ifdef HAVE_TLS
 128    if (bsock->tls) {
 129       /* TLS enabled */
 130       return (tls_bsock_writen(bsock, ptr, nbytes));
 131    }
 132 #endif /* HAVE_TLS */
 133
 134    nleft = nbytes;
 135    while (nleft > 0) {
 136       do {
 137          errno = 0;
 138          nwritten = socketWrite(bsock->m_fd, ptr, nleft);
 139          if (bsock->is_timed_out() || bsock->is_terminated()) {
 140             return nwritten;
 141          }
 142       } while (nwritten == -1 && errno == EINTR);
 143       /*
 144        * If connection is non-blocking, we will get EAGAIN, so
 145        * use select() to keep from consuming all the CPU
 146        * and try again.
 147        */
 148       if (nwritten == -1 && errno == EAGAIN) {
 149          fd_set fdset;
 150          struct timeval tv;
 151
 152          FD_ZERO(&fdset);
 153          FD_SET((unsigned)bsock->m_fd, &fdset);
 154          tv.tv_sec = 10;
 155          tv.tv_usec = 0;
 156          select(bsock->m_fd + 1, NULL, &fdset, NULL, &tv);
 157          continue;
 158       }
 159       if (nwritten <= 0) {
 160          return nwritten;          /* error */
 161       }
 162       nleft -= nwritten;
 163       ptr += nwritten;
 164    }
 165    return nbytes - nleft;
 166 }
 167
 168 /*
 169  * Receive a message from the other end. Each message consists of
 170  * two packets. The first is a header that contains the size
 171  * of the data that follows in the second packet.
 172  * Returns number of bytes read (may return zero)
 173  * Returns -1 on signal (BNET_SIGNAL)
 174  * Returns -2 on hard end of file (BNET_HARDEOF)
 175  * Returns -3 on error  (BNET_ERROR)
 176  *
 177  *  Unfortunately, it is a bit complicated because we have these
 178  *    four return types:
 179  *    1. Normal data
 180  *    2. Signal including end of data stream
 181  *    3. Hard end of file
 182  *    4. Error
 183  *  Using is_bnet_stop() and is_bnet_error() you can figure this all out.
 184  */
 185 int32_t bnet_recv(BSOCK * bsock)
 186 {
 187    return bsock->recv();
 188 }
 189
 190
 191 /*
 192  * Return 1 if there are errors on this bsock or it is closed,
 193  *   i.e. stop communicating on this line.
 194  */
 195 bool is_bnet_stop(BSOCK * bsock)
 196 {
 197    return bsock->errors || bsock->is_terminated();
 198 }
 199
 200 /*
 201  * Return number of errors on socket
 202  */
 203 int is_bnet_error(BSOCK * bsock)
 204 {
 205    errno = bsock->b_errno;
 206    return bsock->errors;
 207 }
 208
 209 /*
 210  * Call here after error during closing to suppress error
 211  *  messages which are due to the other end shutting down too.
 212  */
 213 void bnet_suppress_error_messages(BSOCK * bsock, bool flag)
 214 {
 215    bsock->m_suppress_error_msgs = flag;
 216 }
 217
 218 /*
 219  * Send a message over the network. The send consists of
 220  * two network packets. The first is sends a 32 bit integer containing
 221  * the length of the data packet which follows.
 222  *
 223  * Returns: false on failure
 224  *          true  on success
 225  */
 226 bool bnet_send(BSOCK *bsock)
 227 {
 228    return bsock->send();
 229 }
 230
 231
 232 /*
 233  * Establish a TLS connection -- server side
 234  *  Returns: true  on success
 235  *           false on failure
 236  */
 237 #ifdef HAVE_TLS
 238 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 239 {
 240    TLS_CONNECTION *tls;
 241
 242    tls = new_tls_connection(ctx, bsock->m_fd);
 243    if (!tls) {
 244       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 245       return false;
 246    }
 247
 248    bsock->tls = tls;
 249
 250    /* Initiate TLS Negotiation */
 251    if (!tls_bsock_accept(bsock)) {
 252       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS Negotiation failed.\n"));
 253       goto err;
 254    }
 255
 256    if (verify_list) {
 257       if (!tls_postconnect_verify_cn(tls, verify_list)) {
 258          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 259                                          " Peer certificate did not match a required commonName\n"),
 260                                          bsock->host());
 261          goto err;
 262       }
 263    }
 264    Dmsg0(50, "TLS server negotiation established.\n");
 265    return true;
 266
 267 err:
 268    free_tls_connection(tls);
 269    bsock->tls = NULL;
 270    return false;
 271 }
 272
 273 /*
 274  * Establish a TLS connection -- client side
 275  * Returns: true  on success
 276  *          false on failure
 277  */
 278 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 279 {
 280    TLS_CONNECTION *tls;
 281
 282    tls  = new_tls_connection(ctx, bsock->m_fd);
 283    if (!tls) {
 284       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 285       return false;
 286    }
 287
 288    bsock->tls = tls;
 289
 290    /* Initiate TLS Negotiation */
 291    if (!tls_bsock_connect(bsock)) {
 292       goto err;
 293    }
 294
 295    /* If there's an Allowed CN verify list, use that to validate the remote
 296     * certificate's CN. Otherwise, we use standard host/CN matching. */
 297    if (verify_list) {
 298       if (!tls_postconnect_verify_cn(tls, verify_list)) {
 299          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 300                                          " Peer certificate did not match a required commonName\n"),
 301                                          bsock->host());
 302          goto err;
 303       }
 304    } else {
 305       if (!tls_postconnect_verify_host(tls, bsock->host())) {
 306          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host %s did not match presented certificate\n"),
 307                bsock->host());
 308          goto err;
 309       }
 310    }
 311    Dmsg0(50, "TLS client negotiation established.\n");
 312    return true;
 313
 314 err:
 315    free_tls_connection(tls);
 316    bsock->tls = NULL;
 317    return false;
 318 }
 319 #else
 320
 321 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 322 {
 323    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n"));
 324    return false;
 325 }
 326
 327 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 328 {
 329    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n"));
 330    return false;
 331 }
 332
 333 #endif /* HAVE_TLS */
 334
 335 /*
 336  * Wait for a specified time for data to appear on
 337  * the BSOCK connection.
 338  *
 339  *   Returns: 1 if data available
 340  *            0 if timeout
 341  *           -1 if error
 342  */
 343 int bnet_wait_data(BSOCK * bsock, int sec)
 344 {
 345    return bsock->wait_data(sec);
 346 }
 347
 348 /*
 349  * As above, but returns on interrupt
 350  */
 351 int bnet_wait_data_intr(BSOCK * bsock, int sec)
 352 {
 353    return bsock->wait_data_intr(sec);
 354 }
 355
 356 #ifndef NETDB_INTERNAL
 357 #define NETDB_INTERNAL  -1         /* See errno. */
 358 #endif
 359 #ifndef NETDB_SUCCESS
 360 #define NETDB_SUCCESS   0          /* No problem. */
 361 #endif
 362 #ifndef HOST_NOT_FOUND
 363 #define HOST_NOT_FOUND  1          /* Authoritative Answer Host not found. */
 364 #endif
 365 #ifndef TRY_AGAIN
 366 #define TRY_AGAIN       2          /* Non-Authoritative Host not found, or SERVERFAIL. */
 367 #endif
 368 #ifndef NO_RECOVERY
 369 #define NO_RECOVERY     3          /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
 370 #endif
 371 #ifndef NO_DATA
 372 #define NO_DATA         4          /* Valid name, no data record of requested type. */
 373 #endif
 374
 375 /*
 376  * Get human readable error for gethostbyname()
 377  */
 378 static const char *gethost_strerror()
 379 {
 380    const char *msg;
 381    berrno be;
 382    switch (h_errno) {
 383    case NETDB_INTERNAL:
 384       msg = be.bstrerror();
 385       break;
 386    case NETDB_SUCCESS:
 387       msg = _("No problem.");
 388       break;
 389    case HOST_NOT_FOUND:
 390       msg = _("Authoritative answer for host not found.");
 391       break;
 392    case TRY_AGAIN:
 393       msg = _("Non-authoritative for host not found, or ServerFail.");
 394       break;
 395    case NO_RECOVERY:
 396       msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
 397       break;
 398    case NO_DATA:
 399       msg = _("Valid name, no data record of resquested type.");
 400       break;
 401    default:
 402       msg = _("Unknown error.");
 403    }
 404    return msg;
 405 }
 406
 407
 408
 409
 410 static IPADDR *add_any(int family)
 411 {
 412    IPADDR *addr = New(IPADDR(family));
 413    addr->set_type(IPADDR::R_MULTIPLE);
 414    addr->set_addr_any();
 415    return addr;
 416 }
 417
 418 static const char *resolv_host(int family, const char *host, dlist * addr_list)
 419 {
 420    struct hostent *hp;
 421    const char *errmsg;
 422
 423    P(ip_mutex);                       /* gethostbyname() is not thread safe */
 424 #ifdef HAVE_GETHOSTBYNAME2
 425    if ((hp = gethostbyname2(host, family)) == NULL) {
 426 #else
 427    if ((hp = gethostbyname(host)) == NULL) {
 428 #endif
 429       /* may be the strerror give not the right result -:( */
 430       errmsg = gethost_strerror();
 431       V(ip_mutex);
 432       return errmsg;
 433    } else {
 434       char **p;
 435       for (p = hp->h_addr_list; *p != 0; p++) {
 436          IPADDR *addr =  New(IPADDR(hp->h_addrtype));
 437          addr->set_type(IPADDR::R_MULTIPLE);
 438          if (addr->get_family() == AF_INET) {
 439              addr->set_addr4((struct in_addr*)*p);
 440          }
 441 #ifdef HAVE_IPV6
 442          else {
 443              addr->set_addr6((struct in6_addr*)*p);
 444          }
 445 #endif
 446          addr_list->append(addr);
 447       }
 448       V(ip_mutex);
 449    }
 450    return NULL;
 451 }
 452
 453 /*
 454  * i host = 0 mean INADDR_ANY only ipv4
 455  */
 456 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
 457 {
 458    struct in_addr inaddr;
 459    IPADDR *addr = 0;
 460    const char *errmsg;
 461 #ifdef HAVE_IPV6
 462    struct in6_addr inaddr6;
 463 #endif
 464
 465    dlist *addr_list = New(dlist(addr, &addr->link));
 466    if (!host || host[0] == '\0') {
 467       if (family != 0) {
 468          addr_list->append(add_any(family));
 469       } else {
 470          addr_list->append(add_any(AF_INET));
 471 #ifdef HAVE_IPV6
 472          addr_list->append(add_any(AF_INET6));
 473 #endif
 474       }
 475    } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
 476       addr = New(IPADDR(AF_INET));
 477       addr->set_type(IPADDR::R_MULTIPLE);
 478       addr->set_addr4(&inaddr);
 479       addr_list->append(addr);
 480    } else
 481 #ifdef HAVE_IPV6
 482    if (inet_pton(AF_INET6, host, &inaddr6) > 1) {
 483       addr = New(IPADDR(AF_INET6));
 484       addr->set_type(IPADDR::R_MULTIPLE);
 485       addr->set_addr6(&inaddr6);
 486       addr_list->append(addr);
 487    } else
 488 #endif
 489    {
 490       if (family != 0) {
 491          errmsg = resolv_host(family, host, addr_list);
 492          if (errmsg) {
 493             *errstr = errmsg;
 494             free_addresses(addr_list);
 495             return 0;
 496          }
 497       } else {
 498          errmsg = resolv_host(AF_INET, host, addr_list);
 499 #ifdef HAVE_IPV6
 500          if (errmsg) {
 501             errmsg = resolv_host(AF_INET6, host, addr_list);
 502          }
 503 #endif
 504          if (errmsg) {
 505             *errstr = errmsg;
 506             free_addresses(addr_list);
 507             return 0;
 508          }
 509       }
 510    }
 511    return addr_list;
 512 }
 513
 514 /*
 515  * This is the "old" way of opening a connection.  The preferred way is
 516  *   now to do what this subroutine does, but inline. That allows the
 517  *   connect() call to return error status, ...
 518  */
 519 BSOCK *bnet_connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
 520                     utime_t heart_beat,
 521                     const char *name, char *host, char *service, int port,
 522                     int verbose)
 523 {
 524    BSOCK *bsock = new_bsock();
 525    if (!bsock->connect(jcr, retry_interval, max_retry_time, heart_beat,
 526                        name, host, service, port, verbose)) {
 527        bsock->destroy();
 528        bsock = NULL;
 529    }
 530    return bsock;
 531 }
 532
 533
 534
 535 /*
 536  * Return the string for the error that occurred
 537  * on the socket. Only the first error is retained.
 538  */
 539 const char *bnet_strerror(BSOCK * bsock)
 540 {
 541    return bsock->bstrerror();
 542 }
 543
 544 /*
 545  * Format and send a message
 546  *  Returns: false on error
 547  *           true  on success
 548  */
 549 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
 550 {
 551    va_list arg_ptr;
 552    int maxlen;
 553
 554    if (bs->errors || bs->is_terminated()) {
 555       return false;
 556    }
 557    /* This probably won't work, but we vsnprintf, then if we
 558     * get a negative length or a length greater than our buffer
 559     * (depending on which library is used), the printf was truncated, so
 560     * get a bigger buffer and try again.
 561     */
 562    for (;;) {
 563       maxlen = sizeof_pool_memory(bs->msg) - 1;
 564       va_start(arg_ptr, fmt);
 565       bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
 566       va_end(arg_ptr);
 567       if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
 568          break;
 569       }
 570       bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
 571    }
 572    return bs->send();
 573 }
 574
 575 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen)
 576 {
 577    return bs->get_peer(buf, buflen);
 578 }
 579
 580 /*
 581  * Set the network buffer size, suggested size is in size.
 582  *  Actual size obtained is returned in bs->msglen
 583  *
 584  *  Returns: 0 on failure
 585  *           1 on success
 586  */
 587 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
 588 {
 589    return bs->set_buffer_size(size, rw);
 590 }
 591
 592 /*
 593  * Set socket non-blocking
 594  * Returns previous socket flag
 595  */
 596 int bnet_set_nonblocking(BSOCK *bsock)
 597 {
 598    return bsock->set_nonblocking();
 599 }
 600
 601 /*
 602  * Set socket blocking
 603  * Returns previous socket flags
 604  */
 605 int bnet_set_blocking(BSOCK *bsock)
 606 {
 607    return bsock->set_blocking();
 608 }
 609
 610 /*
 611  * Restores socket flags
 612  */
 613 void bnet_restore_blocking (BSOCK *bsock, int flags)
 614 {
 615    bsock->restore_blocking(flags);
 616 }
 617
 618
 619 /*
 620  * Send a network "signal" to the other end
 621  *  This consists of sending a negative packet length
 622  *
 623  *  Returns: false on failure
 624  *           true  on success
 625  */
 626 bool bnet_sig(BSOCK * bs, int signal)
 627 {
 628    return bs->signal(signal);
 629 }
 630
 631 /*
 632  * Convert a network "signal" code into
 633  * human readable ASCII.
 634  */
 635 const char *bnet_sig_to_ascii(BSOCK * bs)
 636 {
 637    static char buf[30];
 638    switch (bs->msglen) {
 639    case BNET_EOD:
 640       return "BNET_EOD";           /* end of data stream */
 641    case BNET_EOD_POLL:
 642       return "BNET_EOD_POLL";
 643    case BNET_STATUS:
 644       return "BNET_STATUS";
 645    case BNET_TERMINATE:
 646       return "BNET_TERMINATE";     /* terminate connection */
 647    case BNET_POLL:
 648       return "BNET_POLL";
 649    case BNET_HEARTBEAT:
 650       return "BNET_HEARTBEAT";
 651    case BNET_HB_RESPONSE:
 652       return "BNET_HB_RESPONSE";
 653    case BNET_PROMPT:
 654       return "BNET_PROMPT";
 655    default:
 656       sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
 657       return buf;
 658    }
 659 }
 660
 661 /* Initialize internal socket structure.
 662  *  This probably should be done in net_open
 663  */
 664 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
 665                   struct sockaddr *client_addr)
 666 {
 667    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
 668    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 669    memset(bsock, 0, sizeof(BSOCK));
 670    bsock->m_fd = sockfd;
 671    bsock->tls = NULL;
 672    bsock->errors = 0;
 673    bsock->m_blocking = 1;
 674    bsock->msg = get_pool_memory(PM_MESSAGE);
 675    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 676    bsock->set_who(bstrdup(who));
 677    bsock->set_host(bstrdup(host));
 678    bsock->set_port(port);
 679    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
 680    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
 681    /*
 682     * ****FIXME**** reduce this to a few hours once
 683     *   heartbeats are implemented
 684     */
 685    bsock->timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
 686    bsock->set_jcr(jcr);
 687    return bsock;
 688 }
 689
 690 BSOCK *dup_bsock(BSOCK * osock)
 691 {
 692    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 693    memcpy(bsock, osock, sizeof(BSOCK));
 694    bsock->msg = get_pool_memory(PM_MESSAGE);
 695    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 696    if (osock->who()) {
 697       bsock->set_who(bstrdup(osock->who()));
 698    }
 699    if (osock->host()) {
 700       bsock->set_host(bstrdup(osock->host()));
 701    }
 702    bsock->set_duped();
 703    return bsock;
 704 }
 705
 706 /* Close the network connection */
 707 void bnet_close(BSOCK * bsock)
 708 {
 709    bsock->close();
 710 }
 711
 712 void term_bsock(BSOCK * bsock)
 713 {
 714    bsock->destroy();
 715 }