2 Bacula® - The Network Backup Solution
4 Copyright (C) 2007-2007 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);
263 * Send a message over the network. The send consists of
264 * two network packets. The first is sends a 32 bit integer containing
265 * the length of the data packet which follows.
267 * Returns: false on failure
276 if (errors || is_terminated() || msglen > 1000000) {
279 /* Compute total packet length */
281 pktsiz = sizeof(pktsiz); /* signal, no data */
283 pktsiz = msglen + sizeof(pktsiz); /* data */
285 /* Store packet length at head of message -- note, we
286 * have reserved an int32_t just before msg, so we can
289 hdr = (int32_t *)(msg - (int)sizeof(pktsiz));
290 *hdr = htonl(msglen); /* store signal/length */
292 out_msg_no++; /* increment message number */
294 /* send data packet */
295 timer_start = watchdog_time; /* start timer */
297 /* Full I/O done in one write */
298 rc = write_nbytes(this, (char *)hdr, pktsiz);
299 timer_start = 0; /* clear timer */
308 if (!m_suppress_error_msgs) {
309 Qmsg5(m_jcr, M_ERROR, 0,
310 _("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"),
312 m_host, m_port, this->bstrerror());
315 Qmsg5(m_jcr, M_ERROR, 0,
316 _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
317 msglen, m_who, m_host, m_port, rc);
325 * Format and send a message
326 * Returns: false on error
329 bool BSOCK::fsend(const char *fmt, ...)
334 if (errors || is_terminated()) {
337 /* This probably won't work, but we vsnprintf, then if we
338 * get a negative length or a length greater than our buffer
339 * (depending on which library is used), the printf was truncated, so
340 * get a bigger buffer and try again.
343 maxlen = sizeof_pool_memory(msg) - 1;
344 va_start(arg_ptr, fmt);
345 msglen = bvsnprintf(msg, maxlen, fmt, arg_ptr);
347 if (msglen > 0 && msglen < (maxlen - 5)) {
350 msg = realloc_pool_memory(msg, maxlen + maxlen / 2);
356 * Receive a message from the other end. Each message consists of
357 * two packets. The first is a header that contains the size
358 * of the data that follows in the second packet.
359 * Returns number of bytes read (may return zero)
360 * Returns -1 on signal (BNET_SIGNAL)
361 * Returns -2 on hard end of file (BNET_HARDEOF)
362 * Returns -3 on error (BNET_ERROR)
364 * Unfortunately, it is a bit complicated because we have these
367 * 2. Signal including end of data stream
368 * 3. Hard end of file
370 * Using is_bnet_stop() and is_bnet_error() you can figure this all out.
372 int32_t BSOCK::recv()
379 if (errors || is_terminated()) {
383 read_seqno++; /* bump sequence number */
384 timer_start = watchdog_time; /* set start wait time */
386 /* get data size -- in int32_t */
387 if ((nbytes = read_nbytes(this, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
388 timer_start = 0; /* clear timer */
389 /* probably pipe broken because client died */
396 return BNET_HARDEOF; /* assume hard EOF received */
398 timer_start = 0; /* clear timer */
399 if (nbytes != sizeof(int32_t)) {
402 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
403 sizeof(int32_t), nbytes, m_who, m_host, m_port);
407 pktsiz = ntohl(pktsiz); /* decode no. of bytes that follow */
409 if (pktsiz == 0) { /* No data transferred */
410 timer_start = 0; /* clear timer */
413 return 0; /* zero bytes read */
416 /* If signal or packet size too big */
417 if (pktsiz < 0 || pktsiz > 1000000) {
418 if (pktsiz > 0) { /* if packet too big */
419 Qmsg3(m_jcr, M_FATAL, 0,
420 _("Packet size too big from \"%s:%s:%d. Terminating connection.\n"),
421 m_who, m_host, m_port);
422 pktsiz = BNET_TERMINATE; /* hang up */
424 if (pktsiz == BNET_TERMINATE) {
427 timer_start = 0; /* clear timer */
429 msglen = pktsiz; /* signal code */
430 return BNET_SIGNAL; /* signal */
433 /* Make sure the buffer is big enough + one byte for EOS */
434 if (pktsiz >= (int32_t) sizeof_pool_memory(msg)) {
435 msg = realloc_pool_memory(msg, pktsiz + 100);
438 timer_start = watchdog_time; /* set start wait time */
440 /* now read the actual data */
441 if ((nbytes = read_nbytes(this, msg, pktsiz)) <= 0) {
442 timer_start = 0; /* clear timer */
449 Qmsg4(m_jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"),
450 m_who, m_host, m_port, this->bstrerror());
453 timer_start = 0; /* clear timer */
456 if (nbytes != pktsiz) {
459 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
460 pktsiz, nbytes, m_who, m_host, m_port);
463 /* always add a zero by to properly terminate any
464 * string that was send to us. Note, we ensured above that the
465 * buffer is at least one byte longer than the message length.
467 msg[nbytes] = 0; /* terminate in case it is a string */
468 sm_check(__FILE__, __LINE__, false);
469 return nbytes; /* return actual length of message */
476 bool BSOCK::signal(int signal)
479 if (signal == BNET_TERMINATE) {
480 m_suppress_error_msgs = true;
486 * Despool spooled attributes
488 bool BSOCK::despool(void update_attr_spool_size(ssize_t size), ssize_t tsize)
492 ssize_t last = 0, size = 0;
497 #if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
498 posix_fadvise(fileno(m_spool_fd), 0, 0, POSIX_FADV_WILLNEED);
501 while (fread((char *)&pktsiz, 1, sizeof(int32_t), m_spool_fd) ==
503 size += sizeof(int32_t);
504 msglen = ntohl(pktsiz);
506 if (msglen > (int32_t) sizeof_pool_memory(msg)) {
507 msg = realloc_pool_memory(msg, msglen + 1);
509 nbytes = fread(msg, 1, msglen, m_spool_fd);
510 if (nbytes != (size_t) msglen) {
512 Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
513 Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
515 update_attr_spool_size(tsize - last);
519 if ((++count & 0x3F) == 0) {
520 update_attr_spool_size(size - last);
526 update_attr_spool_size(tsize - last);
527 if (ferror(m_spool_fd)) {
529 Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
537 * Return the string for the error that occurred
538 * on the socket. Only the first error is retained.
540 const char *BSOCK::bstrerror()
543 if (errmsg == NULL) {
544 errmsg = get_pool_memory(PM_MESSAGE);
546 pm_strcpy(errmsg, be.bstrerror(b_errno));
550 int BSOCK::get_peer(char *buf, socklen_t buflen)
552 #if !defined(HAVE_WIN32)
553 if (peer_addr.sin_family == 0) {
554 socklen_t salen = sizeof(peer_addr);
555 int rval = (getpeername)(m_fd, (struct sockaddr *)&peer_addr, &salen);
556 if (rval < 0) return rval;
558 if (!inet_ntop(peer_addr.sin_family, &peer_addr.sin_addr, buf, buflen))
568 * Set the network buffer size, suggested size is in size.
569 * Actual size obtained is returned in bs->msglen
571 * Returns: false on failure
574 bool BSOCK::set_buffer_size(uint32_t size, int rw)
576 uint32_t dbuf_size, start_size;
577 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
579 opt = IPTOS_THROUGHPUT;
580 setsockopt(fd, IPPROTO_IP, IP_TOS, (sockopt_val_t)&opt, sizeof(opt));
586 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
588 start_size = dbuf_size;
589 if ((msg = realloc_pool_memory(msg, dbuf_size + 100)) == NULL) {
590 Qmsg0(get_jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
593 if (rw & BNET_SETBUF_READ) {
594 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
595 SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
597 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
598 dbuf_size -= TAPE_BSIZE;
600 Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
601 if (dbuf_size != start_size) {
602 Qmsg1(get_jcr(), M_WARNING, 0,
603 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
605 if (dbuf_size % TAPE_BSIZE != 0) {
606 Qmsg1(get_jcr(), M_ABORT, 0,
607 _("Network buffer size %d not multiple of tape block size.\n"),
614 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
616 start_size = dbuf_size;
617 if (rw & BNET_SETBUF_WRITE) {
618 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
619 SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
621 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
622 dbuf_size -= TAPE_BSIZE;
624 Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
625 if (dbuf_size != start_size) {
626 Qmsg1(get_jcr(), M_WARNING, 0,
627 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
629 if (dbuf_size % TAPE_BSIZE != 0) {
630 Qmsg1(get_jcr(), M_ABORT, 0,
631 _("Network buffer size %d not multiple of tape block size.\n"),
641 * Set socket non-blocking
642 * Returns previous socket flag
644 int BSOCK::set_nonblocking()
649 /* Get current flags */
650 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
652 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
655 /* Set O_NONBLOCK flag */
656 if ((fcntl(m_fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
658 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
668 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
676 * Set socket blocking
677 * Returns previous socket flags
679 int BSOCK::set_blocking()
683 /* Get current flags */
684 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
686 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
689 /* Set O_NONBLOCK flag */
690 if ((fcntl(m_fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
692 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
702 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
710 * Restores socket flags
712 void BSOCK::restore_blocking (int flags)
715 if ((fcntl(m_fd, F_SETFL, flags)) < 0) {
717 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
720 m_blocking = (flags & O_NONBLOCK) ? true : false;
722 u_long ioctlArg = flags;
724 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
730 * Wait for a specified time for data to appear on
731 * the BSOCK connection.
733 * Returns: 1 if data available
737 int BSOCK::wait_data(int sec)
743 FD_SET((unsigned)m_fd, &fdset);
747 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
748 case 0: /* timeout */
753 if (errno == EINTR) {
756 return -1; /* error return */
765 * As above, but returns on interrupt
767 int BSOCK::wait_data_intr(int sec)
773 FD_SET((unsigned)m_fd, &fdset);
776 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
777 case 0: /* timeout */
782 return -1; /* error return */
790 * Note, this routine closes and destroys all the sockets
791 * that are open including the duped ones.
802 for (; bsock; bsock = next) {
803 next = bsock->m_next; /* get possible pointer to next before destoryed */
804 if (!bsock->m_duped) {
805 /* Shutdown tls cleanly. */
807 tls_bsock_shutdown(bsock);
808 free_tls_connection(bsock->tls);
811 if (bsock->is_timed_out()) {
812 shutdown(bsock->m_fd, SHUT_RDWR); /* discard any pending I/O */
814 socketClose(bsock->m_fd); /* normal close */
821 void BSOCK::destroy()
824 free_pool_memory(msg);
827 ASSERT(1 == 0); /* double close */
830 free_pool_memory(errmsg);
844 /* Commands sent to Director */
845 static char hello[] = "Hello %s calling\n";
847 /* Response from Director */
848 static char OKhello[] = "1000 OK:";
851 * Authenticate Director
853 bool BSOCK::authenticate_director(const char *name, const char *password,
854 TLS_CONTEXT *tls_ctx, char *msg, int msglen)
856 int tls_local_need = BNET_TLS_NONE;
857 int tls_remote_need = BNET_TLS_NONE;
858 int compatible = true;
859 char bashed_name[MAX_NAME_LENGTH];
860 BSOCK *dir = this; /* for readability */
864 * Send my name to the Director then do authentication
867 /* Timeout Hello after 15 secs */
868 dir->start_timer(15);
869 dir->fsend(hello, bashed_name);
871 if (get_tls_enable(tls_ctx)) {
872 tls_local_need = get_tls_enable(tls_ctx) ? BNET_TLS_REQUIRED : BNET_TLS_OK;
875 /* respond to Dir challenge */
876 if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
877 /* Now challenge dir */
878 !cram_md5_challenge(dir, password, tls_local_need, compatible)) {
879 bsnprintf(msg, msglen, _("Director authorization problem at \"%s:%d\"\n"),
880 dir->host(), dir->port());
884 /* Verify that the remote host is willing to meet our TLS requirements */
885 if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
886 bsnprintf(msg, msglen, _("Authorization problem:"
887 " Remote server at \"%s:%d\" did not advertise required TLS support.\n"),
888 dir->host(), dir->port());
892 /* Verify that we are willing to meet the remote host's requirements */
893 if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
894 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\":"
895 " Remote server requires TLS.\n"),
896 dir->host(), dir->port());
901 /* Is TLS Enabled? */
903 if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
904 /* Engage TLS! Full Speed Ahead! */
905 if (!bnet_tls_client(tls_ctx, dir, NULL)) {
906 bsnprintf(msg, msglen, _("TLS negotiation failed with Director at \"%s:%d\"\n"),
907 dir->host(), dir->port());
913 Dmsg1(6, ">dird: %s", dir->msg);
914 if (dir->recv() <= 0) {
916 bsnprintf(msg, msglen, _("Bad response to Hello command: ERR=%s\n"
917 "The Director at \"%s:%d\" is probably not running.\n"),
918 dir->bstrerror(), dir->host(), dir->port());
923 Dmsg1(10, "<dird: %s", dir->msg);
924 if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
925 bsnprintf(msg, msglen, _("Director at \"%s:%d\" rejected Hello command\n"),
926 dir->host(), dir->port());
929 bsnprintf(msg, msglen, "%s", dir->msg);
935 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\"\n"
936 "Most likely the passwords do not agree.\n"
937 "If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
938 "Please see http://www.bacula.org/rel-manual/faq.html#AuthorizationErrors for help.\n"),
939 dir->host(), dir->port());