2 Bacula® - The Network Backup Solution
4 Copyright (C) 2007-2008 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 two of the GNU 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 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
41 #ifndef ENODATA /* not defined on BSD systems */
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)
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)
56 * This is a non-class BSOCK "constructor" because we want to
57 * call the Bacula smartalloc routines instead of new.
61 BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
68 memset(this, 0, sizeof(BSOCK));
70 msg = get_pool_memory(PM_MESSAGE);
71 errmsg = get_pool_memory(PM_MESSAGE);
73 * ****FIXME**** reduce this to a few hours once
74 * heartbeats are implemented
76 timeout = 60 * 60 * 6 * 24; /* 6 days timeout */
80 * This is our "class destructor" that ensures that we use
81 * smartalloc rather than the system free().
83 void BSOCK::free_bsock()
88 void BSOCK::free_tls()
90 free_tls_connection(this->tls);
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
99 bool BSOCK::connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
101 const char *name, char *host, char *service, int port,
107 time_t begin_time = time(NULL);
109 btimer_t *tid = NULL;
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);
116 for (i = 0; !open(jcr, name, host, service, port, heart_beat, &fatal);
117 i -= retry_interval) {
119 if (fatal || (jcr && job_canceled(jcr))) {
122 Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
123 name, host, port, be.bstrerror());
125 i = 60 * 5; /* complain again in 5 minutes */
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());
131 bmicrosleep(retry_interval, 0);
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());
143 stop_thread_timer(tid);
150 * Finish initialization of the pocket structure.
152 void BSOCK::fin_init(JCR * jcr, int sockfd, const char *who, const char *host, int port,
153 struct sockaddr *lclient_addr)
155 Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
157 set_who(bstrdup(who));
158 set_host(bstrdup(host));
160 memcpy(&client_addr, lclient_addr, sizeof(client_addr));
165 * Copy the address from the configuration dlist that gets passed in
167 void BSOCK::set_source_address(dlist *src_addr_list)
171 // delete the object we already have, if it's allocated
178 addr = (IPADDR*) src_addr_list->first();
179 src_addr = New( IPADDR(*addr));
185 * Open a TCP connection to the server
187 * Returns BSOCK * pointer on success
190 bool BSOCK::open(JCR *jcr, const char *name, char *host, char *service,
191 int port, utime_t heart_beat, int *fatal)
196 bool connected = false;
202 * Fill in the structure serv_addr with the address of
203 * the server that we want to connect with.
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"),
209 Dmsg2(100, "bnet_host2ipaddrs() for host %s failed: ERR=%s\n",
215 foreach_dlist(ipaddr, addr_list) {
216 ipaddr->set_port_net(htons(port));
217 char allbuf[256 * 10];
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) {
227 Pmsg3(000, _("Socket open error. proto=%d port=%d. ERR=%s\n"),
228 ipaddr->get_family(), ipaddr->get_port_host_order(), be.bstrerror());
232 /* Bind to the source address if it is set */
234 if (bind(sockfd, src_addr->get_sockaddr(), src_addr->get_sockaddr_len()) < 0) {
238 Pmsg2(000, _("Source address bind error. proto=%d. ERR=%s\n"),
239 src_addr->get_family(), be.bstrerror() );
245 * Keep socket from timing out from inactivity
247 if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
249 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
252 #if defined(TCP_KEEPIDLE)
255 if (setsockopt(sockfd, IPPROTO_IP, TCP_KEEPIDLE, (sockopt_val_t)&opt, sizeof(opt)) < 0) {
257 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPIDLE on socket: %s\n"),
263 /* connect to server */
264 if (::connect(sockfd, ipaddr->get_sockaddr(), ipaddr->get_sockaddr_len()) < 0) {
275 free_addresses(addr_list);
276 errno = save_errno | b_errno_win32;
280 * Keep socket from timing out from inactivity
281 * Do this a second time out of paranoia
283 if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
285 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
288 fin_init(jcr, sockfd, name, host, port, ipaddr->get_sockaddr());
289 free_addresses(addr_list);
294 * Force read/write to use locking
296 bool BSOCK::set_locking()
300 return true; /* already set */
302 if ((stat = pthread_mutex_init(&m_mutex, NULL)) != 0) {
304 Qmsg(m_jcr, M_FATAL, 0, _("Could not init bsock mutex. ERR=%s\n"),
308 m_use_locking = true;
312 void BSOCK::clear_locking()
314 if (!m_use_locking) {
317 m_use_locking = false;
318 pthread_mutex_destroy(&m_mutex);
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.
327 * Returns: false on failure
337 if (errors || is_terminated() || msglen > 1000000) {
338 if (!m_suppress_error_msgs) {
339 Qmsg6(m_jcr, M_ERROR, 0,
340 _("Socket has errors=%d; is_terminated=%d; or has insane msglen=%d on call to %s:%s:%d\n"),
341 errors, is_terminated(), msglen, m_who,
346 if (m_use_locking) P(m_mutex);
347 /* Compute total packet length */
349 pktsiz = sizeof(pktsiz); /* signal, no data */
351 pktsiz = msglen + sizeof(pktsiz); /* data */
353 /* Store packet length at head of message -- note, we
354 * have reserved an int32_t just before msg, so we can
357 hdr = (int32_t *)(msg - (int)sizeof(pktsiz));
358 *hdr = htonl(msglen); /* store signal/length */
360 out_msg_no++; /* increment message number */
362 /* send data packet */
363 timer_start = watchdog_time; /* start timer */
365 /* Full I/O done in one write */
366 rc = write_nbytes(this, (char *)hdr, pktsiz);
367 timer_start = 0; /* clear timer */
376 if (!m_suppress_error_msgs) {
377 Qmsg5(m_jcr, M_ERROR, 0,
378 _("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"),
380 m_host, m_port, this->bstrerror());
383 Qmsg5(m_jcr, M_ERROR, 0,
384 _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
385 msglen, m_who, m_host, m_port, rc);
389 if (m_use_locking) V(m_mutex);
394 * Format and send a message
395 * Returns: false on error
398 bool BSOCK::fsend(const char *fmt, ...)
403 if (errors || is_terminated()) {
406 /* This probably won't work, but we vsnprintf, then if we
407 * get a negative length or a length greater than our buffer
408 * (depending on which library is used), the printf was truncated, so
409 * get a bigger buffer and try again.
412 maxlen = sizeof_pool_memory(msg) - 1;
413 va_start(arg_ptr, fmt);
414 msglen = bvsnprintf(msg, maxlen, fmt, arg_ptr);
416 if (msglen > 0 && msglen < (maxlen - 5)) {
419 msg = realloc_pool_memory(msg, maxlen + maxlen / 2);
425 * Receive a message from the other end. Each message consists of
426 * two packets. The first is a header that contains the size
427 * of the data that follows in the second packet.
428 * Returns number of bytes read (may return zero)
429 * Returns -1 on signal (BNET_SIGNAL)
430 * Returns -2 on hard end of file (BNET_HARDEOF)
431 * Returns -3 on error (BNET_ERROR)
433 * Unfortunately, it is a bit complicated because we have these
436 * 2. Signal including end of data stream
437 * 3. Hard end of file
439 * Using is_bnet_stop() and is_bnet_error() you can figure this all out.
441 int32_t BSOCK::recv()
448 if (errors || is_terminated()) {
452 if (m_use_locking) P(m_mutex);
453 read_seqno++; /* bump sequence number */
454 timer_start = watchdog_time; /* set start wait time */
456 /* get data size -- in int32_t */
457 if ((nbytes = read_nbytes(this, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
458 timer_start = 0; /* clear timer */
459 /* probably pipe broken because client died */
466 nbytes = BNET_HARDEOF; /* assume hard EOF received */
469 timer_start = 0; /* clear timer */
470 if (nbytes != sizeof(int32_t)) {
473 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
474 sizeof(int32_t), nbytes, m_who, m_host, m_port);
479 pktsiz = ntohl(pktsiz); /* decode no. of bytes that follow */
481 if (pktsiz == 0) { /* No data transferred */
482 timer_start = 0; /* clear timer */
485 nbytes = 0; /* zero bytes read */
489 /* If signal or packet size too big */
490 if (pktsiz < 0 || pktsiz > 1000000) {
491 if (pktsiz > 0) { /* if packet too big */
492 Qmsg3(m_jcr, M_FATAL, 0,
493 _("Packet size too big from \"%s:%s:%d. Terminating connection.\n"),
494 m_who, m_host, m_port);
495 pktsiz = BNET_TERMINATE; /* hang up */
497 if (pktsiz == BNET_TERMINATE) {
500 timer_start = 0; /* clear timer */
502 msglen = pktsiz; /* signal code */
503 nbytes = BNET_SIGNAL; /* signal */
507 /* Make sure the buffer is big enough + one byte for EOS */
508 if (pktsiz >= (int32_t) sizeof_pool_memory(msg)) {
509 msg = realloc_pool_memory(msg, pktsiz + 100);
512 timer_start = watchdog_time; /* set start wait time */
514 /* now read the actual data */
515 if ((nbytes = read_nbytes(this, msg, pktsiz)) <= 0) {
516 timer_start = 0; /* clear timer */
523 Qmsg4(m_jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"),
524 m_who, m_host, m_port, this->bstrerror());
528 timer_start = 0; /* clear timer */
531 if (nbytes != pktsiz) {
534 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
535 pktsiz, nbytes, m_who, m_host, m_port);
539 /* always add a zero by to properly terminate any
540 * string that was send to us. Note, we ensured above that the
541 * buffer is at least one byte longer than the message length.
543 msg[nbytes] = 0; /* terminate in case it is a string */
544 sm_check(__FILE__, __LINE__, false);
547 if (m_use_locking) V(m_mutex);
548 return nbytes; /* return actual length of message */
555 bool BSOCK::signal(int signal)
558 if (signal == BNET_TERMINATE) {
559 m_suppress_error_msgs = true;
565 * Despool spooled attributes
567 bool BSOCK::despool(void update_attr_spool_size(ssize_t size), ssize_t tsize)
571 ssize_t last = 0, size = 0;
573 JCR *jcr = get_jcr();
577 #if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
578 posix_fadvise(fileno(m_spool_fd), 0, 0, POSIX_FADV_WILLNEED);
581 while (fread((char *)&pktsiz, 1, sizeof(int32_t), m_spool_fd) ==
583 size += sizeof(int32_t);
584 msglen = ntohl(pktsiz);
586 if (msglen > (int32_t)sizeof_pool_memory(msg)) {
587 msg = realloc_pool_memory(msg, msglen + 1);
589 nbytes = fread(msg, 1, msglen, m_spool_fd);
590 if (nbytes != (size_t)msglen) {
592 Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
593 Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
595 update_attr_spool_size(tsize - last);
599 if ((++count & 0x3F) == 0) {
600 update_attr_spool_size(size - last);
605 if (jcr && job_canceled(jcr)) {
609 update_attr_spool_size(tsize - last);
610 if (ferror(m_spool_fd)) {
611 Qmsg(jcr, M_FATAL, 0, _("fread attr spool I/O error.\n"));
618 * Return the string for the error that occurred
619 * on the socket. Only the first error is retained.
621 const char *BSOCK::bstrerror()
624 if (errmsg == NULL) {
625 errmsg = get_pool_memory(PM_MESSAGE);
627 pm_strcpy(errmsg, be.bstrerror(b_errno));
631 int BSOCK::get_peer(char *buf, socklen_t buflen)
633 #if !defined(HAVE_WIN32)
634 if (peer_addr.sin_family == 0) {
635 socklen_t salen = sizeof(peer_addr);
636 int rval = (getpeername)(m_fd, (struct sockaddr *)&peer_addr, &salen);
637 if (rval < 0) return rval;
639 if (!inet_ntop(peer_addr.sin_family, &peer_addr.sin_addr, buf, buflen))
649 * Set the network buffer size, suggested size is in size.
650 * Actual size obtained is returned in bs->msglen
652 * Returns: false on failure
655 bool BSOCK::set_buffer_size(uint32_t size, int rw)
657 uint32_t dbuf_size, start_size;
658 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
660 opt = IPTOS_THROUGHPUT;
661 setsockopt(fd, IPPROTO_IP, IP_TOS, (sockopt_val_t)&opt, sizeof(opt));
667 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
669 start_size = dbuf_size;
670 if ((msg = realloc_pool_memory(msg, dbuf_size + 100)) == NULL) {
671 Qmsg0(get_jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
674 if (rw & BNET_SETBUF_READ) {
675 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
676 SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
678 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
679 dbuf_size -= TAPE_BSIZE;
681 Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
682 if (dbuf_size != start_size) {
683 Qmsg1(get_jcr(), M_WARNING, 0,
684 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
686 if (dbuf_size % TAPE_BSIZE != 0) {
687 Qmsg1(get_jcr(), M_ABORT, 0,
688 _("Network buffer size %d not multiple of tape block size.\n"),
695 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
697 start_size = dbuf_size;
698 if (rw & BNET_SETBUF_WRITE) {
699 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
700 SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
702 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
703 dbuf_size -= TAPE_BSIZE;
705 Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
706 if (dbuf_size != start_size) {
707 Qmsg1(get_jcr(), M_WARNING, 0,
708 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
710 if (dbuf_size % TAPE_BSIZE != 0) {
711 Qmsg1(get_jcr(), M_ABORT, 0,
712 _("Network buffer size %d not multiple of tape block size.\n"),
722 * Set socket non-blocking
723 * Returns previous socket flag
725 int BSOCK::set_nonblocking()
730 /* Get current flags */
731 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
733 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
736 /* Set O_NONBLOCK flag */
737 if ((fcntl(m_fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
739 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
749 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
757 * Set socket blocking
758 * Returns previous socket flags
760 int BSOCK::set_blocking()
764 /* Get current flags */
765 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
767 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
770 /* Set O_NONBLOCK flag */
771 if ((fcntl(m_fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
773 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
783 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
791 * Restores socket flags
793 void BSOCK::restore_blocking (int flags)
796 if ((fcntl(m_fd, F_SETFL, flags)) < 0) {
798 Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
801 m_blocking = (flags & O_NONBLOCK) ? true : false;
803 u_long ioctlArg = flags;
805 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
811 * Wait for a specified time for data to appear on
812 * the BSOCK connection.
814 * Returns: 1 if data available
818 int BSOCK::wait_data(int sec, int usec)
824 FD_SET((unsigned)m_fd, &fdset);
828 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
829 case 0: /* timeout */
834 if (errno == EINTR) {
837 return -1; /* error return */
846 * As above, but returns on interrupt
848 int BSOCK::wait_data_intr(int sec, int usec)
857 FD_SET((unsigned)m_fd, &fdset);
860 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
861 case 0: /* timeout */
866 return -1; /* error return */
875 * Note, this routine closes and destroys all the sockets
876 * that are open including the duped ones.
890 for (; bsock; bsock = next) {
891 next = bsock->m_next; /* get possible pointer to next before destoryed */
892 if (!bsock->m_duped) {
893 /* Shutdown tls cleanly. */
895 tls_bsock_shutdown(bsock);
896 free_tls_connection(bsock->tls);
899 if (bsock->is_timed_out()) {
900 shutdown(bsock->m_fd, SHUT_RDWR); /* discard any pending I/O */
902 socketClose(bsock->m_fd); /* normal close */
909 void BSOCK::destroy()
912 free_pool_memory(msg);
915 ASSERT(1 == 0); /* double close */
918 free_pool_memory(errmsg);
936 /* Commands sent to Director */
937 static char hello[] = "Hello %s calling\n";
939 /* Response from Director */
940 static char OKhello[] = "1000 OK:";
943 * Authenticate Director
945 bool BSOCK::authenticate_director(const char *name, const char *password,
946 TLS_CONTEXT *tls_ctx, char *msg, int msglen)
948 int tls_local_need = BNET_TLS_NONE;
949 int tls_remote_need = BNET_TLS_NONE;
950 int compatible = true;
951 char bashed_name[MAX_NAME_LENGTH];
952 BSOCK *dir = this; /* for readability */
956 * Send my name to the Director then do authentication
959 /* Timeout Hello after 15 secs */
960 dir->start_timer(15);
961 dir->fsend(hello, bashed_name);
963 if (get_tls_enable(tls_ctx)) {
964 tls_local_need = get_tls_enable(tls_ctx) ? BNET_TLS_REQUIRED : BNET_TLS_OK;
967 /* respond to Dir challenge */
968 if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
969 /* Now challenge dir */
970 !cram_md5_challenge(dir, password, tls_local_need, compatible)) {
971 bsnprintf(msg, msglen, _("Director authorization problem at \"%s:%d\"\n"),
972 dir->host(), dir->port());
976 /* Verify that the remote host is willing to meet our TLS 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:"
979 " Remote server at \"%s:%d\" did not advertise required TLS support.\n"),
980 dir->host(), dir->port());
984 /* Verify that we are willing to meet the remote host's requirements */
985 if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
986 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\":"
987 " Remote server requires TLS.\n"),
988 dir->host(), dir->port());
993 /* Is TLS Enabled? */
995 if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
996 /* Engage TLS! Full Speed Ahead! */
997 if (!bnet_tls_client(tls_ctx, dir, NULL)) {
998 bsnprintf(msg, msglen, _("TLS negotiation failed with Director at \"%s:%d\"\n"),
999 dir->host(), dir->port());
1005 Dmsg1(6, ">dird: %s", dir->msg);
1006 if (dir->recv() <= 0) {
1008 bsnprintf(msg, msglen, _("Bad response to Hello command: ERR=%s\n"
1009 "The Director at \"%s:%d\" is probably not running.\n"),
1010 dir->bstrerror(), dir->host(), dir->port());
1015 Dmsg1(10, "<dird: %s", dir->msg);
1016 if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
1017 bsnprintf(msg, msglen, _("Director at \"%s:%d\" rejected Hello command\n"),
1018 dir->host(), dir->port());
1021 bsnprintf(msg, msglen, "%s", dir->msg);
1027 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\"\n"
1028 "Most likely the passwords do not agree.\n"
1029 "If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
1030 "Please see http://www.bacula.org/en/rel-manual/Bacula_Freque_Asked_Questi.html#SECTION003760000000000000000 for help.\n"),
1031 dir->host(), dir->port());