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()
89 * Try to connect to host for max_retry_time at retry_time intervals.
90 * Note, you must have called the constructor prior to calling
93 bool BSOCK::connect(JCR * jcr, int retry_interval, utime_t max_retry_time,
95 const char *name, char *host, char *service, int port,
101 time_t begin_time = time(NULL);
103 btimer_t *tid = NULL;
105 /* Try to trap out of OS call when time expires */
106 if (max_retry_time) {
107 tid = start_thread_timer(pthread_self(), (uint32_t)max_retry_time);
110 for (i = 0; !open(jcr, name, host, service, port, heart_beat, &fatal);
111 i -= retry_interval) {
113 if (fatal || (jcr && job_canceled(jcr))) {
116 Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
117 name, host, port, be.bstrerror());
119 i = 60 * 5; /* complain again in 5 minutes */
121 Qmsg4(jcr, M_WARNING, 0, _(
122 "Could not connect to %s on %s:%d. ERR=%s\n"
123 "Retrying ...\n"), name, host, port, be.bstrerror());
125 bmicrosleep(retry_interval, 0);
127 if (begin_time + max_retry_time <= now) {
128 Qmsg4(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"),
129 name, host, port, be.bstrerror());
137 stop_thread_timer(tid);
144 * Finish initialization of the pocket structure.
146 void BSOCK::fin_init(JCR * jcr, int sockfd, const char *who, const char *host, int port,
147 struct sockaddr *lclient_addr)
149 Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
151 set_who(bstrdup(who));
152 set_host(bstrdup(host));
154 memcpy(&client_addr, lclient_addr, sizeof(client_addr));
159 * Open a TCP connection to the server
161 * Returns BSOCK * pointer on success
164 bool BSOCK::open(JCR *jcr, const char *name, char *host, char *service,
165 int port, utime_t heart_beat, int *fatal)
170 bool connected = false;
176 * Fill in the structure serv_addr with the address of
177 * the server that we want to connect with.
179 if ((addr_list = bnet_host2ipaddrs(host, 0, &errstr)) == NULL) {
180 /* Note errstr is not malloc'ed */
181 Qmsg2(jcr, M_ERROR, 0, _("gethostbyname() for host \"%s\" failed: ERR=%s\n"),
183 Dmsg2(100, "bnet_host2ipaddrs() for host %s failed: ERR=%s\n",
189 foreach_dlist(ipaddr, addr_list) {
190 ipaddr->set_port_net(htons(port));
191 char allbuf[256 * 10];
193 Dmsg2(100, "Current %sAll %s\n",
194 ipaddr->build_address_str(curbuf, sizeof(curbuf)),
195 build_addresses_str(addr_list, allbuf, sizeof(allbuf)));
196 /* Open a TCP socket */
197 if ((sockfd = socket(ipaddr->get_family(), SOCK_STREAM, 0)) < 0) {
201 Pmsg3(000, _("Socket open error. proto=%d port=%d. ERR=%s\n"),
202 ipaddr->get_family(), ipaddr->get_port_host_order(), be.bstrerror());
206 * Keep socket from timing out from inactivity
208 if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
210 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
213 #if defined(TCP_KEEPIDLE)
216 if (setsockopt(sockfd, IPPROTO_IP, TCP_KEEPIDLE, (sockopt_val_t)&opt, sizeof(opt)) < 0) {
218 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPIDLE on socket: %s\n"),
224 /* connect to server */
225 if (::connect(sockfd, ipaddr->get_sockaddr(), ipaddr->get_sockaddr_len()) < 0) {
236 free_addresses(addr_list);
237 errno = save_errno | b_errno_win32;
241 * Keep socket from timing out from inactivity
242 * Do this a second time out of paranoia
244 if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
246 Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
249 fin_init(jcr, sockfd, name, host, port, ipaddr->get_sockaddr());
250 free_addresses(addr_list);
257 * Send a message over the network. The send consists of
258 * two network packets. The first is sends a 32 bit integer containing
259 * the length of the data packet which follows.
261 * Returns: false on failure
270 if (errors || is_terminated() || msglen > 1000000) {
273 /* Compute total packet length */
275 pktsiz = sizeof(pktsiz); /* signal, no data */
277 pktsiz = msglen + sizeof(pktsiz); /* data */
279 /* Store packet length at head of message -- note, we
280 * have reserved an int32_t just before msg, so we can
283 hdr = (int32_t *)(msg - (int)sizeof(pktsiz));
284 *hdr = htonl(msglen); /* store signal/length */
286 out_msg_no++; /* increment message number */
288 /* send data packet */
289 timer_start = watchdog_time; /* start timer */
291 /* Full I/O done in one write */
292 rc = write_nbytes(this, (char *)hdr, pktsiz);
293 timer_start = 0; /* clear timer */
302 if (!m_suppress_error_msgs) {
303 Qmsg5(m_jcr, M_ERROR, 0,
304 _("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"),
306 m_host, m_port, this->bstrerror());
309 Qmsg5(m_jcr, M_ERROR, 0,
310 _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
311 msglen, m_who, m_host, m_port, rc);
319 * Format and send a message
320 * Returns: false on error
323 bool BSOCK::fsend(const char *fmt, ...)
328 if (errors || is_terminated()) {
331 /* This probably won't work, but we vsnprintf, then if we
332 * get a negative length or a length greater than our buffer
333 * (depending on which library is used), the printf was truncated, so
334 * get a bigger buffer and try again.
337 maxlen = sizeof_pool_memory(msg) - 1;
338 va_start(arg_ptr, fmt);
339 msglen = bvsnprintf(msg, maxlen, fmt, arg_ptr);
341 if (msglen > 0 && msglen < (maxlen - 5)) {
344 msg = realloc_pool_memory(msg, maxlen + maxlen / 2);
350 * Receive a message from the other end. Each message consists of
351 * two packets. The first is a header that contains the size
352 * of the data that follows in the second packet.
353 * Returns number of bytes read (may return zero)
354 * Returns -1 on signal (BNET_SIGNAL)
355 * Returns -2 on hard end of file (BNET_HARDEOF)
356 * Returns -3 on error (BNET_ERROR)
358 * Unfortunately, it is a bit complicated because we have these
361 * 2. Signal including end of data stream
362 * 3. Hard end of file
364 * Using is_bnet_stop() and is_bnet_error() you can figure this all out.
366 int32_t BSOCK::recv()
373 if (errors || is_terminated()) {
377 read_seqno++; /* bump sequence number */
378 timer_start = watchdog_time; /* set start wait time */
380 /* get data size -- in int32_t */
381 if ((nbytes = read_nbytes(this, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
382 timer_start = 0; /* clear timer */
383 /* probably pipe broken because client died */
390 return BNET_HARDEOF; /* assume hard EOF received */
392 timer_start = 0; /* clear timer */
393 if (nbytes != sizeof(int32_t)) {
396 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
397 sizeof(int32_t), nbytes, m_who, m_host, m_port);
401 pktsiz = ntohl(pktsiz); /* decode no. of bytes that follow */
403 if (pktsiz == 0) { /* No data transferred */
404 timer_start = 0; /* clear timer */
407 return 0; /* zero bytes read */
410 /* If signal or packet size too big */
411 if (pktsiz < 0 || pktsiz > 1000000) {
412 if (pktsiz > 0) { /* if packet too big */
413 Qmsg3(m_jcr, M_FATAL, 0,
414 _("Packet size too big from \"%s:%s:%d. Terminating connection.\n"),
415 m_who, m_host, m_port);
416 pktsiz = BNET_TERMINATE; /* hang up */
418 if (pktsiz == BNET_TERMINATE) {
421 timer_start = 0; /* clear timer */
423 msglen = pktsiz; /* signal code */
424 return BNET_SIGNAL; /* signal */
427 /* Make sure the buffer is big enough + one byte for EOS */
428 if (pktsiz >= (int32_t) sizeof_pool_memory(msg)) {
429 msg = realloc_pool_memory(msg, pktsiz + 100);
432 timer_start = watchdog_time; /* set start wait time */
434 /* now read the actual data */
435 if ((nbytes = read_nbytes(this, msg, pktsiz)) <= 0) {
436 timer_start = 0; /* clear timer */
443 Qmsg4(m_jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"),
444 m_who, m_host, m_port, this->bstrerror());
447 timer_start = 0; /* clear timer */
450 if (nbytes != pktsiz) {
453 Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
454 pktsiz, nbytes, m_who, m_host, m_port);
457 /* always add a zero by to properly terminate any
458 * string that was send to us. Note, we ensured above that the
459 * buffer is at least one byte longer than the message length.
461 msg[nbytes] = 0; /* terminate in case it is a string */
462 sm_check(__FILE__, __LINE__, false);
463 return nbytes; /* return actual length of message */
470 bool BSOCK::signal(int signal)
473 if (signal == BNET_TERMINATE) {
474 m_suppress_error_msgs = true;
480 * Despool spooled attributes
482 bool BSOCK::despool(void update_attr_spool_size(ssize_t size), ssize_t tsize)
486 ssize_t last = 0, size = 0;
491 #if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
492 posix_fadvise(fileno(m_spool_fd), 0, 0, POSIX_FADV_WILLNEED);
495 while (fread((char *)&pktsiz, 1, sizeof(int32_t), m_spool_fd) ==
497 size += sizeof(int32_t);
498 msglen = ntohl(pktsiz);
500 if (msglen > (int32_t) sizeof_pool_memory(msg)) {
501 msg = realloc_pool_memory(msg, msglen + 1);
503 nbytes = fread(msg, 1, msglen, m_spool_fd);
504 if (nbytes != (size_t) msglen) {
506 Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
507 Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
509 update_attr_spool_size(tsize - last);
513 if ((++count & 0x3F) == 0) {
514 update_attr_spool_size(size - last);
520 update_attr_spool_size(tsize - last);
521 if (ferror(m_spool_fd)) {
523 Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
531 * Return the string for the error that occurred
532 * on the socket. Only the first error is retained.
534 const char *BSOCK::bstrerror()
537 if (errmsg == NULL) {
538 errmsg = get_pool_memory(PM_MESSAGE);
540 pm_strcpy(errmsg, be.bstrerror(b_errno));
544 int BSOCK::get_peer(char *buf, socklen_t buflen)
546 #if !defined(HAVE_WIN32)
547 if (peer_addr.sin_family == 0) {
548 socklen_t salen = sizeof(peer_addr);
549 int rval = (getpeername)(m_fd, (struct sockaddr *)&peer_addr, &salen);
550 if (rval < 0) return rval;
552 if (!inet_ntop(peer_addr.sin_family, &peer_addr.sin_addr, buf, buflen))
562 * Set the network buffer size, suggested size is in size.
563 * Actual size obtained is returned in bs->msglen
565 * Returns: false on failure
568 bool BSOCK::set_buffer_size(uint32_t size, int rw)
570 uint32_t dbuf_size, start_size;
571 #if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
573 opt = IPTOS_THROUGHPUT;
574 setsockopt(fd, IPPROTO_IP, IP_TOS, (sockopt_val_t)&opt, sizeof(opt));
580 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
582 start_size = dbuf_size;
583 if ((msg = realloc_pool_memory(msg, dbuf_size + 100)) == NULL) {
584 Qmsg0(get_jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
587 if (rw & BNET_SETBUF_READ) {
588 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
589 SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
591 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
592 dbuf_size -= TAPE_BSIZE;
594 Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
595 if (dbuf_size != start_size) {
596 Qmsg1(get_jcr(), M_WARNING, 0,
597 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
599 if (dbuf_size % TAPE_BSIZE != 0) {
600 Qmsg1(get_jcr(), M_ABORT, 0,
601 _("Network buffer size %d not multiple of tape block size.\n"),
608 dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
610 start_size = dbuf_size;
611 if (rw & BNET_SETBUF_WRITE) {
612 while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
613 SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
615 Qmsg1(get_jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
616 dbuf_size -= TAPE_BSIZE;
618 Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
619 if (dbuf_size != start_size) {
620 Qmsg1(get_jcr(), M_WARNING, 0,
621 _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
623 if (dbuf_size % TAPE_BSIZE != 0) {
624 Qmsg1(get_jcr(), M_ABORT, 0,
625 _("Network buffer size %d not multiple of tape block size.\n"),
635 * Set socket non-blocking
636 * Returns previous socket flag
638 int BSOCK::set_nonblocking()
643 /* Get current flags */
644 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
646 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
649 /* Set O_NONBLOCK flag */
650 if ((fcntl(m_fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
652 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
662 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
670 * Set socket blocking
671 * Returns previous socket flags
673 int BSOCK::set_blocking()
677 /* Get current flags */
678 if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
680 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
683 /* Set O_NONBLOCK flag */
684 if ((fcntl(m_fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
686 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
696 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
704 * Restores socket flags
706 void BSOCK::restore_blocking (int flags)
709 if ((fcntl(m_fd, F_SETFL, flags)) < 0) {
711 Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
714 m_blocking = (flags & O_NONBLOCK) ? true : false;
716 u_long ioctlArg = flags;
718 ioctlsocket(m_fd, FIONBIO, &ioctlArg);
724 * Wait for a specified time for data to appear on
725 * the BSOCK connection.
727 * Returns: 1 if data available
731 int BSOCK::wait_data(int sec)
737 FD_SET((unsigned)m_fd, &fdset);
741 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
742 case 0: /* timeout */
747 if (errno == EINTR) {
750 return -1; /* error return */
759 * As above, but returns on interrupt
761 int BSOCK::wait_data_intr(int sec)
767 FD_SET((unsigned)m_fd, &fdset);
770 switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
771 case 0: /* timeout */
776 return -1; /* error return */
785 * Note, this routine closes and destroys all the sockets
786 * that are open including the duped ones.
797 for (; bsock; bsock = next) {
798 next = bsock->m_next; /* get possible pointer to next before destoryed */
799 if (!bsock->m_duped) {
800 /* Shutdown tls cleanly. */
802 tls_bsock_shutdown(bsock);
803 free_tls_connection(bsock->tls);
806 if (bsock->is_timed_out()) {
807 shutdown(bsock->m_fd, SHUT_RDWR); /* discard any pending I/O */
809 socketClose(bsock->m_fd); /* normal close */
816 void BSOCK::destroy()
819 free_pool_memory(msg);
822 ASSERT(1 == 0); /* double close */
825 free_pool_memory(errmsg);
839 /* Commands sent to Director */
840 static char hello[] = "Hello %s calling\n";
842 /* Response from Director */
843 static char OKhello[] = "1000 OK:";
846 * Authenticate Director
848 bool BSOCK::authenticate_director(const char *name, const char *password,
849 TLS_CONTEXT *tls_ctx, char *msg, int msglen)
851 int tls_local_need = BNET_TLS_NONE;
852 int tls_remote_need = BNET_TLS_NONE;
853 int compatible = true;
854 char bashed_name[MAX_NAME_LENGTH];
855 BSOCK *dir = this; /* for readability */
859 * Send my name to the Director then do authentication
862 /* Timeout Hello after 15 secs */
863 dir->start_timer(15);
864 dir->fsend(hello, bashed_name);
866 if (get_tls_enable(tls_ctx)) {
867 tls_local_need = get_tls_enable(tls_ctx) ? BNET_TLS_REQUIRED : BNET_TLS_OK;
870 /* respond to Dir challenge */
871 if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
872 /* Now challenge dir */
873 !cram_md5_challenge(dir, password, tls_local_need, compatible)) {
874 bsnprintf(msg, msglen, _("Director authorization problem at \"%s:%d\"\n"),
875 dir->host(), dir->port());
879 /* Verify that the remote host is willing to meet our TLS requirements */
880 if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
881 bsnprintf(msg, msglen, _("Authorization problem:"
882 " Remote server at \"%s:%d\" did not advertise required TLS support.\n"),
883 dir->host(), dir->port());
887 /* Verify that we are willing to meet the remote host's requirements */
888 if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
889 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\":"
890 " Remote server requires TLS.\n"),
891 dir->host(), dir->port());
896 /* Is TLS Enabled? */
898 if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
899 /* Engage TLS! Full Speed Ahead! */
900 if (!bnet_tls_client(tls_ctx, dir, NULL)) {
901 bsnprintf(msg, msglen, _("TLS negotiation failed with Director at \"%s:%d\"\n"),
902 dir->host(), dir->port());
908 Dmsg1(6, ">dird: %s", dir->msg);
909 if (dir->recv() <= 0) {
911 bsnprintf(msg, msglen, _("Bad response to Hello command: ERR=%s\n"
912 "The Director at \"%s:%d\" is probably not running.\n"),
913 dir->bstrerror(), dir->host(), dir->port());
918 Dmsg1(10, "<dird: %s", dir->msg);
919 if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
920 bsnprintf(msg, msglen, _("Director at \"%s:%d\" rejected Hello command\n"),
921 dir->host(), dir->port());
924 bsnprintf(msg, msglen, "%s", dir->msg);
930 bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\"\n"
931 "Most likely the passwords do not agree.\n"
932 "If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
933 "Please see http://www.bacula.org/rel-manual/faq.html#AuthorizationErrors for help.\n"),
934 dir->host(), dir->port());