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 John Walker.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
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 * Open a TCP connection to the server
167 * Returns BSOCK * pointer on success
170 bool BSOCK::open(JCR *jcr, const char *name, char *host, char *service,
171 int port, utime_t heart_beat, int *fatal)
176 bool connected = false;
182 * Fill in the structure serv_addr with the address of
183 * the server that we want to connect with.
185 if ((addr_list = bnet_host2ipaddrs(host, 0, &errstr)) == NULL) {
186 /* Note errstr is not malloc'ed */
187 Qmsg2(jcr, M_ERROR, 0, _("gethostbyname() for host \"%s\" failed: ERR=%s\n"),
189 Dmsg2(100, "bnet_host2ipaddrs() for host %s failed: ERR=%s\n",
195 foreach_dlist(ipaddr, addr_list) {
196 ipaddr->set_port_net(htons(port));
197 char allbuf[256 * 10];
199 Dmsg2(100, "Current %sAll %s\n",
200 ipaddr->build_address_str(curbuf, sizeof(curbuf)),
201 build_addresses_str(addr_list, allbuf, sizeof(allbuf)));
202 /* Open a TCP socket */
203 if ((sockfd = socket(ipaddr->get_family(), SOCK_STREAM, 0)) < 0) {
207 Pmsg3(000, _("Socket open error. proto=%d port=%d. ERR=%s\n"),
208 ipaddr->get_family(), ipaddr->get_port_host_order(), be.bstrerror());
212 * Keep socket from timing out from inactivity
214 if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
216 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
219 #if defined(TCP_KEEPIDLE)
222 if (setsockopt(sockfd, IPPROTO_IP, TCP_KEEPIDLE, (sockopt_val_t)&opt, sizeof(opt)) < 0) {
224 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPIDLE on socket: %s\n"),
230 /* connect to server */
231 if (::connect(sockfd, ipaddr->get_sockaddr(), ipaddr->get_sockaddr_len()) < 0) {
242 free_addresses(addr_list);
243 errno = save_errno | b_errno_win32;
247 * Keep socket from timing out from inactivity
248 * Do this a second time out of paranoia
250 if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
252 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
255 fin_init(jcr, sockfd, name, host, port, ipaddr->get_sockaddr());
256 free_addresses(addr_list);
261 * Force read/write to use locking
263 bool BSOCK::set_locking()
267 return true; /* already set */
269 if ((stat = pthread_mutex_init(&m_mutex, NULL)) != 0) {
271 Jmsg(m_jcr, M_FATAL, 0, _("Could not init bsock mutex. ERR=%s\n"),
275 m_use_locking = true;
279 void BSOCK::clear_locking()
281 if (!m_use_locking) {
284 m_use_locking = false;
285 pthread_mutex_destroy(&m_mutex);
290 * Send a message over the network. The send consists of
291 * two network packets. The first is sends a 32 bit integer containing
292 * the length of the data packet which follows.
294 * Returns: false on failure
304 if (errors || is_terminated() || msglen > 1000000) {
307 if (m_use_locking) P(m_mutex);
308 /* Compute total packet length */
310 pktsiz = sizeof(pktsiz); /* signal, no data */
312 pktsiz = msglen + sizeof(pktsiz); /* data */
314 /* Store packet length at head of message -- note, we
315 * have reserved an int32_t just before msg, so we can
318 hdr = (int32_t *)(msg - (int)sizeof(pktsiz));
319 *hdr = htonl(msglen); /* store signal/length */
321 out_msg_no++; /* increment message number */
323 /* send data packet */
324 timer_start = watchdog_time; /* start timer */
326 /* Full I/O done in one write */
327 rc = write_nbytes(this, (char *)hdr, pktsiz);
328 timer_start = 0; /* clear timer */
337 if (!m_suppress_error_msgs) {
338 Qmsg5(m_jcr, M_ERROR, 0,
339 _("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"),
341 m_host, m_port, this->bstrerror());
344 Qmsg5(m_jcr, M_ERROR, 0,
345 _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
346 msglen, m_who, m_host, m_port, rc);
350 if (m_use_locking) V(m_mutex);
355 * Format and send a message
356 * Returns: false on error
359 bool BSOCK::fsend(const char *fmt, ...)
364 if (errors || is_terminated()) {
367 /* This probably won't work, but we vsnprintf, then if we
368 * get a negative length or a length greater than our buffer
369 * (depending on which library is used), the printf was truncated, so
370 * get a bigger buffer and try again.
373 maxlen = sizeof_pool_memory(msg) - 1;
374 va_start(arg_ptr, fmt);
375 msglen = bvsnprintf(msg, maxlen, fmt, arg_ptr);
377 if (msglen > 0 && msglen < (maxlen - 5)) {
380 msg = realloc_pool_memory(msg, maxlen + maxlen / 2);
386 * Receive a message from the other end. Each message consists of
387 * two packets. The first is a header that contains the size
388 * of the data that follows in the second packet.
389 * Returns number of bytes read (may return zero)
390 * Returns -1 on signal (BNET_SIGNAL)
391 * Returns -2 on hard end of file (BNET_HARDEOF)
392 * Returns -3 on error (BNET_ERROR)
394 * Unfortunately, it is a bit complicated because we have these
397 * 2. Signal including end of data stream
398 * 3. Hard end of file
400 * Using is_bnet_stop() and is_bnet_error() you can figure this all out.
402 int32_t BSOCK::recv()
409 if (errors || is_terminated()) {
413 if (m_use_locking) P(m_mutex);
414 read_seqno++; /* bump sequence number */
415 timer_start = watchdog_time; /* set start wait time */
417 /* get data size -- in int32_t */
418 if ((nbytes = read_nbytes(this, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
419 timer_start = 0; /* clear timer */
420 /* probably pipe broken because client died */
427 nbytes = BNET_HARDEOF; /* assume hard EOF received */
430 timer_start = 0; /* clear timer */
431 if (nbytes != sizeof(int32_t)) {
434 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
435 sizeof(int32_t), nbytes, m_who, m_host, m_port);
440 pktsiz = ntohl(pktsiz); /* decode no. of bytes that follow */
442 if (pktsiz == 0) { /* No data transferred */
443 timer_start = 0; /* clear timer */
446 nbytes = 0; /* zero bytes read */
450 /* If signal or packet size too big */
451 if (pktsiz < 0 || pktsiz > 1000000) {
452 if (pktsiz > 0) { /* if packet too big */
453 Qmsg3(m_jcr, M_FATAL, 0,
454 _("Packet size too big from \"%s:%s:%d. Terminating connection.\n"),
455 m_who, m_host, m_port);
456 pktsiz = BNET_TERMINATE; /* hang up */
458 if (pktsiz == BNET_TERMINATE) {
461 timer_start = 0; /* clear timer */
463 msglen = pktsiz; /* signal code */
464 nbytes = BNET_SIGNAL; /* signal */
468 /* Make sure the buffer is big enough + one byte for EOS */
469 if (pktsiz >= (int32_t) sizeof_pool_memory(msg)) {
470 msg = realloc_pool_memory(msg, pktsiz + 100);
473 timer_start = watchdog_time; /* set start wait time */
475 /* now read the actual data */
476 if ((nbytes = read_nbytes(this, msg, pktsiz)) <= 0) {
477 timer_start = 0; /* clear timer */
484 Qmsg4(m_jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"),
485 m_who, m_host, m_port, this->bstrerror());
489 timer_start = 0; /* clear timer */
492 if (nbytes != pktsiz) {
495 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
496 pktsiz, nbytes, m_who, m_host, m_port);
500 /* always add a zero by to properly terminate any
501 * string that was send to us. Note, we ensured above that the
502 * buffer is at least one byte longer than the message length.
504 msg[nbytes] = 0; /* terminate in case it is a string */
505 sm_check(__FILE__, __LINE__, false);
508 if (m_use_locking) V(m_mutex);
509 return nbytes; /* return actual length of message */
516 bool BSOCK::signal(int signal)
519 if (signal == BNET_TERMINATE) {
520 m_suppress_error_msgs = true;
526 * Despool spooled attributes
528 bool BSOCK::despool(void update_attr_spool_size(ssize_t size), ssize_t tsize)
532 ssize_t last = 0, size = 0;
537 #if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
538 posix_fadvise(fileno(m_spool_fd), 0, 0, POSIX_FADV_WILLNEED);
541 while (fread((char *)&pktsiz, 1, sizeof(int32_t), m_spool_fd) ==
543 size += sizeof(int32_t);
544 msglen = ntohl(pktsiz);
546 if (msglen > (int32_t) sizeof_pool_memory(msg)) {
547 msg = realloc_pool_memory(msg, msglen + 1);
549 nbytes = fread(msg, 1, msglen, m_spool_fd);
550 if (nbytes != (size_t) msglen) {
552 Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
553 Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
555 update_attr_spool_size(tsize - last);
559 if ((++count & 0x3F) == 0) {
560 update_attr_spool_size(size - last);
566 update_attr_spool_size(tsize - last);
567 if (ferror(m_spool_fd)) {
569 Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
577 * Return the string for the error that occurred
578 * on the socket. Only the first error is retained.
580 const char *BSOCK::bstrerror()
583 if (errmsg == NULL) {
584 errmsg = get_pool_memory(PM_MESSAGE);
586 pm_strcpy(errmsg, be.bstrerror(b_errno));
590 int BSOCK::get_peer(char *buf, socklen_t buflen)
592 #if !defined(HAVE_WIN32)
593 if (peer_addr.sin_family == 0) {
594 socklen_t salen = sizeof(peer_addr);
595 int rval = (getpeername)(m_fd, (struct sockaddr *)&peer_addr, &salen);
596 if (rval < 0) return rval;
598 if (!inet_ntop(peer_addr.sin_family, &peer_addr.sin_addr, buf, buflen))
608 * Set the network buffer size, suggested size is in size.
609 * Actual size obtained is returned in bs->msglen
611 * Returns: false on failure
614 bool BSOCK::set_buffer_size(uint32_t size, int rw)
616 uint32_t dbuf_size, start_size;
617 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
619 opt = IPTOS_THROUGHPUT;
620 setsockopt(fd, IPPROTO_IP, IP_TOS, (sockopt_val_t)&opt, sizeof(opt));
626 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
628 start_size = dbuf_size;
629 if ((msg = realloc_pool_memory(msg, dbuf_size + 100)) == NULL) {
630 Qmsg0(get_jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
633 if (rw & BNET_SETBUF_READ) {
634 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
635 SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
637 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
638 dbuf_size -= TAPE_BSIZE;
640 Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
641 if (dbuf_size != start_size) {
642 Qmsg1(get_jcr(), M_WARNING, 0,
643 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
645 if (dbuf_size % TAPE_BSIZE != 0) {
646 Qmsg1(get_jcr(), M_ABORT, 0,
647 _("Network buffer size %d not multiple of tape block size.\n"),
654 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
656 start_size = dbuf_size;
657 if (rw & BNET_SETBUF_WRITE) {
658 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
659 SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
661 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
662 dbuf_size -= TAPE_BSIZE;
664 Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
665 if (dbuf_size != start_size) {
666 Qmsg1(get_jcr(), M_WARNING, 0,
667 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
669 if (dbuf_size % TAPE_BSIZE != 0) {
670 Qmsg1(get_jcr(), M_ABORT, 0,
671 _("Network buffer size %d not multiple of tape block size.\n"),
681 * Set socket non-blocking
682 * Returns previous socket flag
684 int BSOCK::set_nonblocking()
689 /* Get current flags */
690 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
692 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
695 /* Set O_NONBLOCK flag */
696 if ((fcntl(m_fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
698 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
708 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
716 * Set socket blocking
717 * Returns previous socket flags
719 int BSOCK::set_blocking()
723 /* Get current flags */
724 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
726 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
729 /* Set O_NONBLOCK flag */
730 if ((fcntl(m_fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
732 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
742 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
750 * Restores socket flags
752 void BSOCK::restore_blocking (int flags)
755 if ((fcntl(m_fd, F_SETFL, flags)) < 0) {
757 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
760 m_blocking = (flags & O_NONBLOCK) ? true : false;
762 u_long ioctlArg = flags;
764 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
770 * Wait for a specified time for data to appear on
771 * the BSOCK connection.
773 * Returns: 1 if data available
777 int BSOCK::wait_data(int sec)
783 FD_SET((unsigned)m_fd, &fdset);
787 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
788 case 0: /* timeout */
793 if (errno == EINTR) {
796 return -1; /* error return */
805 * As above, but returns on interrupt
807 int BSOCK::wait_data_intr(int sec)
813 FD_SET((unsigned)m_fd, &fdset);
816 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
817 case 0: /* timeout */
822 return -1; /* error return */
831 * Note, this routine closes and destroys all the sockets
832 * that are open including the duped ones.
846 for (; bsock; bsock = next) {
847 next = bsock->m_next; /* get possible pointer to next before destoryed */
848 if (!bsock->m_duped) {
849 /* Shutdown tls cleanly. */
851 tls_bsock_shutdown(bsock);
852 free_tls_connection(bsock->tls);
855 if (bsock->is_timed_out()) {
856 shutdown(bsock->m_fd, SHUT_RDWR); /* discard any pending I/O */
858 socketClose(bsock->m_fd); /* normal close */
865 void BSOCK::destroy()
868 free_pool_memory(msg);
871 ASSERT(1 == 0); /* double close */
874 free_pool_memory(errmsg);
888 /* Commands sent to Director */
889 static char hello[] = "Hello %s calling\n";
891 /* Response from Director */
892 static char OKhello[] = "1000 OK:";
895 * Authenticate Director
897 bool BSOCK::authenticate_director(const char *name, const char *password,
898 TLS_CONTEXT *tls_ctx, char *msg, int msglen)
900 int tls_local_need = BNET_TLS_NONE;
901 int tls_remote_need = BNET_TLS_NONE;
902 int compatible = true;
903 char bashed_name[MAX_NAME_LENGTH];
904 BSOCK *dir = this; /* for readability */
908 * Send my name to the Director then do authentication
911 /* Timeout Hello after 15 secs */
912 dir->start_timer(15);
913 dir->fsend(hello, bashed_name);
915 if (get_tls_enable(tls_ctx)) {
916 tls_local_need = get_tls_enable(tls_ctx) ? BNET_TLS_REQUIRED : BNET_TLS_OK;
919 /* respond to Dir challenge */
920 if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
921 /* Now challenge dir */
922 !cram_md5_challenge(dir, password, tls_local_need, compatible)) {
923 bsnprintf(msg, msglen, _("Director authorization problem at \"%s:%d\"\n"),
924 dir->host(), dir->port());
928 /* Verify that the remote host is willing to meet our TLS requirements */
929 if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
930 bsnprintf(msg, msglen, _("Authorization problem:"
931 " Remote server at \"%s:%d\" did not advertise required TLS support.\n"),
932 dir->host(), dir->port());
936 /* Verify that we are willing to meet the remote host's requirements */
937 if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
938 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\":"
939 " Remote server requires TLS.\n"),
940 dir->host(), dir->port());
945 /* Is TLS Enabled? */
947 if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
948 /* Engage TLS! Full Speed Ahead! */
949 if (!bnet_tls_client(tls_ctx, dir, NULL)) {
950 bsnprintf(msg, msglen, _("TLS negotiation failed with Director at \"%s:%d\"\n"),
951 dir->host(), dir->port());
957 Dmsg1(6, ">dird: %s", dir->msg);
958 if (dir->recv() <= 0) {
960 bsnprintf(msg, msglen, _("Bad response to Hello command: ERR=%s\n"
961 "The Director at \"%s:%d\" is probably not running.\n"),
962 dir->bstrerror(), dir->host(), dir->port());
967 Dmsg1(10, "<dird: %s", dir->msg);
968 if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
969 bsnprintf(msg, msglen, _("Director at \"%s:%d\" rejected Hello command\n"),
970 dir->host(), dir->port());
973 bsnprintf(msg, msglen, "%s", dir->msg);
979 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\"\n"
980 "Most likely the passwords do not agree.\n"
981 "If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
982 "Please see http://www.bacula.org/rel-manual/faq.html#AuthorizationErrors for help.\n"),
983 dir->host(), dir->port());