2 Bacula® - The Network Backup Solution
4 Copyright (C) 2007-2011 Free Software Foundation Europe e.V.
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 three of the GNU Affero General Public
10 License as published by the Free Software Foundation and included
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.
18 You should have received a copy of the GNU Affero 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
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.
29 * Network Utility Routines
40 #ifndef ENODATA /* not defined on BSD systems */
45 #define socketRead(fd, buf, len) ::recv(fd, buf, len, 0)
46 #define socketWrite(fd, buf, len) ::send(fd, buf, len, 0)
47 #define socketClose(fd) ::closesocket(fd)
49 #define socketRead(fd, buf, len) ::read(fd, buf, len)
50 #define socketWrite(fd, buf, len) ::write(fd, buf, len)
51 #define socketClose(fd) ::close(fd)
55 * This is a non-class BSOCK "constructor" because we want to
56 * call the Bacula smartalloc routines instead of new.
60 BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
67 memset(this, 0, sizeof(BSOCK));
69 msg = get_pool_memory(PM_BSOCK);
70 errmsg = get_pool_memory(PM_MESSAGE);
72 * ****FIXME**** reduce this to a few hours once
73 * heartbeats are implemented
75 timeout = 60 * 60 * 6 * 24; /* 6 days timeout */
79 * This is our "class destructor" that ensures that we use
80 * smartalloc rather than the system free().
82 void BSOCK::free_bsock()
87 void BSOCK::free_tls()
89 free_tls_connection(this->tls);
94 * Try to connect to host for max_retry_time at retry_time intervals.
95 * Note, you must have called the constructor prior to calling
98 bool BSOCK::connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
100 const char *name, char *host, char *service, int port,
106 time_t begin_time = time(NULL);
108 btimer_t *tid = NULL;
110 /* Try to trap out of OS call when time expires */
111 if (max_retry_time) {
112 tid = start_thread_timer(jcr, pthread_self(), (uint32_t)max_retry_time);
115 for (i = 0; !open(jcr, name, host, service, port, heart_beat, &fatal);
116 i -= retry_interval) {
118 if (fatal || (jcr && job_canceled(jcr))) {
121 Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
122 name, host, port, be.bstrerror());
124 i = 60 * 5; /* complain again in 5 minutes */
126 Qmsg4(jcr, M_WARNING, 0, _(
127 "Could not connect to %s on %s:%d. ERR=%s\n"
128 "Retrying ...\n"), name, host, port, be.bstrerror());
130 bmicrosleep(retry_interval, 0);
132 if (begin_time + max_retry_time <= now) {
133 Qmsg4(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"),
134 name, host, port, be.bstrerror());
142 stop_thread_timer(tid);
149 * Finish initialization of the pocket structure.
151 void BSOCK::fin_init(JCR * jcr, int sockfd, const char *who, const char *host, int port,
152 struct sockaddr *lclient_addr)
154 Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
156 set_who(bstrdup(who));
157 set_host(bstrdup(host));
159 memcpy(&client_addr, lclient_addr, sizeof(client_addr));
164 * Copy the address from the configuration dlist that gets passed in
166 void BSOCK::set_source_address(dlist *src_addr_list)
170 // delete the object we already have, if it's allocated
177 addr = (IPADDR*) src_addr_list->first();
178 src_addr = New( IPADDR(*addr));
184 * Open a TCP connection to the server
186 * Returns BSOCK * pointer on success
189 bool BSOCK::open(JCR *jcr, const char *name, char *host, char *service,
190 int port, utime_t heart_beat, int *fatal)
195 bool connected = false;
201 * Fill in the structure serv_addr with the address of
202 * the server that we want to connect with.
204 if ((addr_list = bnet_host2ipaddrs(host, 0, &errstr)) == NULL) {
205 /* Note errstr is not malloc'ed */
206 Qmsg2(jcr, M_ERROR, 0, _("gethostbyname() for host \"%s\" failed: ERR=%s\n"),
208 Dmsg2(100, "bnet_host2ipaddrs() for host %s failed: ERR=%s\n",
214 foreach_dlist(ipaddr, addr_list) {
215 ipaddr->set_port_net(htons(port));
216 char allbuf[256 * 10];
218 Dmsg2(100, "Current %sAll %s\n",
219 ipaddr->build_address_str(curbuf, sizeof(curbuf)),
220 build_addresses_str(addr_list, allbuf, sizeof(allbuf)));
221 /* Open a TCP socket */
222 if ((sockfd = socket(ipaddr->get_family(), SOCK_STREAM, 0)) < 0) {
226 Pmsg3(000, _("Socket open error. proto=%d port=%d. ERR=%s\n"),
227 ipaddr->get_family(), ipaddr->get_port_host_order(), be.bstrerror());
231 /* Bind to the source address if it is set */
233 if (bind(sockfd, src_addr->get_sockaddr(), src_addr->get_sockaddr_len()) < 0) {
237 Pmsg2(000, _("Source address bind error. proto=%d. ERR=%s\n"),
238 src_addr->get_family(), be.bstrerror() );
244 * Keep socket from timing out from inactivity
246 if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
248 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
251 #if defined(TCP_KEEPIDLE)
254 if (setsockopt(sockfd, IPPROTO_IP, TCP_KEEPIDLE, (sockopt_val_t)&opt, sizeof(opt)) < 0) {
256 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPIDLE on socket: %s\n"),
262 /* connect to server */
263 if (::connect(sockfd, ipaddr->get_sockaddr(), ipaddr->get_sockaddr_len()) < 0) {
274 free_addresses(addr_list);
275 errno = save_errno | b_errno_win32;
279 * Keep socket from timing out from inactivity
280 * Do this a second time out of paranoia
282 if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
284 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
287 fin_init(jcr, sockfd, name, host, port, ipaddr->get_sockaddr());
288 free_addresses(addr_list);
293 * Force read/write to use locking
295 bool BSOCK::set_locking()
299 return true; /* already set */
301 if ((stat = pthread_mutex_init(&m_mutex, NULL)) != 0) {
303 Qmsg(m_jcr, M_FATAL, 0, _("Could not init bsock mutex. ERR=%s\n"),
307 m_use_locking = true;
311 void BSOCK::clear_locking()
313 if (!m_use_locking) {
316 m_use_locking = false;
317 pthread_mutex_destroy(&m_mutex);
322 * Send a message over the network. The send consists of
323 * two network packets. The first is sends a 32 bit integer containing
324 * the length of the data packet which follows.
326 * Returns: false on failure
337 if (!m_suppress_error_msgs) {
338 Qmsg4(m_jcr, M_ERROR, 0, _("Socket has errors=%d on call to %s:%s:%d\n"),
339 errors, m_who, m_host, m_port);
343 if (is_terminated()) {
344 if (!m_suppress_error_msgs) {
345 Qmsg4(m_jcr, M_ERROR, 0, _("Socket is terminated=%d on call to %s:%s:%d\n"),
346 is_terminated(), m_who, m_host, m_port);
350 if (msglen > 4000000) {
351 if (!m_suppress_error_msgs) {
352 Qmsg4(m_jcr, M_ERROR, 0,
353 _("Socket has insane msglen=%d on call to %s:%s:%d\n"),
354 msglen, m_who, m_host, m_port);
359 if (m_use_locking) P(m_mutex);
360 /* Compute total packet length */
362 pktsiz = sizeof(pktsiz); /* signal, no data */
364 pktsiz = msglen + sizeof(pktsiz); /* data */
366 /* Store packet length at head of message -- note, we
367 * have reserved an int32_t just before msg, so we can
370 hdr = (int32_t *)(msg - (int)sizeof(pktsiz));
371 *hdr = htonl(msglen); /* store signal/length */
373 out_msg_no++; /* increment message number */
375 /* send data packet */
376 timer_start = watchdog_time; /* start timer */
378 /* Full I/O done in one write */
379 rc = write_nbytes(this, (char *)hdr, pktsiz);
380 timer_start = 0; /* clear timer */
389 if (!m_suppress_error_msgs) {
390 Qmsg5(m_jcr, M_ERROR, 0,
391 _("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"),
393 m_host, m_port, this->bstrerror());
396 Qmsg5(m_jcr, M_ERROR, 0,
397 _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
398 msglen, m_who, m_host, m_port, rc);
402 if (m_use_locking) V(m_mutex);
407 * Format and send a message
408 * Returns: false on error
411 bool BSOCK::fsend(const char *fmt, ...)
416 if (errors || is_terminated()) {
419 /* This probably won't work, but we vsnprintf, then if we
420 * get a negative length or a length greater than our buffer
421 * (depending on which library is used), the printf was truncated, so
422 * get a bigger buffer and try again.
425 maxlen = sizeof_pool_memory(msg) - 1;
426 va_start(arg_ptr, fmt);
427 msglen = bvsnprintf(msg, maxlen, fmt, arg_ptr);
429 if (msglen > 0 && msglen < (maxlen - 5)) {
432 msg = realloc_pool_memory(msg, maxlen + maxlen / 2);
438 * Receive a message from the other end. Each message consists of
439 * two packets. The first is a header that contains the size
440 * of the data that follows in the second packet.
441 * Returns number of bytes read (may return zero)
442 * Returns -1 on signal (BNET_SIGNAL)
443 * Returns -2 on hard end of file (BNET_HARDEOF)
444 * Returns -3 on error (BNET_ERROR)
446 * Unfortunately, it is a bit complicated because we have these
449 * 2. Signal including end of data stream
450 * 3. Hard end of file
452 * Using is_bnet_stop() and is_bnet_error() you can figure this all out.
454 int32_t BSOCK::recv()
461 if (errors || is_terminated()) {
465 if (m_use_locking) P(m_mutex);
466 read_seqno++; /* bump sequence number */
467 timer_start = watchdog_time; /* set start wait time */
469 /* get data size -- in int32_t */
470 if ((nbytes = read_nbytes(this, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
471 timer_start = 0; /* clear timer */
472 /* probably pipe broken because client died */
479 nbytes = BNET_HARDEOF; /* assume hard EOF received */
482 timer_start = 0; /* clear timer */
483 if (nbytes != sizeof(int32_t)) {
486 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
487 sizeof(int32_t), nbytes, m_who, m_host, m_port);
492 pktsiz = ntohl(pktsiz); /* decode no. of bytes that follow */
494 if (pktsiz == 0) { /* No data transferred */
495 timer_start = 0; /* clear timer */
498 nbytes = 0; /* zero bytes read */
502 /* If signal or packet size too big */
503 if (pktsiz < 0 || pktsiz > 1000000) {
504 if (pktsiz > 0) { /* if packet too big */
505 Qmsg3(m_jcr, M_FATAL, 0,
506 _("Packet size too big from \"%s:%s:%d. Terminating connection.\n"),
507 m_who, m_host, m_port);
508 pktsiz = BNET_TERMINATE; /* hang up */
510 if (pktsiz == BNET_TERMINATE) {
513 timer_start = 0; /* clear timer */
515 msglen = pktsiz; /* signal code */
516 nbytes = BNET_SIGNAL; /* signal */
520 /* Make sure the buffer is big enough + one byte for EOS */
521 if (pktsiz >= (int32_t) sizeof_pool_memory(msg)) {
522 msg = realloc_pool_memory(msg, pktsiz + 100);
525 timer_start = watchdog_time; /* set start wait time */
527 /* now read the actual data */
528 if ((nbytes = read_nbytes(this, msg, pktsiz)) <= 0) {
529 timer_start = 0; /* clear timer */
536 Qmsg4(m_jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"),
537 m_who, m_host, m_port, this->bstrerror());
541 timer_start = 0; /* clear timer */
544 if (nbytes != pktsiz) {
547 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
548 pktsiz, nbytes, m_who, m_host, m_port);
552 /* always add a zero by to properly terminate any
553 * string that was send to us. Note, we ensured above that the
554 * buffer is at least one byte longer than the message length.
556 msg[nbytes] = 0; /* terminate in case it is a string */
558 * The following uses *lots* of resources so turn it on only for
564 if (m_use_locking) V(m_mutex);
565 return nbytes; /* return actual length of message */
572 bool BSOCK::signal(int signal)
575 if (signal == BNET_TERMINATE) {
576 m_suppress_error_msgs = true;
582 * Despool spooled attributes
584 bool BSOCK::despool(void update_attr_spool_size(ssize_t size), ssize_t tsize)
588 ssize_t last = 0, size = 0;
590 JCR *jcr = get_jcr();
594 #if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
595 posix_fadvise(fileno(m_spool_fd), 0, 0, POSIX_FADV_WILLNEED);
598 while (fread((char *)&pktsiz, 1, sizeof(int32_t), m_spool_fd) ==
600 size += sizeof(int32_t);
601 msglen = ntohl(pktsiz);
603 if (msglen > (int32_t)sizeof_pool_memory(msg)) {
604 msg = realloc_pool_memory(msg, msglen + 1);
606 nbytes = fread(msg, 1, msglen, m_spool_fd);
607 if (nbytes != (size_t)msglen) {
609 Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
610 Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
612 update_attr_spool_size(tsize - last);
616 if ((++count & 0x3F) == 0) {
617 update_attr_spool_size(size - last);
622 if (jcr && job_canceled(jcr)) {
626 update_attr_spool_size(tsize - last);
627 if (ferror(m_spool_fd)) {
628 Qmsg(jcr, M_FATAL, 0, _("fread attr spool I/O error.\n"));
635 * Return the string for the error that occurred
636 * on the socket. Only the first error is retained.
638 const char *BSOCK::bstrerror()
641 if (errmsg == NULL) {
642 errmsg = get_pool_memory(PM_MESSAGE);
644 pm_strcpy(errmsg, be.bstrerror(b_errno));
648 int BSOCK::get_peer(char *buf, socklen_t buflen)
650 #if !defined(HAVE_WIN32)
651 if (peer_addr.sin_family == 0) {
652 socklen_t salen = sizeof(peer_addr);
653 int rval = (getpeername)(m_fd, (struct sockaddr *)&peer_addr, &salen);
654 if (rval < 0) return rval;
656 if (!inet_ntop(peer_addr.sin_family, &peer_addr.sin_addr, buf, buflen))
666 * Set the network buffer size, suggested size is in size.
667 * Actual size obtained is returned in bs->msglen
669 * Returns: false on failure
672 bool BSOCK::set_buffer_size(uint32_t size, int rw)
674 uint32_t dbuf_size, start_size;
676 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
678 opt = IPTOS_THROUGHPUT;
679 setsockopt(fd, IPPROTO_IP, IP_TOS, (sockopt_val_t)&opt, sizeof(opt));
685 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
687 start_size = dbuf_size;
688 if ((msg = realloc_pool_memory(msg, dbuf_size + 100)) == NULL) {
689 Qmsg0(get_jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
694 * If user has not set the size, use the OS default -- i.e. do not
695 * try to set it. This allows sys admins to set the size they
696 * want in the OS, and Bacula will comply. See bug #1493
703 if (rw & BNET_SETBUF_READ) {
704 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
705 SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
707 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
708 dbuf_size -= TAPE_BSIZE;
710 Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
711 if (dbuf_size != start_size) {
712 Qmsg1(get_jcr(), M_WARNING, 0,
713 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
715 if (dbuf_size % TAPE_BSIZE != 0) {
716 Qmsg1(get_jcr(), M_ABORT, 0,
717 _("Network buffer size %d not multiple of tape block size.\n"),
724 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
726 start_size = dbuf_size;
727 if (rw & BNET_SETBUF_WRITE) {
728 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
729 SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
731 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
732 dbuf_size -= TAPE_BSIZE;
734 Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
735 if (dbuf_size != start_size) {
736 Qmsg1(get_jcr(), M_WARNING, 0,
737 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
739 if (dbuf_size % TAPE_BSIZE != 0) {
740 Qmsg1(get_jcr(), M_ABORT, 0,
741 _("Network buffer size %d not multiple of tape block size.\n"),
751 * Set socket non-blocking
752 * Returns previous socket flag
754 int BSOCK::set_nonblocking()
759 /* Get current flags */
760 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
762 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
765 /* Set O_NONBLOCK flag */
766 if ((fcntl(m_fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
768 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
778 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
786 * Set socket blocking
787 * Returns previous socket flags
789 int BSOCK::set_blocking()
793 /* Get current flags */
794 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
796 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
799 /* Set O_NONBLOCK flag */
800 if ((fcntl(m_fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
802 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
812 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
820 * Restores socket flags
822 void BSOCK::restore_blocking (int flags)
825 if ((fcntl(m_fd, F_SETFL, flags)) < 0) {
827 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
830 m_blocking = (flags & O_NONBLOCK) ? true : false;
832 u_long ioctlArg = flags;
834 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
840 * Wait for a specified time for data to appear on
841 * the BSOCK connection.
843 * Returns: 1 if data available
847 int BSOCK::wait_data(int sec, int usec)
853 FD_SET((unsigned)m_fd, &fdset);
857 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
858 case 0: /* timeout */
863 if (errno == EINTR) {
866 return -1; /* error return */
875 * As above, but returns on interrupt
877 int BSOCK::wait_data_intr(int sec, int usec)
886 FD_SET((unsigned)m_fd, &fdset);
889 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
890 case 0: /* timeout */
895 return -1; /* error return */
904 * Note, this routine closes and destroys all the sockets
905 * that are open including the duped ones.
919 for (; bsock; bsock = next) {
920 next = bsock->m_next; /* get possible pointer to next before destoryed */
921 if (!bsock->m_duped) {
922 /* Shutdown tls cleanly. */
924 tls_bsock_shutdown(bsock);
925 free_tls_connection(bsock->tls);
928 if (bsock->is_timed_out()) {
929 shutdown(bsock->m_fd, SHUT_RDWR); /* discard any pending I/O */
931 socketClose(bsock->m_fd); /* normal close */
938 void BSOCK::destroy()
941 free_pool_memory(msg);
944 ASSERT(1 == 0); /* double close */
947 free_pool_memory(errmsg);
965 /* Commands sent to Director */
966 static char hello[] = "Hello %s calling\n";
968 /* Response from Director */
969 static char OKhello[] = "1000 OK:";
972 * Authenticate Director
974 bool BSOCK::authenticate_director(const char *name, const char *password,
975 TLS_CONTEXT *tls_ctx, char *msg, int msglen)
977 int tls_local_need = BNET_TLS_NONE;
978 int tls_remote_need = BNET_TLS_NONE;
979 int compatible = true;
980 char bashed_name[MAX_NAME_LENGTH];
981 BSOCK *dir = this; /* for readability */
985 * Send my name to the Director then do authentication
988 /* Timeout Hello after 15 secs */
989 dir->start_timer(15);
990 dir->fsend(hello, bashed_name);
992 if (get_tls_enable(tls_ctx)) {
993 tls_local_need = get_tls_enable(tls_ctx) ? BNET_TLS_REQUIRED : BNET_TLS_OK;
996 /* respond to Dir challenge */
997 if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
998 /* Now challenge dir */
999 !cram_md5_challenge(dir, password, tls_local_need, compatible)) {
1000 bsnprintf(msg, msglen, _("Director authorization problem at \"%s:%d\"\n"),
1001 dir->host(), dir->port());
1005 /* Verify that the remote host is willing to meet our TLS requirements */
1006 if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
1007 bsnprintf(msg, msglen, _("Authorization problem:"
1008 " Remote server at \"%s:%d\" did not advertise required TLS support.\n"),
1009 dir->host(), dir->port());
1013 /* Verify that we are willing to meet the remote host's requirements */
1014 if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
1015 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\":"
1016 " Remote server requires TLS.\n"),
1017 dir->host(), dir->port());
1022 /* Is TLS Enabled? */
1024 if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
1025 /* Engage TLS! Full Speed Ahead! */
1026 if (!bnet_tls_client(tls_ctx, dir, NULL)) {
1027 bsnprintf(msg, msglen, _("TLS negotiation failed with Director at \"%s:%d\"\n"),
1028 dir->host(), dir->port());
1034 Dmsg1(6, ">dird: %s", dir->msg);
1035 if (dir->recv() <= 0) {
1037 bsnprintf(msg, msglen, _("Bad response to Hello command: ERR=%s\n"
1038 "The Director at \"%s:%d\" is probably not running.\n"),
1039 dir->bstrerror(), dir->host(), dir->port());
1044 Dmsg1(10, "<dird: %s", dir->msg);
1045 if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
1046 bsnprintf(msg, msglen, _("Director at \"%s:%d\" rejected Hello command\n"),
1047 dir->host(), dir->port());
1050 bsnprintf(msg, msglen, "%s", dir->msg);
1056 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\"\n"
1057 "Most likely the passwords do not agree.\n"
1058 "If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
1059 "Please see http://www.bacula.org/en/rel-manual/Bacula_Freque_Asked_Questi.html#SECTION003760000000000000000 for help.\n"),
1060 dir->host(), dir->port());
1064 /* Try to limit the bandwidth of a network connection
1066 void BSOCK::control_bwlimit(int bytes)
1073 now = get_current_btime(); /* microseconds */
1074 temp = now - m_last_tick; /* microseconds */
1076 m_nb_bytes += bytes;
1078 /* Less than 0.1ms since the last call, see the next time */
1083 if (temp > 10000000) { /* Take care of clock problems (>10s) */
1089 /* Remove what was authorised to be written in temp us */
1090 m_nb_bytes -= (int64_t)(temp * ((double)m_bwlimit / 1000000.0));
1092 if (m_nb_bytes < 0) {
1096 /* What exceed should be converted in sleep time */
1097 int64_t usec_sleep = (int64_t)(m_nb_bytes /((double)m_bwlimit / 1000000.0));
1098 if (usec_sleep > 100) {
1099 bmicrosleep(0, usec_sleep);
1100 m_last_tick = get_current_btime();