/*
Bacula® - The Network Backup Solution
- Copyright (C) 2007-2007 Free Software Foundation Europe e.V.
+ Copyright (C) 2007-2011 Free Software Foundation Europe e.V.
The main author of Bacula is Kern Sibbald, with contributions from
many others, a complete list can be found in the file AUTHORS.
This program is Free Software; you can redistribute it and/or
- modify it under the terms of version two of the GNU General Public
- License as published by the Free Software Foundation plus additions
- that are listed in the file LICENSE.
+ modify it under the terms of version three of the GNU Affero General Public
+ License as published by the Free Software Foundation and included
+ in the file LICENSE.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU Affero General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Bacula® is a registered trademark of John Walker.
+ Bacula® is a registered trademark of Kern Sibbald.
The licensor of Bacula is the Free Software Foundation Europe
(FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
Switzerland, email:ftf@fsfeurope.org.
*
* by Kern Sibbald
*
- * Version $Id: $
*/
-
#include "bacula.h"
#include "jcr.h"
#include <netdb.h>
{
memset(this, 0, sizeof(BSOCK));
m_blocking = 1;
- msg = get_pool_memory(PM_MESSAGE);
+ msg = get_pool_memory(PM_BSOCK);
errmsg = get_pool_memory(PM_MESSAGE);
/*
* ****FIXME**** reduce this to a few hours once
destroy();
}
+void BSOCK::free_tls()
+{
+ free_tls_connection(this->tls);
+ this->tls = NULL;
+}
+
/*
* Try to connect to host for max_retry_time at retry_time intervals.
* Note, you must have called the constructor prior to calling
/* Try to trap out of OS call when time expires */
if (max_retry_time) {
- tid = start_thread_timer(pthread_self(), (uint32_t)max_retry_time);
+ tid = start_thread_timer(jcr, pthread_self(), (uint32_t)max_retry_time);
}
for (i = 0; !open(jcr, name, host, service, port, heart_beat, &fatal);
return ok;
}
-
/*
* Finish initialization of the pocket structure.
*/
void BSOCK::fin_init(JCR * jcr, int sockfd, const char *who, const char *host, int port,
- struct sockaddr *lclient_addr)
+ struct sockaddr *lclient_addr)
{
Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
m_fd = sockfd;
set_jcr(jcr);
}
+/*
+ * Copy the address from the configuration dlist that gets passed in
+ */
+void BSOCK::set_source_address(dlist *src_addr_list)
+{
+ IPADDR *addr = NULL;
+
+ // delete the object we already have, if it's allocated
+ if (src_addr) {
+ free( src_addr);
+ src_addr = NULL;
+ }
+
+ if (src_addr_list) {
+ addr = (IPADDR*) src_addr_list->first();
+ src_addr = New( IPADDR(*addr));
+ }
+}
+
/*
* Open a TCP connection to the server
* Returns NULL
* Returns BSOCK * pointer on success
- *
*/
bool BSOCK::open(JCR *jcr, const char *name, char *host, char *service,
- int port, utime_t heart_beat, int *fatal)
+ int port, utime_t heart_beat, int *fatal)
{
int sockfd = -1;
dlist *addr_list;
ipaddr->get_family(), ipaddr->get_port_host_order(), be.bstrerror());
continue;
}
+
+ /* Bind to the source address if it is set */
+ if (src_addr) {
+ if (bind(sockfd, src_addr->get_sockaddr(), src_addr->get_sockaddr_len()) < 0) {
+ berrno be;
+ save_errno = errno;
+ *fatal = 1;
+ Pmsg2(000, _("Source address bind error. proto=%d. ERR=%s\n"),
+ src_addr->get_family(), be.bstrerror() );
+ continue;
+ }
+ }
+
/*
* Keep socket from timing out from inactivity
*/
return true;
}
+/*
+ * Force read/write to use locking
+ */
+bool BSOCK::set_locking()
+{
+ int stat;
+ if (m_use_locking) {
+ return true; /* already set */
+ }
+ if ((stat = pthread_mutex_init(&m_mutex, NULL)) != 0) {
+ berrno be;
+ Qmsg(m_jcr, M_FATAL, 0, _("Could not init bsock mutex. ERR=%s\n"),
+ be.bstrerror(stat));
+ return false;
+ }
+ m_use_locking = true;
+ return true;
+}
+void BSOCK::clear_locking()
+{
+ if (!m_use_locking) {
+ return;
+ }
+ m_use_locking = false;
+ pthread_mutex_destroy(&m_mutex);
+ return;
+}
/*
* Send a message over the network. The send consists of
int32_t rc;
int32_t pktsiz;
int32_t *hdr;
+ bool ok = true;
- if (errors || is_terminated() || msglen > 1000000) {
+ if (errors) {
+ if (!m_suppress_error_msgs) {
+ Qmsg4(m_jcr, M_ERROR, 0, _("Socket has errors=%d on call to %s:%s:%d\n"),
+ errors, m_who, m_host, m_port);
+ }
+ return false;
+ }
+ if (is_terminated()) {
+ if (!m_suppress_error_msgs) {
+ Qmsg4(m_jcr, M_ERROR, 0, _("Socket is terminated=%d on call to %s:%s:%d\n"),
+ is_terminated(), m_who, m_host, m_port);
+ }
+ return false;
+ }
+ if (msglen > 4000000) {
+ if (!m_suppress_error_msgs) {
+ Qmsg4(m_jcr, M_ERROR, 0,
+ _("Socket has insane msglen=%d on call to %s:%s:%d\n"),
+ msglen, m_who, m_host, m_port);
+ }
return false;
}
+
+ if (m_use_locking) P(m_mutex);
/* Compute total packet length */
if (msglen <= 0) {
pktsiz = sizeof(pktsiz); /* signal, no data */
/* send data packet */
timer_start = watchdog_time; /* start timer */
- m_timed_out = 0;
+ clear_timed_out();
/* Full I/O done in one write */
rc = write_nbytes(this, (char *)hdr, pktsiz);
timer_start = 0; /* clear timer */
_("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"),
msglen, m_who, m_host, m_port, rc);
}
- return false;
+ ok = false;
}
- return true;
+ if (m_use_locking) V(m_mutex);
+ return ok;
}
/*
return BNET_HARDEOF;
}
+ if (m_use_locking) P(m_mutex);
read_seqno++; /* bump sequence number */
timer_start = watchdog_time; /* set start wait time */
- m_timed_out = 0;
+ clear_timed_out();
/* get data size -- in int32_t */
if ((nbytes = read_nbytes(this, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
timer_start = 0; /* clear timer */
b_errno = errno;
}
errors++;
- return BNET_HARDEOF; /* assume hard EOF received */
+ nbytes = BNET_HARDEOF; /* assume hard EOF received */
+ goto get_out;
}
timer_start = 0; /* clear timer */
if (nbytes != sizeof(int32_t)) {
b_errno = EIO;
Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
sizeof(int32_t), nbytes, m_who, m_host, m_port);
- return BNET_ERROR;
+ nbytes = BNET_ERROR;
+ goto get_out;
}
pktsiz = ntohl(pktsiz); /* decode no. of bytes that follow */
if (pktsiz == 0) { /* No data transferred */
- timer_start = 0; /* clear timer */
+ timer_start = 0; /* clear timer */
in_msg_no++;
msglen = 0;
- return 0; /* zero bytes read */
+ nbytes = 0; /* zero bytes read */
+ goto get_out;
}
/* If signal or packet size too big */
if (pktsiz == BNET_TERMINATE) {
set_terminated();
}
- timer_start = 0; /* clear timer */
+ timer_start = 0; /* clear timer */
b_errno = ENODATA;
- msglen = pktsiz; /* signal code */
- return BNET_SIGNAL; /* signal */
+ msglen = pktsiz; /* signal code */
+ nbytes = BNET_SIGNAL; /* signal */
+ goto get_out;
}
/* Make sure the buffer is big enough + one byte for EOS */
}
timer_start = watchdog_time; /* set start wait time */
- m_timed_out = 0;
+ clear_timed_out();
/* now read the actual data */
if ((nbytes = read_nbytes(this, msg, pktsiz)) <= 0) {
timer_start = 0; /* clear timer */
errors++;
Qmsg4(m_jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"),
m_who, m_host, m_port, this->bstrerror());
- return BNET_ERROR;
+ nbytes = BNET_ERROR;
+ goto get_out;
}
timer_start = 0; /* clear timer */
in_msg_no++;
errors++;
Qmsg5(m_jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"),
pktsiz, nbytes, m_who, m_host, m_port);
- return BNET_ERROR;
+ nbytes = BNET_ERROR;
+ goto get_out;
}
/* always add a zero by to properly terminate any
* string that was send to us. Note, we ensured above that the
* buffer is at least one byte longer than the message length.
*/
msg[nbytes] = 0; /* terminate in case it is a string */
- sm_check(__FILE__, __LINE__, false);
+ /*
+ * The following uses *lots* of resources so turn it on only for
+ * serious debugging.
+ */
+ Dsm_check(300);
+
+get_out:
+ if (m_use_locking) V(m_mutex);
return nbytes; /* return actual length of message */
}
-
/*
* Send a signal
*/
size_t nbytes;
ssize_t last = 0, size = 0;
int count = 0;
+ JCR *jcr = get_jcr();
rewind(m_spool_fd);
size += sizeof(int32_t);
msglen = ntohl(pktsiz);
if (msglen > 0) {
- if (msglen > (int32_t) sizeof_pool_memory(msg)) {
+ if (msglen > (int32_t)sizeof_pool_memory(msg)) {
msg = realloc_pool_memory(msg, msglen + 1);
}
nbytes = fread(msg, 1, msglen, m_spool_fd);
- if (nbytes != (size_t) msglen) {
+ if (nbytes != (size_t)msglen) {
berrno be;
Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
}
}
send();
+ if (jcr && job_canceled(jcr)) {
+ return false;
+ }
}
update_attr_spool_size(tsize - last);
if (ferror(m_spool_fd)) {
- berrno be;
- Qmsg1(get_jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
- be.bstrerror());
+ Qmsg(jcr, M_FATAL, 0, _("fread attr spool I/O error.\n"));
return false;
}
return true;
bool BSOCK::set_buffer_size(uint32_t size, int rw)
{
uint32_t dbuf_size, start_size;
+
#if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
int opt;
opt = IPTOS_THROUGHPUT;
Qmsg0(get_jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
return false;
}
+
+ /*
+ * If user has not set the size, use the OS default -- i.e. do not
+ * try to set it. This allows sys admins to set the size they
+ * want in the OS, and Bacula will comply. See bug #1493
+ */
+ if (size == 0) {
+ msglen = dbuf_size;
+ return true;
+ }
+
if (rw & BNET_SETBUF_READ) {
while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
/* Get current flags */
if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
berrno be;
- Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
+ Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
}
/* Set O_NONBLOCK flag */
if ((fcntl(m_fd, F_SETFL, oflags|O_NONBLOCK)) < 0) {
berrno be;
- Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
+ Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
}
m_blocking = 0;
/* Get current flags */
if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
berrno be;
- Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
+ Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.bstrerror());
}
/* Set O_NONBLOCK flag */
if ((fcntl(m_fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) {
berrno be;
- Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
+ Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
}
m_blocking = 1;
#endif
}
+void BSOCK::set_killable(bool killable)
+{
+ if (m_jcr) {
+ m_jcr->set_killable(killable);
+ }
+}
+
/*
* Restores socket flags
*/
#ifndef HAVE_WIN32
if ((fcntl(m_fd, F_SETFL, flags)) < 0) {
berrno be;
- Jmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
+ Qmsg1(get_jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
}
m_blocking = (flags & O_NONBLOCK) ? true : false;
* 0 if timeout
* -1 if error
*/
-int BSOCK::wait_data(int sec)
+int BSOCK::wait_data(int sec, int usec)
{
fd_set fdset;
struct timeval tv;
FD_SET((unsigned)m_fd, &fdset);
for (;;) {
tv.tv_sec = sec;
- tv.tv_usec = 0;
+ tv.tv_usec = usec;
switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
case 0: /* timeout */
b_errno = 0;
/*
* As above, but returns on interrupt
*/
-int BSOCK::wait_data_intr(int sec)
+int BSOCK::wait_data_intr(int sec, int usec)
{
fd_set fdset;
struct timeval tv;
+ if (this == NULL) {
+ return -1;
+ }
FD_ZERO(&fdset);
FD_SET((unsigned)m_fd, &fdset);
tv.tv_sec = sec;
- tv.tv_usec = 0;
+ tv.tv_usec = usec;
switch (select(m_fd + 1, &fdset, NULL, NULL, &tv)) {
case 0: /* timeout */
b_errno = 0;
return -1; /* error return */
default:
b_errno = 0;
+ break;
}
return 1;
}
* Note, this routine closes and destroys all the sockets
* that are open including the duped ones.
*/
+#ifndef SHUT_RDWR
+#define SHUT_RDWR 2
+#endif
+
void BSOCK::close()
{
BSOCK *bsock = this;
BSOCK *next;
+ if (!m_duped) {
+ clear_locking();
+ }
for (; bsock; bsock = next) {
next = bsock->m_next; /* get possible pointer to next before destoryed */
if (!bsock->m_duped) {
bsock->tls = NULL;
}
if (bsock->is_timed_out()) {
- shutdown(bsock->m_fd, 2); /* discard any pending I/O */
+ shutdown(bsock->m_fd, SHUT_RDWR); /* discard any pending I/O */
}
socketClose(bsock->m_fd); /* normal close */
}
free(m_host);
m_host = NULL;
}
+ if (src_addr) {
+ free(src_addr);
+ src_addr = NULL;
+ }
free(this);
}
* Authenticate Director
*/
bool BSOCK::authenticate_director(const char *name, const char *password,
- TLS_CONTEXT *tls_ctx, char *msg, int msglen)
+ TLS_CONTEXT *tls_ctx, char *response, int response_len)
{
int tls_local_need = BNET_TLS_NONE;
int tls_remote_need = BNET_TLS_NONE;
char bashed_name[MAX_NAME_LENGTH];
BSOCK *dir = this; /* for readability */
- msg[0] = 0;
+ response[0] = 0;
/*
* Send my name to the Director then do authentication
*/
if (!cram_md5_respond(dir, password, &tls_remote_need, &compatible) ||
/* Now challenge dir */
!cram_md5_challenge(dir, password, tls_local_need, compatible)) {
- bsnprintf(msg, msglen, _("Director authorization problem at \"%s:%d\"\n"),
+ bsnprintf(response, response_len, _("Director authorization problem at \"%s:%d\"\n"),
dir->host(), dir->port());
goto bail_out;
}
/* Verify that the remote host is willing to meet our TLS requirements */
if (tls_remote_need < tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
- bsnprintf(msg, msglen, _("Authorization problem:"
+ bsnprintf(response, response_len, _("Authorization problem:"
" Remote server at \"%s:%d\" did not advertise required TLS support.\n"),
dir->host(), dir->port());
goto bail_out;
/* Verify that we are willing to meet the remote host's requirements */
if (tls_remote_need > tls_local_need && tls_local_need != BNET_TLS_OK && tls_remote_need != BNET_TLS_OK) {
- bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\":"
+ bsnprintf(response, response_len, _("Authorization problem with Director at \"%s:%d\":"
" Remote server requires TLS.\n"),
dir->host(), dir->port());
if (tls_local_need >= BNET_TLS_OK && tls_remote_need >= BNET_TLS_OK) {
/* Engage TLS! Full Speed Ahead! */
if (!bnet_tls_client(tls_ctx, dir, NULL)) {
- bsnprintf(msg, msglen, _("TLS negotiation failed with Director at \"%s:%d\"\n"),
+ bsnprintf(response, response_len, _("TLS negotiation failed with Director at \"%s:%d\"\n"),
dir->host(), dir->port());
goto bail_out;
}
Dmsg1(6, ">dird: %s", dir->msg);
if (dir->recv() <= 0) {
dir->stop_timer();
- bsnprintf(msg, msglen, _("Bad response to Hello command: ERR=%s\n"
+ bsnprintf(response, response_len, _("Bad response to Hello command: ERR=%s\n"
"The Director at \"%s:%d\" is probably not running.\n"),
dir->bstrerror(), dir->host(), dir->port());
return false;
}
- dir->stop_timer();
+ dir->stop_timer();
Dmsg1(10, "<dird: %s", dir->msg);
if (strncmp(dir->msg, OKhello, sizeof(OKhello)-1) != 0) {
- bsnprintf(msg, msglen, _("Director at \"%s:%d\" rejected Hello command\n"),
+ bsnprintf(response, response_len, _("Director at \"%s:%d\" rejected Hello command\n"),
dir->host(), dir->port());
return false;
} else {
- bsnprintf(msg, msglen, "%s", dir->msg);
+ bsnprintf(response, response_len, "%s", dir->msg);
}
return true;
bail_out:
dir->stop_timer();
- bsnprintf(msg, msglen, _("Authorization problem with Director at \"%s:%d\"\n"
+ bsnprintf(response, response_len, _("Authorization problem with Director at \"%s:%d\"\n"
"Most likely the passwords do not agree.\n"
"If you are using TLS, there may have been a certificate validation error during the TLS handshake.\n"
- "Please see http://www.bacula.org/rel-manual/faq.html#AuthorizationErrors for help.\n"),
+ "Please see " MANUAL_AUTH_URL " for help.\n"),
dir->host(), dir->port());
return false;
}