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

   1 /*
   2    Bacula(R) - The Network Backup Solution
   3
   4    Copyright (C) 2000-2016 Kern Sibbald
   5
   6    The original author of Bacula is Kern Sibbald, with contributions
   7    from many others, a complete list can be found in the file AUTHORS.
   8
   9    You may use this file and others of this release according to the
  10    license defined in the LICENSE file, which includes the Affero General
  11    Public License, v3.0 ("AGPLv3") and some additional permissions and
  12    terms pursuant to its AGPLv3 Section 7.
  13
  14    This notice must be preserved when any source code is
  15    conveyed and/or propagated.
  16
  17    Bacula(R) is a registered trademark of Kern Sibbald.
  18 */
  19 /*
  20  * Network Utility Routines
  21  *
  22  *  by Kern Sibbald
  23  *
  24  * Adapted and enhanced for Bacula, originally written
  25  * for inclusion in the Apcupsd package
  26  *
  27  */
  28
  29
  30 #include "bacula.h"
  31 #include "jcr.h"
  32 #include <netdb.h>
  33
  34 #ifndef   INADDR_NONE
  35 #define   INADDR_NONE    -1
  36 #endif
  37
  38 #ifdef HAVE_WIN32
  39 #undef inet_pton
  40 #define inet_pton binet_pton
  41 #define socketRead(fd, buf, len)  recv(fd, buf, len, 0)
  42 #define socketWrite(fd, buf, len) send(fd, buf, len, 0)
  43 #define socketClose(fd)           closesocket(fd)
  44 #else
  45 #define socketRead(fd, buf, len)  read(fd, buf, len)
  46 #define socketWrite(fd, buf, len) write(fd, buf, len)
  47 #define socketClose(fd)           close(fd)
  48 #endif
  49
  50 #ifndef HAVE_GETADDRINFO
  51 static pthread_mutex_t ip_mutex = PTHREAD_MUTEX_INITIALIZER;
  52 #endif
  53
  54 /*
  55  * Read a nbytes from the network.
  56  * It is possible that the total bytes require in several
  57  * read requests
  58  */
  59
  60 int32_t read_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
  61 {
  62    int32_t nleft, nread;
  63
  64 #ifdef HAVE_TLS
  65    if (bsock->tls) {
  66       /* TLS enabled */
  67       return (tls_bsock_readn(bsock, ptr, nbytes));
  68    }
  69 #endif /* HAVE_TLS */
  70
  71    nleft = nbytes;
  72    while (nleft > 0) {
  73       errno = 0;
  74       nread = socketRead(bsock->m_fd, ptr, nleft);
  75       if (bsock->is_timed_out() || bsock->is_terminated()) {
  76          return -1;
  77       }
  78
  79 #ifdef HAVE_WIN32
  80       /*
  81        * We simulate errno on Windows for a socket
  82        *  error in order to handle errors correctly.
  83        */
  84       if (nread == SOCKET_ERROR) {
  85         DWORD err = WSAGetLastError();
  86         nread = -1;
  87         if (err == WSAEINTR) {
  88            errno = EINTR;
  89         } else if (err == WSAEWOULDBLOCK) {
  90            errno = EAGAIN;
  91         } else {
  92            errno = EIO;            /* some other error */
  93         }
  94      }
  95 #endif
  96
  97       if (nread == -1) {
  98          if (errno == EINTR) {
  99             continue;
 100          }
 101          if (errno == EAGAIN) {
 102             bmicrosleep(0, 20000);  /* try again in 20ms */
 103             continue;
 104          }
 105       }
 106       if (nread <= 0) {
 107          return -1;                /* error, or EOF */
 108       }
 109       nleft -= nread;
 110       ptr += nread;
 111       if (bsock->use_bwlimit()) {
 112          bsock->control_bwlimit(nread);
 113       }
 114    }
 115    return nbytes - nleft;          /* return >= 0 */
 116 }
 117
 118 /*
 119  * Write nbytes to the network.
 120  * It may require several writes.
 121  */
 122
 123 int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes)
 124 {
 125    int32_t nleft, nwritten;
 126
 127    if (bsock->is_spooling()) {
 128       nwritten = fwrite(ptr, 1, nbytes, bsock->m_spool_fd);
 129       if (nwritten != nbytes) {
 130          berrno be;
 131          bsock->b_errno = errno;
 132          Qmsg3(bsock->jcr(), M_FATAL, 0, _("Attr spool write error. wrote=%d wanted=%d bytes. ERR=%s\n"),
 133                nbytes, nwritten, be.bstrerror());
 134          Dmsg2(400, "nwritten=%d nbytes=%d.\n", nwritten, nbytes);
 135          errno = bsock->b_errno;
 136          return -1;
 137       }
 138       return nbytes;
 139    }
 140
 141 #ifdef HAVE_TLS
 142    if (bsock->tls) {
 143       /* TLS enabled */
 144       return (tls_bsock_writen(bsock, ptr, nbytes));
 145    }
 146 #endif /* HAVE_TLS */
 147
 148    nleft = nbytes;
 149    while (nleft > 0) {
 150       do {
 151          errno = 0;
 152          nwritten = socketWrite(bsock->m_fd, ptr, nleft);
 153          if (bsock->is_timed_out() || bsock->is_terminated()) {
 154             return -1;
 155          }
 156
 157 #ifdef HAVE_WIN32
 158          /*
 159           * We simulate errno on Windows for a socket
 160           *  error in order to handle errors correctly.
 161           */
 162          if (nwritten == SOCKET_ERROR) {
 163             DWORD err = WSAGetLastError();
 164             nwritten = -1;
 165             if (err == WSAEINTR) {
 166                errno = EINTR;
 167             } else if (err == WSAEWOULDBLOCK) {
 168                errno = EAGAIN;
 169             } else {
 170                errno = EIO;        /* some other error */
 171             }
 172          }
 173 #endif
 174
 175       } while (nwritten == -1 && errno == EINTR);
 176       /*
 177        * If connection is non-blocking, we will get EAGAIN, so
 178        * use select() to keep from consuming all the CPU
 179        * and try again.
 180        */
 181       if (nwritten == -1 && errno == EAGAIN) {
 182          fd_set fdset;
 183          struct timeval tv;
 184
 185          FD_ZERO(&fdset);
 186          FD_SET((unsigned)bsock->m_fd, &fdset);
 187          tv.tv_sec = 1;
 188          tv.tv_usec = 0;
 189          select(bsock->m_fd + 1, NULL, &fdset, NULL, &tv);
 190          continue;
 191       }
 192       if (nwritten <= 0) {
 193          return -1;                /* error */
 194       }
 195       nleft -= nwritten;
 196       ptr += nwritten;
 197       if (bsock->use_bwlimit()) {
 198          bsock->control_bwlimit(nwritten);
 199       }
 200    }
 201    return nbytes - nleft;
 202 }
 203
 204 /*
 205  * Establish a TLS connection -- server side
 206  *  Returns: true  on success
 207  *           false on failure
 208  */
 209 #ifdef HAVE_TLS
 210 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 211 {
 212    TLS_CONNECTION *tls;
 213    JCR *jcr = bsock->jcr();
 214
 215    tls = new_tls_connection(ctx, bsock->m_fd);
 216    if (!tls) {
 217       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 218       return false;
 219    }
 220
 221    bsock->tls = tls;
 222
 223    /* Initiate TLS Negotiation */
 224    if (!tls_bsock_accept(bsock)) {
 225       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS Negotiation failed.\n"));
 226       goto err;
 227    }
 228
 229    if (verify_list) {
 230       if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
 231          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 232                                          " Peer certificate did not match a required commonName\n"),
 233                                          bsock->host());
 234          goto err;
 235       }
 236    }
 237    Dmsg0(50, "TLS server negotiation established.\n");
 238    return true;
 239
 240 err:
 241    free_tls_connection(tls);
 242    bsock->tls = NULL;
 243    return false;
 244 }
 245
 246 /*
 247  * Establish a TLS connection -- client side
 248  * Returns: true  on success
 249  *          false on failure
 250  */
 251 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK *bsock, alist *verify_list)
 252 {
 253    TLS_CONNECTION *tls;
 254    JCR *jcr = bsock->jcr();
 255
 256    tls  = new_tls_connection(ctx, bsock->m_fd);
 257    if (!tls) {
 258       Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
 259       return false;
 260    }
 261
 262    bsock->tls = tls;
 263
 264    /* Initiate TLS Negotiation */
 265    if (!tls_bsock_connect(bsock)) {
 266       goto err;
 267    }
 268
 269    /* If there's an Allowed CN verify list, use that to validate the remote
 270     * certificate's CN. Otherwise, we use standard host/CN matching. */
 271    if (verify_list) {
 272       if (!tls_postconnect_verify_cn(jcr, tls, verify_list)) {
 273          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed."
 274                                          " Peer certificate did not match a required commonName\n"),
 275                                          bsock->host());
 276          goto err;
 277       }
 278    } else if (!tls_postconnect_verify_host(jcr, tls, bsock->host())) {
 279       /* If host is 127.0.0.1, try localhost */
 280       if (strcmp(bsock->host(), "127.0.0.1") != 0 ||
 281              !tls_postconnect_verify_host(jcr, tls, "localhost")) {
 282          Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host name \"%s\" did not match presented certificate\n"),
 283                bsock->host());
 284          goto err;
 285       }
 286    }
 287    Dmsg0(50, "TLS client negotiation established.\n");
 288    return true;
 289
 290 err:
 291    free_tls_connection(tls);
 292    bsock->tls = NULL;
 293    return false;
 294 }
 295 #else
 296
 297 bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 298 {
 299    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n"));
 300    return false;
 301 }
 302
 303 bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list)
 304 {
 305    Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n"));
 306    return false;
 307 }
 308
 309 #endif /* HAVE_TLS */
 310
 311 #ifndef NETDB_INTERNAL
 312 #define NETDB_INTERNAL  -1         /* See errno. */
 313 #endif
 314 #ifndef NETDB_SUCCESS
 315 #define NETDB_SUCCESS   0          /* No problem. */
 316 #endif
 317 #ifndef HOST_NOT_FOUND
 318 #define HOST_NOT_FOUND  1          /* Authoritative Answer Host not found. */
 319 #endif
 320 #ifndef TRY_AGAIN
 321 #define TRY_AGAIN       2          /* Non-Authoritative Host not found, or SERVERFAIL. */
 322 #endif
 323 #ifndef NO_RECOVERY
 324 #define NO_RECOVERY     3          /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */
 325 #endif
 326 #ifndef NO_DATA
 327 #define NO_DATA         4          /* Valid name, no data record of requested type. */
 328 #endif
 329
 330 static IPADDR *add_any(int family)
 331 {
 332    IPADDR *addr = New(IPADDR(family));
 333    addr->set_type(IPADDR::R_MULTIPLE);
 334    addr->set_addr_any();
 335    return addr;
 336 }
 337
 338 #if defined(HAVE_GETADDRINFO)
 339 /*
 340  * getaddrinfo.c - Simple example of using getaddrinfo(3) function.
 341  *
 342  * Michal Ludvig <michal@logix.cz> (c) 2002, 2003
 343  * http://www.logix.cz/michal/devel/
 344  *
 345  * License: public domain.
 346  */
 347 const char *resolv_host(int family, const char *host, dlist *addr_list)
 348 {
 349    IPADDR *ipaddr;
 350    struct addrinfo hints, *res, *rp;
 351    int errcode;
 352    //char addrstr[100];
 353    void *ptr;
 354
 355    memset (&hints, 0, sizeof(hints));
 356    hints.ai_family = family;
 357    hints.ai_socktype = SOCK_STREAM;
 358    //hints.ai_flags |= AI_CANONNAME;
 359
 360    errcode = getaddrinfo (host, NULL, &hints, &res);
 361    if (errcode != 0) return gai_strerror(errcode);
 362
 363    for (rp=res; res; res=res->ai_next) {
 364       //inet_ntop (res->ai_family, res->ai_addr->sa_data, addrstr, 100);
 365       switch (res->ai_family) {
 366       case AF_INET:
 367          ipaddr = New(IPADDR(rp->ai_addr->sa_family));
 368          ipaddr->set_type(IPADDR::R_MULTIPLE);
 369          ptr = &((struct sockaddr_in *) res->ai_addr)->sin_addr;
 370          ipaddr->set_addr4((in_addr *)ptr);
 371          break;
 372 #if defined(HAVE_IPV6)
 373       case AF_INET6:
 374          ipaddr = New(IPADDR(rp->ai_addr->sa_family));
 375          ipaddr->set_type(IPADDR::R_MULTIPLE);
 376          ptr = &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr;
 377          ipaddr->set_addr6((in6_addr *)ptr);
 378          break;
 379 #endif
 380       default:
 381          continue;
 382       }
 383       //inet_ntop (res->ai_family, ptr, addrstr, 100);
 384       //Pmsg3(000, "IPv%d address: %s (%s)\n", res->ai_family == PF_INET6 ? 6 : 4,
 385       //         addrstr, res->ai_canonname);
 386       addr_list->append(ipaddr);
 387    }
 388    freeaddrinfo(rp);
 389    return NULL;
 390 }
 391
 392 #else
 393
 394 /*
 395  * Get human readable error for gethostbyname()
 396  */
 397 static const char *gethost_strerror()
 398 {
 399    const char *msg;
 400    berrno be;
 401    switch (h_errno) {
 402    case NETDB_INTERNAL:
 403       msg = be.bstrerror();
 404       break;
 405    case NETDB_SUCCESS:
 406       msg = _("No problem.");
 407       break;
 408    case HOST_NOT_FOUND:
 409       msg = _("Authoritative answer for host not found.");
 410       break;
 411    case TRY_AGAIN:
 412       msg = _("Non-authoritative for host not found, or ServerFail.");
 413       break;
 414    case NO_RECOVERY:
 415       msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.");
 416       break;
 417    case NO_DATA:
 418       msg = _("Valid name, no data record of resquested type.");
 419       break;
 420    default:
 421       msg = _("Unknown error.");
 422    }
 423    return msg;
 424 }
 425
 426 /*
 427  * Note: this is the old way of resolving a host
 428  *  that does not use the new getaddrinfo() above.
 429  */
 430 static const char *resolv_host(int family, const char *host, dlist * addr_list)
 431 {
 432    struct hostent *hp;
 433    const char *errmsg;
 434
 435    P(ip_mutex);                       /* gethostbyname() is not thread safe */
 436 #ifdef HAVE_GETHOSTBYNAME2
 437    if ((hp = gethostbyname2(host, family)) == NULL) {
 438 #else
 439    if ((hp = gethostbyname(host)) == NULL) {
 440 #endif
 441       /* may be the strerror give not the right result -:( */
 442       errmsg = gethost_strerror();
 443       V(ip_mutex);
 444       return errmsg;
 445    } else {
 446       char **p;
 447       for (p = hp->h_addr_list; *p != 0; p++) {
 448          IPADDR *addr =  New(IPADDR(hp->h_addrtype));
 449          addr->set_type(IPADDR::R_MULTIPLE);
 450          if (addr->get_family() == AF_INET) {
 451              addr->set_addr4((struct in_addr*)*p);
 452          }
 453 #ifdef HAVE_IPV6
 454          else {
 455              addr->set_addr6((struct in6_addr*)*p);
 456          }
 457 #endif
 458          addr_list->append(addr);
 459       }
 460       V(ip_mutex);
 461    }
 462    return NULL;
 463 }
 464 #endif
 465
 466 /*
 467  * i host = 0 means INADDR_ANY only for IPv4
 468  */
 469 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr)
 470 {
 471    struct in_addr inaddr;
 472    IPADDR *addr = 0;
 473    const char *errmsg;
 474 #ifdef HAVE_IPV6
 475    struct in6_addr inaddr6;
 476 #endif
 477
 478    dlist *addr_list = New(dlist(addr, &addr->link));
 479    if (!host || host[0] == '\0') {
 480       if (family != 0) {
 481          addr_list->append(add_any(family));
 482       } else {
 483          addr_list->append(add_any(AF_INET));
 484 #ifdef HAVE_IPV6
 485          addr_list->append(add_any(AF_INET6));
 486 #endif
 487       }
 488    } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */
 489       addr = New(IPADDR(AF_INET));
 490       addr->set_type(IPADDR::R_MULTIPLE);
 491       addr->set_addr4(&inaddr);
 492       addr_list->append(addr);
 493 #ifdef HAVE_IPV6
 494    } else if (inet_pton(AF_INET6, host, &inaddr6) == 1) {
 495       addr = New(IPADDR(AF_INET6));
 496       addr->set_type(IPADDR::R_MULTIPLE);
 497       addr->set_addr6(&inaddr6);
 498       addr_list->append(addr);
 499 #endif
 500    } else {
 501       if (family != 0) {
 502          errmsg = resolv_host(family, host, addr_list);
 503          if (errmsg) {
 504             *errstr = errmsg;
 505             free_addresses(addr_list);
 506             return 0;
 507          }
 508       } else {
 509 #ifdef HAVE_IPV6
 510          /* We try to resolv host for ipv6 and ipv4, the connection procedure
 511           * will try to reach the host for each protocols. We report only "Host
 512           * not found" ipv4 message (no need to have ipv6 and ipv4 messages).
 513           */
 514          resolv_host(AF_INET6, host, addr_list);
 515 #endif
 516          errmsg = resolv_host(AF_INET, host, addr_list);
 517
 518          if (addr_list->size() == 0) {
 519             *errstr = errmsg;
 520             free_addresses(addr_list);
 521             return 0;
 522          }
 523       }
 524    }
 525    return addr_list;
 526 }
 527
 528 /*
 529  * Convert a network "signal" code into
 530  * human readable ASCII.
 531  */
 532 const char *bnet_sig_to_ascii(int32_t msglen)
 533 {
 534    static char buf[30];
 535    switch (msglen) {
 536    case BNET_EOD:
 537       return "BNET_EOD";           /* end of data stream */
 538    case BNET_EOD_POLL:
 539       return "BNET_EOD_POLL";
 540    case BNET_STATUS:
 541       return "BNET_STATUS";
 542    case BNET_TERMINATE:
 543       return "BNET_TERMINATE";     /* terminate connection */
 544    case BNET_POLL:
 545       return "BNET_POLL";
 546    case BNET_HEARTBEAT:
 547       return "BNET_HEARTBEAT";
 548    case BNET_HB_RESPONSE:
 549       return "BNET_HB_RESPONSE";
 550    case BNET_SUB_PROMPT:
 551       return "BNET_SUB_PROMPT";
 552    case BNET_TEXT_INPUT:
 553       return "BNET_TEXT_INPUT";
 554    default:
 555       bsnprintf(buf, sizeof(buf), _("Unknown sig %d"), (int)msglen);
 556       return buf;
 557    }
 558 }
 559
 560 /* Initialize internal socket structure.
 561  *  This probably should be done in net_open
 562  */
 563 BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
 564                   struct sockaddr *client_addr)
 565 {
 566    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
 567    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 568    memset(bsock, 0, sizeof(BSOCK));
 569    bsock->m_fd = sockfd;
 570    bsock->tls = NULL;
 571    bsock->errors = 0;
 572    bsock->m_blocking = 1;
 573    bsock->pout_msg_no = &bsock->out_msg_no;
 574    bsock->msg = get_pool_memory(PM_BSOCK);
 575    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 576    bsock->set_who(bstrdup(who));
 577    bsock->set_host(bstrdup(host));
 578    bsock->set_port(port);
 579    memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr));
 580    memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
 581    bsock->timeout = BSOCK_TIMEOUT;
 582    bsock->set_jcr(jcr);
 583    return bsock;
 584 }
 585
 586 BSOCK *dup_bsock(BSOCK *osock)
 587 {
 588    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
 589    osock->set_locking();
 590    memcpy(bsock, osock, sizeof(BSOCK));
 591    bsock->msg = get_pool_memory(PM_BSOCK);
 592    bsock->errmsg = get_pool_memory(PM_MESSAGE);
 593    if (osock->who()) {
 594       bsock->set_who(bstrdup(osock->who()));
 595    }
 596    if (osock->host()) {
 597       bsock->set_host(bstrdup(osock->host()));
 598    }
 599    if (osock->src_addr) {
 600       bsock->src_addr = New( IPADDR( *(osock->src_addr)) );
 601    }
 602    bsock->set_duped();
 603    return bsock;
 604 }
 605
 606 int set_socket_errno(int sockstat)
 607 {
 608 #ifdef HAVE_WIN32
 609    /*
 610     * For Windows, we must simulate Unix errno on a socket
 611     *  error in order to handle errors correctly.
 612     */
 613    if (sockstat == SOCKET_ERROR) {
 614       berrno be;
 615       DWORD err = WSAGetLastError();
 616       if (err == WSAEINTR) {
 617          errno = EINTR;
 618          return sockstat;
 619       } else if (err == WSAEWOULDBLOCK) {
 620          errno = EAGAIN;
 621          return sockstat;
 622       } else {
 623          errno = b_errno_win32 | b_errno_WSA;
 624       }
 625       Dmsg2(20, "Socket error: err=%d %s\n", err, be.bstrerror(err));
 626    }
 627 #else
 628    if (sockstat == SOCKET_ERROR) {
 629       /* Handle errrors from prior connections as EAGAIN */
 630       switch (errno) {
 631          case ENETDOWN:
 632          case EPROTO:
 633          case ENOPROTOOPT:
 634          case EHOSTDOWN:
 635 #ifdef ENONET
 636          case ENONET:
 637 #endif
 638          case EHOSTUNREACH:
 639          case EOPNOTSUPP:
 640          case ENETUNREACH:
 641             errno = EAGAIN;
 642             break;
 643          default:
 644             break;
 645       }
 646    }
 647 #endif
 648    return sockstat;
 649 }