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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2007-2008 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 Kern Sibbald.
  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  *   Version $Id: $
  34  */
  35
  36
  37 #include "bacula.h"
  38 #include "jcr.h"
  39 #include <netdb.h>
  40
  41 #ifndef ENODATA                    /* not defined on BSD systems */
  42 #define ENODATA EPIPE
  43 #endif
  44
  45 #ifdef HAVE_WIN32
  46 #define socketRead(fd, buf, len)  ::recv(fd, buf, len, 0)
  47 #define socketWrite(fd, buf, len) ::send(fd, buf, len, 0)
  48 #define socketClose(fd)           ::closesocket(fd)
  49 #else
  50 #define socketRead(fd, buf, len)  ::read(fd, buf, len)
  51 #define socketWrite(fd, buf, len) ::write(fd, buf, len)
  52 #define socketClose(fd)           ::close(fd)
  53 #endif
  54
  55 /*
  56  * This is a non-class BSOCK "constructor"  because we want to
  57  *   call the Bacula smartalloc routines instead of new.
  58  */
  59 BSOCK *new_bsock()
  60 {
  61    BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
  62    bsock->init();
  63    return bsock;
  64 }
  65
  66 void BSOCK::init()
  67 {
  68    memset(this, 0, sizeof(BSOCK));
  69    m_blocking = 1;
  70    msg = get_pool_memory(PM_MESSAGE);
  71    errmsg = get_pool_memory(PM_MESSAGE);
  72    /*
  73     * ****FIXME**** reduce this to a few hours once
  74     *   heartbeats are implemented
  75     */
  76    timeout = 60 * 60 * 6 * 24;   /* 6 days timeout */
  77 }
  78
  79 /*
  80  * This is our "class destructor" that ensures that we use
  81  *   smartalloc rather than the system free().
  82  */
  83 void BSOCK::free_bsock()
  84 {
  85    destroy();
  86 }
  87
  88 void BSOCK::free_tls()
  89 {
  90    free_tls_connection(this->tls);
  91    this->tls = NULL;
  92 }
  93
  94 /*
  95  * Try to connect to host for max_retry_time at retry_time intervals.
  96  *   Note, you must have called the constructor prior to calling
  97  *   this routine.
  98  */
  99 bool BSOCK::connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
 100                     utime_t heart_beat,
 101                     const char *name, char *host, char *service, int port,
 102                     int verbose)
 103 {
 104    bool ok = false;
 105    int i;
 106    int fatal = 0;
 107    time_t begin_time = time(NULL);
 108    time_t now;
 109    btimer_t *tid = NULL;
 110
 111    /* Try to trap out of OS call when time expires */
 112    if (max_retry_time) {
 113       tid = start_thread_timer(jcr, pthread_self(), (uint32_t)max_retry_time);
 114    }
 115
 116    for (i = 0; !open(jcr, name, host, service, port, heart_beat, &fatal);
 117         i -= retry_interval) {
 118       berrno be;
 119       if (fatal || (jcr && job_canceled(jcr))) {
 120          goto bail_out;
 121       }
 122       Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
 123             name, host, port, be.bstrerror());
 124       if (i < 0) {
 125          i = 60 * 5;               /* complain again in 5 minutes */
 126          if (verbose)
 127             Qmsg4(jcr, M_WARNING, 0, _(
 128                "Could not connect to %s on %s:%d. ERR=%s\n"
 129                "Retrying ...\n"), name, host, port, be.bstrerror());
 130       }
 131       bmicrosleep(retry_interval, 0);
 132       now = time(NULL);
 133       if (begin_time + max_retry_time <= now) {
 134          Qmsg4(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"),
 135                name, host, port, be.bstrerror());
 136          goto bail_out;
 137       }
 138    }
 139    ok = true;
 140
 141 bail_out:
 142    if (tid) {
 143       stop_thread_timer(tid);
 144    }
 145    return ok;
 146 }
 147
 148
 149 /*
 150  * Finish initialization of the pocket structure.
 151  */
 152 void BSOCK::fin_init(JCR * jcr, int sockfd, const char *who, const char *host, int port,
 153             struct sockaddr *lclient_addr)
 154 {
 155    Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
 156    m_fd = sockfd;
 157    set_who(bstrdup(who));
 158    set_host(bstrdup(host));
 159    set_port(port);
 160    memcpy(&client_addr, lclient_addr, sizeof(client_addr));
 161    set_jcr(jcr);
 162 }
 163
 164 /*
 165  * Copy the address from the configuration dlist that gets passed in
 166  */
 167 void BSOCK::set_source_address(dlist *src_addr_list)
 168 {
 169    IPADDR *addr = NULL;
 170
 171    // delete the object we already have, if it's allocated
 172    if (src_addr) {
 173      free( src_addr);
 174      src_addr = NULL;
 175    }
 176
 177    if (src_addr_list) {
 178      addr = (IPADDR*) src_addr_list->first();
 179      src_addr = New( IPADDR(*addr));
 180    }
 181 }
 182
 183
 184 /*
 185  * Open a TCP connection to the server
 186  * Returns NULL
 187  * Returns BSOCK * pointer on success
 188  *
 189  */
 190 bool BSOCK::open(JCR *jcr, const char *name, char *host, char *service,
 191             int port, utime_t heart_beat, int *fatal)
 192 {
 193    int sockfd = -1;
 194    dlist *addr_list;
 195    IPADDR *ipaddr;
 196    bool connected = false;
 197    int turnon = 1;
 198    const char *errstr;
 199    int save_errno = 0;
 200
 201    /*
 202     * Fill in the structure serv_addr with the address of
 203     * the server that we want to connect with.
 204     */
 205    if ((addr_list = bnet_host2ipaddrs(host, 0, &errstr)) == NULL) {
 206       /* Note errstr is not malloc'ed */
 207       Qmsg2(jcr, M_ERROR, 0, _("gethostbyname() for host \"%s\" failed: ERR=%s\n"),
 208             host, errstr);
 209       Dmsg2(100, "bnet_host2ipaddrs() for host %s failed: ERR=%s\n",
 210             host, errstr);
 211       *fatal = 1;
 212       return false;
 213    }
 214
 215    foreach_dlist(ipaddr, addr_list) {
 216       ipaddr->set_port_net(htons(port));
 217       char allbuf[256 * 10];
 218       char curbuf[256];
 219       Dmsg2(100, "Current %sAll %s\n",
 220                    ipaddr->build_address_str(curbuf, sizeof(curbuf)),
 221                    build_addresses_str(addr_list, allbuf, sizeof(allbuf)));
 222       /* Open a TCP socket */
 223       if ((sockfd = socket(ipaddr->get_family(), SOCK_STREAM, 0)) < 0) {
 224          berrno be;
 225          save_errno = errno;
 226          *fatal = 1;
 227          Pmsg3(000, _("Socket open error. proto=%d port=%d. ERR=%s\n"),
 228             ipaddr->get_family(), ipaddr->get_port_host_order(), be.bstrerror());
 229          continue;
 230       }
 231
 232       /* Bind to the source address if it is set */
 233       if (src_addr) {
 234          if (bind(sockfd, src_addr->get_sockaddr(), src_addr->get_sockaddr_len()) < 0) {
 235             berrno be;
 236             save_errno = errno;
 237             *fatal = 1;
 238             Pmsg2(000, _("Source address bind error. proto=%d. ERR=%s\n"),
 239                   src_addr->get_family(), be.bstrerror() );
 240             continue;
 241          }
 242       }
 243
 244       /*
 245        * Keep socket from timing out from inactivity
 246        */
 247       if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 248          berrno be;
 249          Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 250                be.bstrerror());
 251       }
 252 #if defined(TCP_KEEPIDLE)
 253       if (heart_beat) {
 254          int opt = heart_beat
 255          if (setsockopt(sockfd, IPPROTO_IP, TCP_KEEPIDLE, (sockopt_val_t)&opt, sizeof(opt)) < 0) {
 256             berrno be;
 257             Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPIDLE on socket: %s\n"),
 258                   be.bstrerror());
 259          }
 260       }
 261 #endif
 262
 263       /* connect to server */
 264       if (::connect(sockfd, ipaddr->get_sockaddr(), ipaddr->get_sockaddr_len()) < 0) {
 265          save_errno = errno;
 266          socketClose(sockfd);
 267          continue;
 268       }
 269       *fatal = 0;
 270       connected = true;
 271       break;
 272    }
 273
 274    if (!connected) {
 275       free_addresses(addr_list);
 276       errno = save_errno | b_errno_win32;
 277       return false;
 278    }
 279    /*
 280     * Keep socket from timing out from inactivity
 281     *   Do this a second time out of paranoia
 282     */
 283    if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 284       berrno be;
 285       Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 286             be.bstrerror());
 287    }
 288    fin_init(jcr, sockfd, name, host, port, ipaddr->get_sockaddr());
 289    free_addresses(addr_list);
 290    return true;
 291 }
 292
 293 /*
 294  * Force read/write to use locking
 295  */
 296 bool BSOCK::set_locking()
 297 {
 298    int stat;
 299    if (m_use_locking) {
 300       return true;                      /* already set */
 301    }
 302    if ((stat = pthread_mutex_init(&m_mutex, NULL)) != 0) {
 303       berrno be;
 304       Jmsg(m_jcr, M_FATAL, 0, _("Could not init bsock mutex. ERR=%s\n"),
 305          be.bstrerror(stat));
 306       return false;
 307    }
 308    m_use_locking = true;
 309    return true;
 310 }
 311
 312 void BSOCK::clear_locking()
 313 {
 314    if (!m_use_locking) {
 315       return;
 316    }
 317    m_use_locking = false;
 318    pthread_mutex_destroy(&m_mutex);
 319    return;
 320 }
 321
 322 /*
 323  * Send a message over the network. The send consists of
 324  * two network packets. The first is sends a 32 bit integer containing
 325  * the length of the data packet which follows.
 326  *
 327  * Returns: false on failure
 328  *          true  on success
 329  */
 330 bool BSOCK::send()
 331 {
 332    int32_t rc;
 333    int32_t pktsiz;
 334    int32_t *hdr;
 335    bool ok = true;
 336
 337    if (errors || is_terminated() || msglen > 1000000) {
 338       return false;
 339    }
 340    if (m_use_locking) P(m_mutex);
 341    /* Compute total packet length */
 342    if (msglen <= 0) {
 343       pktsiz = sizeof(pktsiz);               /* signal, no data */
 344    } else {
 345       pktsiz = msglen + sizeof(pktsiz);      /* data */
 346    }
 347    /* Store packet length at head of message -- note, we
 348     *  have reserved an int32_t just before msg, so we can
 349     *  store there
 350     */
 351    hdr = (int32_t *)(msg - (int)sizeof(pktsiz));
 352    *hdr = htonl(msglen);                     /* store signal/length */
 353
 354    out_msg_no++;            /* increment message number */
 355
 356    /* send data packet */
 357    timer_start = watchdog_time;  /* start timer */
 358    clear_timed_out();
 359    /* Full I/O done in one write */
 360    rc = write_nbytes(this, (char *)hdr, pktsiz);
 361    timer_start = 0;         /* clear timer */
 362    if (rc != pktsiz) {
 363       errors++;
 364       if (errno == 0) {
 365          b_errno = EIO;
 366       } else {
 367          b_errno = errno;
 368       }
 369       if (rc < 0) {
 370          if (!m_suppress_error_msgs) {
 371             Qmsg5(m_jcr, M_ERROR, 0,
 372                   _("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"),
 373                   msglen, m_who,
 374                   m_host, m_port, this->bstrerror());
 375          }
 376       } else {
 377          Qmsg5(m_jcr, M_ERROR, 0,
 378                _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
 379                msglen, m_who, m_host, m_port, rc);
 380       }
 381       ok = false;
 382    }
 383    if (m_use_locking) V(m_mutex);
 384    return ok;
 385 }
 386
 387 /*
 388  * Format and send a message
 389  *  Returns: false on error
 390  *           true  on success
 391  */
 392 bool BSOCK::fsend(const char *fmt, ...)
 393 {
 394    va_list arg_ptr;
 395    int maxlen;
 396
 397    if (errors || is_terminated()) {
 398       return false;
 399    }
 400    /* This probably won't work, but we vsnprintf, then if we
 401     * get a negative length or a length greater than our buffer
 402     * (depending on which library is used), the printf was truncated, so
 403     * get a bigger buffer and try again.
 404     */
 405    for (;;) {
 406       maxlen = sizeof_pool_memory(msg) - 1;
 407       va_start(arg_ptr, fmt);
 408       msglen = bvsnprintf(msg, maxlen, fmt, arg_ptr);
 409       va_end(arg_ptr);
 410       if (msglen > 0 && msglen < (maxlen - 5)) {
 411          break;
 412       }
 413       msg = realloc_pool_memory(msg, maxlen + maxlen / 2);
 414    }
 415    return send();
 416 }
 417
 418 /*
 419  * Receive a message from the other end. Each message consists of
 420  * two packets. The first is a header that contains the size
 421  * of the data that follows in the second packet.
 422  * Returns number of bytes read (may return zero)
 423  * Returns -1 on signal (BNET_SIGNAL)
 424  * Returns -2 on hard end of file (BNET_HARDEOF)
 425  * Returns -3 on error  (BNET_ERROR)
 426  *
 427  *  Unfortunately, it is a bit complicated because we have these
 428  *    four return types:
 429  *    1. Normal data
 430  *    2. Signal including end of data stream
 431  *    3. Hard end of file
 432  *    4. Error
 433  *  Using is_bnet_stop() and is_bnet_error() you can figure this all out.
 434  */
 435 int32_t BSOCK::recv()
 436 {
 437    int32_t nbytes;
 438    int32_t pktsiz;
 439
 440    msg[0] = 0;
 441    msglen = 0;
 442    if (errors || is_terminated()) {
 443       return BNET_HARDEOF;
 444    }
 445
 446    if (m_use_locking) P(m_mutex);
 447    read_seqno++;            /* bump sequence number */
 448    timer_start = watchdog_time;  /* set start wait time */
 449    clear_timed_out();
 450    /* get data size -- in int32_t */
 451    if ((nbytes = read_nbytes(this, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
 452       timer_start = 0;      /* clear timer */
 453       /* probably pipe broken because client died */
 454       if (errno == 0) {
 455          b_errno = ENODATA;
 456       } else {
 457          b_errno = errno;
 458       }
 459       errors++;
 460       nbytes = BNET_HARDEOF;        /* assume hard EOF received */
 461       goto get_out;
 462    }
 463    timer_start = 0;         /* clear timer */
 464    if (nbytes != sizeof(int32_t)) {
 465       errors++;
 466       b_errno = EIO;
 467       Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
 468             sizeof(int32_t), nbytes, m_who, m_host, m_port);
 469       nbytes = BNET_ERROR;
 470       goto get_out;
 471    }
 472
 473    pktsiz = ntohl(pktsiz);         /* decode no. of bytes that follow */
 474
 475    if (pktsiz == 0) {              /* No data transferred */
 476       timer_start = 0;             /* clear timer */
 477       in_msg_no++;
 478       msglen = 0;
 479       nbytes = 0;                  /* zero bytes read */
 480       goto get_out;
 481    }
 482
 483    /* If signal or packet size too big */
 484    if (pktsiz < 0 || pktsiz > 1000000) {
 485       if (pktsiz > 0) {            /* if packet too big */
 486          Qmsg3(m_jcr, M_FATAL, 0,
 487                _("Packet size too big from \"%s:%s:%d. Terminating connection.\n"),
 488                m_who, m_host, m_port);
 489          pktsiz = BNET_TERMINATE;  /* hang up */
 490       }
 491       if (pktsiz == BNET_TERMINATE) {
 492          set_terminated();
 493       }
 494       timer_start = 0;                /* clear timer */
 495       b_errno = ENODATA;
 496       msglen = pktsiz;                /* signal code */
 497       nbytes =  BNET_SIGNAL;          /* signal */
 498       goto get_out;
 499    }
 500
 501    /* Make sure the buffer is big enough + one byte for EOS */
 502    if (pktsiz >= (int32_t) sizeof_pool_memory(msg)) {
 503       msg = realloc_pool_memory(msg, pktsiz + 100);
 504    }
 505
 506    timer_start = watchdog_time;  /* set start wait time */
 507    clear_timed_out();
 508    /* now read the actual data */
 509    if ((nbytes = read_nbytes(this, msg, pktsiz)) <= 0) {
 510       timer_start = 0;      /* clear timer */
 511       if (errno == 0) {
 512          b_errno = ENODATA;
 513       } else {
 514          b_errno = errno;
 515       }
 516       errors++;
 517       Qmsg4(m_jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"),
 518             m_who, m_host, m_port, this->bstrerror());
 519       nbytes = BNET_ERROR;
 520       goto get_out;
 521    }
 522    timer_start = 0;         /* clear timer */
 523    in_msg_no++;
 524    msglen = nbytes;
 525    if (nbytes != pktsiz) {
 526       b_errno = EIO;
 527       errors++;
 528       Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
 529             pktsiz, nbytes, m_who, m_host, m_port);
 530       nbytes = BNET_ERROR;
 531       goto get_out;
 532    }
 533    /* always add a zero by to properly terminate any
 534     * string that was send to us. Note, we ensured above that the
 535     * buffer is at least one byte longer than the message length.
 536     */
 537    msg[nbytes] = 0; /* terminate in case it is a string */
 538    sm_check(__FILE__, __LINE__, false);
 539
 540 get_out:
 541    if (m_use_locking) V(m_mutex);
 542    return nbytes;                  /* return actual length of message */
 543 }
 544
 545
 546 /*
 547  * Send a signal
 548  */
 549 bool BSOCK::signal(int signal)
 550 {
 551    msglen = signal;
 552    if (signal == BNET_TERMINATE) {
 553       m_suppress_error_msgs = true;
 554    }
 555    return send();
 556 }
 557
 558 /*
 559  * Despool spooled attributes
 560  */
 561 bool BSOCK::despool(void update_attr_spool_size(ssize_t size), ssize_t tsize)
 562 {
 563    int32_t pktsiz;
 564    size_t nbytes;
 565    ssize_t last = 0, size = 0;
 566    int count = 0;
 567
 568    rewind(m_spool_fd);
 569
 570 #if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
 571    posix_fadvise(fileno(m_spool_fd), 0, 0, POSIX_FADV_WILLNEED);
 572 #endif
 573
 574    while (fread((char *)&pktsiz, 1, sizeof(int32_t), m_spool_fd) ==
 575           sizeof(int32_t)) {
 576       size += sizeof(int32_t);
 577       msglen = ntohl(pktsiz);
 578       if (msglen > 0) {
 579          if (msglen > (int32_t) sizeof_pool_memory(msg)) {
 580             msg = realloc_pool_memory(msg, msglen + 1);
 581          }
 582          nbytes = fread(msg, 1, msglen, m_spool_fd);
 583          if (nbytes != (size_t) msglen) {
 584             berrno be;
 585             Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
 586             Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
 587                   be.bstrerror());
 588             update_attr_spool_size(tsize - last);
 589             return false;
 590          }
 591          size += nbytes;
 592          if ((++count & 0x3F) == 0) {
 593             update_attr_spool_size(size - last);
 594             last = size;
 595          }
 596       }
 597       send();
 598    }
 599    update_attr_spool_size(tsize - last);
 600    if (ferror(m_spool_fd)) {
 601       berrno be;
 602       Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
 603             be.bstrerror());
 604       return false;
 605    }
 606    return true;
 607 }
 608
 609 /*
 610  * Return the string for the error that occurred
 611  * on the socket. Only the first error is retained.
 612  */
 613 const char *BSOCK::bstrerror()
 614 {
 615    berrno be;
 616    if (errmsg == NULL) {
 617       errmsg = get_pool_memory(PM_MESSAGE);
 618    }
 619    pm_strcpy(errmsg, be.bstrerror(b_errno));
 620    return errmsg;
 621 }
 622
 623 int BSOCK::get_peer(char *buf, socklen_t buflen)
 624 {
 625 #if !defined(HAVE_WIN32)
 626     if (peer_addr.sin_family == 0) {
 627         socklen_t salen = sizeof(peer_addr);
 628         int rval = (getpeername)(m_fd, (struct sockaddr *)&peer_addr, &salen);
 629         if (rval < 0) return rval;
 630     }
 631     if (!inet_ntop(peer_addr.sin_family, &peer_addr.sin_addr, buf, buflen))
 632         return -1;
 633
 634     return 0;
 635 #else
 636     return -1;
 637 #endif
 638 }
 639
 640 /*
 641  * Set the network buffer size, suggested size is in size.
 642  *  Actual size obtained is returned in bs->msglen
 643  *
 644  *  Returns: false on failure
 645  *           true  on success
 646  */
 647 bool BSOCK::set_buffer_size(uint32_t size, int rw)
 648 {
 649    uint32_t dbuf_size, start_size;
 650 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
 651    int opt;
 652    opt = IPTOS_THROUGHPUT;
 653    setsockopt(fd, IPPROTO_IP, IP_TOS, (sockopt_val_t)&opt, sizeof(opt));
 654 #endif
 655
 656    if (size != 0) {
 657       dbuf_size = size;
 658    } else {
 659       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 660    }
 661    start_size = dbuf_size;
 662    if ((msg = realloc_pool_memory(msg, dbuf_size + 100)) == NULL) {
 663       Qmsg0(get_jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
 664       return false;
 665    }
 666    if (rw & BNET_SETBUF_READ) {
 667       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
 668               SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 669          berrno be;
 670          Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
 671          dbuf_size -= TAPE_BSIZE;
 672       }
 673       Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
 674       if (dbuf_size != start_size) {
 675          Qmsg1(get_jcr(), M_WARNING, 0,
 676                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 677       }
 678       if (dbuf_size % TAPE_BSIZE != 0) {
 679          Qmsg1(get_jcr(), M_ABORT, 0,
 680                _("Network buffer size %d not multiple of tape block size.\n"),
 681                dbuf_size);
 682       }
 683    }
 684    if (size != 0) {
 685       dbuf_size = size;
 686    } else {
 687       dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
 688    }
 689    start_size = dbuf_size;
 690    if (rw & BNET_SETBUF_WRITE) {
 691       while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
 692               SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
 693          berrno be;
 694          Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
 695          dbuf_size -= TAPE_BSIZE;
 696       }
 697       Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
 698       if (dbuf_size != start_size) {
 699          Qmsg1(get_jcr(), M_WARNING, 0,
 700                _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
 701       }
 702       if (dbuf_size % TAPE_BSIZE != 0) {
 703          Qmsg1(get_jcr(), M_ABORT, 0,
 704                _("Network buffer size %d not multiple of tape block size.\n"),
 705                dbuf_size);
 706       }
 707    }
 708
 709    msglen = dbuf_size;
 710    return true;
 711 }
 712
 713 /*
 714  * Set socket non-blocking
 715  * Returns previous socket flag
 716  */
 717 int BSOCK::set_nonblocking()
 718 {
 719 #ifndef HAVE_WIN32
 720    int oflags;
 721
 722    /* Get current flags */
 723    if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
 724       berrno be;
 725       Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
 726    }
 727
 728    /* Set O_NONBLOCK flag */
 729    if ((fcntl(m_fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
 730       berrno be;
 731       Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
 732    }
 733
 734    m_blocking = 0;
 735    return oflags;
 736 #else
 737    int flags;
 738    u_long ioctlArg = 1;
 739
 740    flags = m_blocking;
 741    ioctlsocket(m_fd, FIONBIO, &ioctlArg);
 742    m_blocking = 0;
 743
 744    return flags;
 745 #endif
 746 }
 747
 748 /*
 749  * Set socket blocking
 750  * Returns previous socket flags
 751  */
 752 int BSOCK::set_blocking()
 753 {
 754 #ifndef HAVE_WIN32
 755    int oflags;
 756    /* Get current flags */
 757    if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
 758       berrno be;
 759       Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
 760    }
 761
 762    /* Set O_NONBLOCK flag */
 763    if ((fcntl(m_fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
 764       berrno be;
 765       Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
 766    }
 767
 768    m_blocking = 1;
 769    return oflags;
 770 #else
 771    int flags;
 772    u_long ioctlArg = 0;
 773
 774    flags = m_blocking;
 775    ioctlsocket(m_fd, FIONBIO, &ioctlArg);
 776    m_blocking = 1;
 777
 778    return flags;
 779 #endif
 780 }
 781
 782 /*
 783  * Restores socket flags
 784  */
 785 void BSOCK::restore_blocking (int flags)
 786 {
 787 #ifndef HAVE_WIN32
 788    if ((fcntl(m_fd, F_SETFL, flags)) < 0) {
 789       berrno be;
 790       Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
 791    }
 792
 793    m_blocking = (flags & O_NONBLOCK) ? true : false;
 794 #else
 795    u_long ioctlArg = flags;
 796
 797    ioctlsocket(m_fd, FIONBIO, &ioctlArg);
 798    m_blocking = 1;
 799 #endif
 800 }
 801
 802 /*
 803  * Wait for a specified time for data to appear on
 804  * the BSOCK connection.
 805  *
 806  *   Returns: 1 if data available
 807  *            0 if timeout
 808  *           -1 if error
 809  */
 810 int BSOCK::wait_data(int sec, int usec)
 811 {
 812    fd_set fdset;
 813    struct timeval tv;
 814
 815    FD_ZERO(&fdset);
 816    FD_SET((unsigned)m_fd, &fdset);
 817    for (;;) {
 818       tv.tv_sec = sec;
 819       tv.tv_usec = usec;
 820       switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
 821       case 0:                      /* timeout */
 822          b_errno = 0;
 823          return 0;
 824       case -1:
 825          b_errno = errno;
 826          if (errno == EINTR) {
 827             continue;
 828          }
 829          return -1;                /* error return */
 830       default:
 831          b_errno = 0;
 832          return 1;
 833       }
 834    }
 835 }
 836
 837 /*
 838  * As above, but returns on interrupt
 839  */
 840 int BSOCK::wait_data_intr(int sec, int usec)
 841 {
 842    fd_set fdset;
 843    struct timeval tv;
 844
 845    if (this == NULL) {
 846       return -1;
 847    }
 848    FD_ZERO(&fdset);
 849    FD_SET((unsigned)m_fd, &fdset);
 850    tv.tv_sec = sec;
 851    tv.tv_usec = usec;
 852    switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
 853    case 0:                      /* timeout */
 854       b_errno = 0;
 855       return 0;
 856    case -1:
 857       b_errno = errno;
 858       return -1;                /* error return */
 859    default:
 860       b_errno = 0;
 861       break;
 862    }
 863    return 1;
 864 }
 865
 866 /*
 867  * Note, this routine closes and destroys all the sockets
 868  *  that are open including the duped ones.
 869  */
 870 #ifndef SHUT_RDWR
 871 #define SHUT_RDWR 2
 872 #endif
 873
 874 void BSOCK::close()
 875 {
 876    BSOCK *bsock = this;
 877    BSOCK *next;
 878
 879    if (!m_duped) {
 880       clear_locking();
 881    }
 882    for (; bsock; bsock = next) {
 883       next = bsock->m_next;           /* get possible pointer to next before destoryed */
 884       if (!bsock->m_duped) {
 885          /* Shutdown tls cleanly. */
 886          if (bsock->tls) {
 887             tls_bsock_shutdown(bsock);
 888             free_tls_connection(bsock->tls);
 889             bsock->tls = NULL;
 890          }
 891          if (bsock->is_timed_out()) {
 892             shutdown(bsock->m_fd, SHUT_RDWR);   /* discard any pending I/O */
 893          }
 894          socketClose(bsock->m_fd);      /* normal close */
 895       }
 896       bsock->destroy();
 897    }
 898    return;
 899 }
 900
 901 void BSOCK::destroy()
 902 {
 903    if (msg) {
 904       free_pool_memory(msg);
 905       msg = NULL;
 906    } else {
 907       ASSERT(1 == 0);              /* double close */
 908    }
 909    if (errmsg) {
 910       free_pool_memory(errmsg);
 911       errmsg = NULL;
 912    }
 913    if (m_who) {
 914       free(m_who);
 915       m_who = NULL;
 916    }
 917    if (m_host) {
 918       free(m_host);
 919       m_host = NULL;
 920    }
 921    if (src_addr) {
 922       free(src_addr);
 923       src_addr = NULL;
 924    }
 925    free(this);
 926 }
 927
 928 /* Commands sent to Director */
 929 static char hello[]    = "Hello %s calling\n";
 930
 931 /* Response from Director */
 932 static char OKhello[]   = "1000 OK:";
 933
 934 /*
 935  * Authenticate Director
 936  */
 937 bool BSOCK::authenticate_director(const char *name, const char *password,
 938                TLS_CONTEXT *tls_ctx, char *msg, int msglen)
 939 {
 940    int tls_local_need = BNET_TLS_NONE;
 941    int tls_remote_need = BNET_TLS_NONE;
 942    int compatible = true;
 943    char bashed_name[MAX_NAME_LENGTH];
 944    BSOCK *dir = this;        /* for readability */
 945
 946    msg[0] = 0;
 947    /*
 948     * Send my name to the Director then do authentication
 949     */
 950
 951    /* Timeout Hello after 15 secs */
 952    dir->start_timer(15);
 953    dir->fsend(hello, bashed_name);
 954
 955    if (get_tls_enable(tls_ctx)) {
 956       tls_local_need = get_tls_enable(tls_ctx) ? BNET_TLS_REQUIRED : BNET_TLS_OK;
 957    }
 958
 959    /* respond to Dir challenge */
 960    if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
 961        /* Now challenge dir */
 962        !cram_md5_challenge(dir, password, tls_local_need, compatible)) {
 963       bsnprintf(msg, msglen, _("Director authorization problem at \"%s:%d\"\n"),
 964          dir->host(), dir->port());
 965       goto bail_out;
 966    }
 967
 968    /* Verify that the remote host is willing to meet our TLS requirements */
 969    if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
 970       bsnprintf(msg, msglen, _("Authorization problem:"
 971              " Remote server at \"%s:%d\" did not advertise required TLS support.\n"),
 972              dir->host(), dir->port());
 973       goto bail_out;
 974    }
 975
 976    /* Verify that we are willing to meet the remote host's requirements */
 977    if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
 978       bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\":"
 979                      " Remote server requires TLS.\n"),
 980                      dir->host(), dir->port());
 981
 982       goto bail_out;
 983    }
 984
 985    /* Is TLS Enabled? */
 986    if (have_tls) {
 987       if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
 988          /* Engage TLS! Full Speed Ahead! */
 989          if (!bnet_tls_client(tls_ctx, dir, NULL)) {
 990             bsnprintf(msg, msglen, _("TLS negotiation failed with Director at \"%s:%d\"\n"),
 991                dir->host(), dir->port());
 992             goto bail_out;
 993          }
 994       }
 995    }
 996
 997    Dmsg1(6, ">dird: %s", dir->msg);
 998    if (dir->recv() <= 0) {
 999       dir->stop_timer();
1000       bsnprintf(msg, msglen, _("Bad response to Hello command: ERR=%s\n"
1001                       "The Director at \"%s:%d\" is probably not running.\n"),
1002                     dir->bstrerror(), dir->host(), dir->port());
1003       return false;
1004    }
1005
1006   dir->stop_timer();
1007    Dmsg1(10, "<dird: %s", dir->msg);
1008    if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
1009       bsnprintf(msg, msglen, _("Director at \"%s:%d\" rejected Hello command\n"),
1010          dir->host(), dir->port());
1011       return false;
1012    } else {
1013       bsnprintf(msg, msglen, "%s", dir->msg);
1014    }
1015    return true;
1016
1017 bail_out:
1018    dir->stop_timer();
1019    bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\"\n"
1020              "Most likely the passwords do not agree.\n"
1021              "If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
1022              "Please see http://www.bacula.org/en/rel-manual/Bacula_Freque_Asked_Questi.html#SECTION003760000000000000000 for help.\n"),
1023              dir->host(), dir->port());
1024    return false;
1025 }