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    return true;
 265
 266 err:
 267    free_tls_connection(tls);
 268    bsock->tls = NULL;
 269    return false;
 270 }
 271
 272 /*
 273  * Establish a TLS connection -- client side
 274  * Returns: true  on success
 275  *          false on failure
 276  */
 277 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 278 {
 279    TLS_CONNECTION *tls;
 280
 281    tls  = new_tls_connection(ctx, bsock->m_fd);
 282    if (!tls) {
 283       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 284       return false;
 285    }
 286
 287    bsock->tls = tls;
 288
 289    /* Initiate TLS Negotiation */
 290    if (!tls_bsock_connect(bsock)) {
 291       goto err;
 292    }
 293
 294    /* If there's an Allowed CN verify list, use that to validate the remote
 295     * certificate's CN. Otherwise, we use standard host/CN matching. */
 296    if (verify_list) {
 297       if (!tls_postconnect_verify_cn(tls, verify_list)) {
 298          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 299                                          " Peer certificate did not match a required commonName\n"),
 300                                          bsock->host());
 301          goto err;
 302       }
 303    } else {
 304       if (!tls_postconnect_verify_host(tls, bsock->host())) {
 305          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host %s did not match presented certificate\n"),
 306                bsock->host());
 307          goto err;
 308       }
 309    }
 310
 311    return true;
 312
 313 err:
 314    free_tls_connection(tls);
 315    bsock->tls = NULL;
 316    return false;
 317 }
 318 #else
 319
 320 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 321 {
 322    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n"));
 323    return false;
 324 }
 325
 326 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 327 {
 328    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n"));
 329    return false;
 330 }
 331
 332 #endif /* HAVE_TLS */
 333
 334 /*
 335  * Wait for a specified time for data to appear on
 336  * the BSOCK connection.
 337  *
 338  *   Returns: 1 if data available
 339  *            0 if timeout
 340  *           -1 if error
 341  */
 342 int bnet_wait_data(BSOCK * bsock, int sec)
 343 {
 344    return bsock->wait_data(sec);
 345 }
 346
 347 /*
 348  * As above, but returns on interrupt
 349  */
 350 int bnet_wait_data_intr(BSOCK * bsock, int sec)
 351 {
 352    return bsock->wait_data_intr(sec);
 353 }
 354
 355 #ifndef NETDB_INTERNAL
 356 #define NETDB_INTERNAL  -1         /* See errno. */
 357 #endif
 358 #ifndef NETDB_SUCCESS
 359 #define NETDB_SUCCESS   0          /* No problem. */
 360 #endif
 361 #ifndef HOST_NOT_FOUND
 362 #define HOST_NOT_FOUND  1          /* Authoritative Answer Host not found. */
 363 #endif
 364 #ifndef TRY_AGAIN
 365 #define TRY_AGAIN       2          /* Non-Authoritative Host not found, or SERVERFAIL. */
 366 #endif
 367 #ifndef NO_RECOVERY
 368 #define NO_RECOVERY     3          /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
 369 #endif
 370 #ifndef NO_DATA
 371 #define NO_DATA         4          /* Valid name, no data record of requested type. */
 372 #endif
 373
 374 /*
 375  * Get human readable error for gethostbyname()
 376  */
 377 static const char *gethost_strerror()
 378 {
 379    const char *msg;
 380    berrno be;
 381    switch (h_errno) {
 382    case NETDB_INTERNAL:
 383       msg = be.bstrerror();
 384       break;
 385    case NETDB_SUCCESS:
 386       msg = _("No problem.");
 387       break;
 388    case HOST_NOT_FOUND:
 389       msg = _("Authoritative answer for host not found.");
 390       break;
 391    case TRY_AGAIN:
 392       msg = _("Non-authoritative for host not found, or ServerFail.");
 393       break;
 394    case NO_RECOVERY:
 395       msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
 396       break;
 397    case NO_DATA:
 398       msg = _("Valid name, no data record of resquested type.");
 399       break;
 400    default:
 401       msg = _("Unknown error.");
 402    }
 403    return msg;
 404 }
 405
 406
 407
 408
 409 static IPADDR *add_any(int family)
 410 {
 411    IPADDR *addr = New(IPADDR(family));
 412    addr->set_type(IPADDR::R_MULTIPLE);
 413    addr->set_addr_any();
 414    return addr;
 415 }
 416
 417 static const char *resolv_host(int family, const char *host, dlist * addr_list)
 418 {
 419    struct hostent *hp;
 420    const char *errmsg;
 421
 422    P(ip_mutex);                       /* gethostbyname() is not thread safe */
 423 #ifdef HAVE_GETHOSTBYNAME2
 424    if ((hp = gethostbyname2(host, family)) == NULL) {
 425 #else
 426    if ((hp = gethostbyname(host)) == NULL) {
 427 #endif
 428       /* may be the strerror give not the right result -:( */
 429       errmsg = gethost_strerror();
 430       V(ip_mutex);
 431       return errmsg;
 432    } else {
 433       char **p;
 434       for (p = hp->h_addr_list; *p != 0; p++) {
 435          IPADDR *addr =  New(IPADDR(hp->h_addrtype));
 436          addr->set_type(IPADDR::R_MULTIPLE);
 437          if (addr->get_family() == AF_INET) {
 438              addr->set_addr4((struct in_addr*)*p);
 439          }
 440 #ifdef HAVE_IPV6
 441          else {
 442              addr->set_addr6((struct in6_addr*)*p);
 443          }
 444 #endif
 445          addr_list->append(addr);
 446       }
 447       V(ip_mutex);
 448    }
 449    return NULL;
 450 }
 451
 452 /*
 453  * i host = 0 mean INADDR_ANY only ipv4
 454  */
 455 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
 456 {
 457    struct in_addr inaddr;
 458    IPADDR *addr = 0;
 459    const char *errmsg;
 460 #ifdef HAVE_IPV6
 461    struct in6_addr inaddr6;
 462 #endif
 463
 464    dlist *addr_list = New(dlist(addr, &addr->link));
 465    if (!host || host[0] == '\0') {
 466       if (family != 0) {
 467          addr_list->append(add_any(family));
 468       } else {
 469          addr_list->append(add_any(AF_INET));
 470 #ifdef HAVE_IPV6
 471          addr_list->append(add_any(AF_INET6));
 472 #endif
 473       }
 474    } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
 475       addr = New(IPADDR(AF_INET));
 476       addr->set_type(IPADDR::R_MULTIPLE);
 477       addr->set_addr4(&inaddr);
 478       addr_list->append(addr);
 479    } else
 480 #ifdef HAVE_IPV6
 481    if (inet_pton(AF_INET6, host, &inaddr6) > 1) {
 482       addr = New(IPADDR(AF_INET6));
 483       addr->set_type(IPADDR::R_MULTIPLE);
 484       addr->set_addr6(&inaddr6);
 485       addr_list->append(addr);
 486    } else
 487 #endif
 488    {
 489       if (family != 0) {
 490          errmsg = resolv_host(family, host, addr_list);
 491          if (errmsg) {
 492             *errstr = errmsg;
 493             free_addresses(addr_list);
 494             return 0;
 495          }
 496       } else {
 497          errmsg = resolv_host(AF_INET, host, addr_list);
 498 #ifdef HAVE_IPV6
 499          if (errmsg) {
 500             errmsg = resolv_host(AF_INET6, host, addr_list);
 501          }
 502 #endif
 503          if (errmsg) {
 504             *errstr = errmsg;
 505             free_addresses(addr_list);
 506             return 0;
 507          }
 508       }
 509    }
 510    return addr_list;
 511 }
 512
 513 /*
 514  * This is the "old" way of opening a connection.  The preferred way is
 515  *   now to do what this subroutine does, but inline. That allows the
 516  *   connect() call to return error status, ...
 517  */
 518 BSOCK *bnet_connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
 519                     utime_t heart_beat,
 520                     const char *name, char *host, char *service, int port,
 521                     int verbose)
 522 {
 523    BSOCK *bsock = new_bsock();
 524    if (!bsock->connect(jcr, retry_interval, max_retry_time, heart_beat,
 525                        name, host, service, port, verbose)) {
 526        bsock->destroy();
 527        bsock = NULL;
 528    }
 529    return bsock;
 530 }
 531
 532
 533
 534 /*
 535  * Return the string for the error that occurred
 536  * on the socket. Only the first error is retained.
 537  */
 538 const char *bnet_strerror(BSOCK * bsock)
 539 {
 540    return bsock->bstrerror();
 541 }
 542
 543 /*
 544  * Format and send a message
 545  *  Returns: false on error
 546  *           true  on success
 547  */
 548 bool bnet_fsend(BSOCK * bs, const char *fmt, ...)
 549 {
 550    va_list arg_ptr;
 551    int maxlen;
 552
 553    if (bs->errors || bs->is_terminated()) {
 554       return false;
 555    }
 556    /* This probably won't work, but we vsnprintf, then if we
 557     * get a negative length or a length greater than our buffer
 558     * (depending on which library is used), the printf was truncated, so
 559     * get a bigger buffer and try again.
 560     */
 561    for (;;) {
 562       maxlen = sizeof_pool_memory(bs->msg) - 1;
 563       va_start(arg_ptr, fmt);
 564       bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
 565       va_end(arg_ptr);
 566       if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) {
 567          break;
 568       }
 569       bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
 570    }
 571    return bs->send();
 572 }
 573
 574 int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen)
 575 {
 576    return bs->get_peer(buf, buflen);
 577 }
 578
 579 /*
 580  * Set the network buffer size, suggested size is in size.
 581  *  Actual size obtained is returned in bs->msglen
 582  *
 583  *  Returns: 0 on failure
 584  *           1 on success
 585  */
 586 bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
 587 {
 588    return bs->set_buffer_size(size, rw);
 589 }
 590
 591 /*
 592  * Set socket non-blocking
 593  * Returns previous socket flag
 594  */
 595 int bnet_set_nonblocking(BSOCK *bsock)
 596 {
 597    return bsock->set_nonblocking();
 598 }
 599
 600 /*
 601  * Set socket blocking
 602  * Returns previous socket flags
 603  */
 604 int bnet_set_blocking(BSOCK *bsock)
 605 {
 606    return bsock->set_blocking();
 607 }
 608
 609 /*
 610  * Restores socket flags
 611  */
 612 void bnet_restore_blocking (BSOCK *bsock, int flags)
 613 {
 614    bsock->restore_blocking(flags);
 615 }
 616
 617
 618 /*
 619  * Send a network "signal" to the other end
 620  *  This consists of sending a negative packet length
 621  *
 622  *  Returns: false on failure
 623  *           true  on success
 624  */
 625 bool bnet_sig(BSOCK * bs, int signal)
 626 {
 627    return bs->signal(signal);
 628 }
 629
 630 /*
 631  * Convert a network "signal" code into
 632  * human readable ASCII.
 633  */
 634 const char *bnet_sig_to_ascii(BSOCK * bs)
 635 {
 636    static char buf[30];
 637    switch (bs->msglen) {
 638    case BNET_EOD:
 639       return "BNET_EOD";           /* end of data stream */
 640    case BNET_EOD_POLL:
 641       return "BNET_EOD_POLL";
 642    case BNET_STATUS:
 643       return "BNET_STATUS";
 644    case BNET_TERMINATE:
 645       return "BNET_TERMINATE";     /* terminate connection */
 646    case BNET_POLL:
 647       return "BNET_POLL";
 648    case BNET_HEARTBEAT:
 649       return "BNET_HEARTBEAT";
 650    case BNET_HB_RESPONSE:
 651       return "BNET_HB_RESPONSE";
 652    case BNET_PROMPT:
 653       return "BNET_PROMPT";
 654    default:
 655       sprintf(buf, _("Unknown sig %d"), (int)bs->msglen);
 656       return buf;
 657    }
 658 }
 659
 660 /* Initialize internal socket structure.
 661  *  This probably should be done in net_open
 662  */
 663 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
 664                   struct sockaddr *client_addr)
 665 {
 666    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
 667    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 668    memset(bsock, 0, sizeof(BSOCK));
 669    bsock->m_fd = sockfd;
 670    bsock->tls = NULL;
 671    bsock->errors = 0;
 672    bsock->m_blocking = 1;
 673    bsock->msg = get_pool_memory(PM_MESSAGE);
 674    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 675    bsock->set_who(bstrdup(who));
 676    bsock->set_host(bstrdup(host));
 677    bsock->set_port(port);
 678    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
 679    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
 680    /*
 681     * ****FIXME**** reduce this to a few hours once
 682     *   heartbeats are implemented
 683     */
 684    bsock->timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
 685    bsock->set_jcr(jcr);
 686    return bsock;
 687 }
 688
 689 BSOCK *dup_bsock(BSOCK * osock)
 690 {
 691    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 692    memcpy(bsock, osock, sizeof(BSOCK));
 693    bsock->msg = get_pool_memory(PM_MESSAGE);
 694    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 695    if (osock->who()) {
 696       bsock->set_who(bstrdup(osock->who()));
 697    }
 698    if (osock->host()) {
 699       bsock->set_host(bstrdup(osock->host()));
 700    }
 701    bsock->set_duped();
 702    return bsock;
 703 }
 704
 705 /* Close the network connection */
 706 void bnet_close(BSOCK * bsock)
 707 {
 708    bsock->close();
 709 }
 710
 711 void term_bsock(BSOCK * bsock)
 712 {
 713    bsock->destroy();
 714 }