X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Flib%2Fbnet.c;h=e874fcee4fb28231f00f402b97fe858285b77e2b;hb=1c6e0ab3bc93f3dd5e4be8ec7dab9a3f64319470;hp=f0e21a628d77fbf46638358d5bf3ff71057f663f;hpb=66696d1cadedbb362c392dadce9a8ce275dd5d80;p=bacula%2Fbacula diff --git a/bacula/src/lib/bnet.c b/bacula/src/lib/bnet.c index f0e21a628d..e874fcee4f 100644 --- a/bacula/src/lib/bnet.c +++ b/bacula/src/lib/bnet.c @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2006 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. + + 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 + 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. + The licensor of Bacula is the Free Software Foundation Europe + (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, + Switzerland, email:ftf@fsfeurope.org. +*/ /* * Network Utility Routines * @@ -8,25 +35,6 @@ * * Version $Id$ */ -/* - Copyright (C) 2000-2004 Kern Sibbald and John Walker - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library 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 - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, - MA 02111-1307, USA. - - */ #include "bacula.h" @@ -36,36 +44,24 @@ extern time_t watchdog_time; #ifndef INADDR_NONE -#define INADDR_NONE -1 +#define INADDR_NONE -1 #endif -#ifndef ENODATA /* not defined on BSD systems */ +#ifndef ENODATA /* not defined on BSD systems */ #define ENODATA EPIPE #endif #ifdef HAVE_WIN32 #define socketRead(fd, buf, len) recv(fd, buf, len, 0) #define socketWrite(fd, buf, len) send(fd, buf, len, 0) -#define socketClose(fd) closesocket(fd) +#define socketClose(fd) closesocket(fd) #else #define socketRead(fd, buf, len) read(fd, buf, len) #define socketWrite(fd, buf, len) write(fd, buf, len) -#define socketClose(fd) close(fd) +#define socketClose(fd) close(fd) #endif - -#ifdef HAVE_OLD_SOCKOPT -int inet_aton(const char *cp, struct in_addr *inp) -{ - struct in_addr inaddr; - - if((inaddr.s_addr = inet_addr(cp)) != INADDR_NONE) { - inp->s_addr = inaddr.s_addr; - return 1; - } - return 0; -} -#endif +static pthread_mutex_t ip_mutex = PTHREAD_MUTEX_INITIALIZER; /* * Read a nbytes from the network. @@ -73,26 +69,40 @@ int inet_aton(const char *cp, struct in_addr *inp) * read requests */ -static int32_t read_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes) +int32_t read_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes) { int32_t nleft, nread; +#ifdef HAVE_TLS + if (bsock->tls) { + /* TLS enabled */ + return (tls_bsock_readn(bsock, ptr, nbytes)); + } +#endif /* HAVE_TLS */ + nleft = nbytes; while (nleft > 0) { - do { - errno = 0; - nread = socketRead(bsock->fd, ptr, nleft); - if (bsock->timed_out || bsock->terminated) { - return nread; - } - } while (nread == -1 && (errno == EINTR || errno == EAGAIN)); + errno = 0; + nread = socketRead(bsock->fd, ptr, nleft); + if (bsock->timed_out || bsock->terminated) { + return nread; + } + if (nread == -1) { + if (errno == EINTR) { + continue; + } + if (errno == EAGAIN) { + bmicrosleep(0, 200000); /* try again in 200ms */ + continue; + } + } if (nread <= 0) { - return nread; /* error, or EOF */ + return nread; /* error, or EOF */ } nleft -= nread; ptr += nread; } - return nbytes - nleft; /* return >= 0 */ + return nbytes - nleft; /* return >= 0 */ } /* @@ -100,31 +110,39 @@ static int32_t read_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes) * It may require several writes. */ -static int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes) +int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes) { int32_t nleft, nwritten; if (bsock->spool) { nwritten = fwrite(ptr, 1, nbytes, bsock->spool_fd); if (nwritten != nbytes) { - berrno be; - bsock->b_errno = errno; - Qmsg1(bsock->jcr, M_FATAL, 0, _("Attr spool write error. ERR=%s\n"), - be.strerror()); - Dmsg2(400, "nwritten=%d nbytes=%d.\n", nwritten, nbytes); - errno = bsock->b_errno; - return -1; + berrno be; + bsock->b_errno = errno; + Qmsg1(bsock->jcr(), M_FATAL, 0, _("Attr spool write error. ERR=%s\n"), + be.strerror()); + Dmsg2(400, "nwritten=%d nbytes=%d.\n", nwritten, nbytes); + errno = bsock->b_errno; + return -1; } return nbytes; } + +#ifdef HAVE_TLS + if (bsock->tls) { + /* TLS enabled */ + return (tls_bsock_writen(bsock, ptr, nbytes)); + } +#endif /* HAVE_TLS */ + nleft = nbytes; while (nleft > 0) { do { - errno = 0; - nwritten = socketWrite(bsock->fd, ptr, nleft); - if (bsock->timed_out || bsock->terminated) { - return nwritten; - } + errno = 0; + nwritten = socketWrite(bsock->fd, ptr, nleft); + if (bsock->timed_out || bsock->terminated) { + return nwritten; + } } while (nwritten == -1 && errno == EINTR); /* * If connection is non-blocking, we will get EAGAIN, so @@ -132,18 +150,18 @@ static int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes) * and try again. */ if (nwritten == -1 && errno == EAGAIN) { - fd_set fdset; - struct timeval tv; - - FD_ZERO(&fdset); - FD_SET((unsigned)bsock->fd, &fdset); - tv.tv_sec = 10; - tv.tv_usec = 0; - select(bsock->fd + 1, NULL, &fdset, NULL, &tv); - continue; + fd_set fdset; + struct timeval tv; + + FD_ZERO(&fdset); + FD_SET((unsigned)bsock->fd, &fdset); + tv.tv_sec = 10; + tv.tv_usec = 0; + select(bsock->fd + 1, NULL, &fdset, NULL, &tv); + continue; } if (nwritten <= 0) { - return nwritten; /* error */ + return nwritten; /* error */ } nleft -= nwritten; ptr += nwritten; @@ -158,7 +176,7 @@ static int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes) * Returns number of bytes read (may return zero) * Returns -1 on signal (BNET_SIGNAL) * Returns -2 on hard end of file (BNET_HARDEOF) - * Returns -3 on error (BNET_ERROR) + * Returns -3 on error (BNET_ERROR) * * Unfortunately, it is a bit complicated because we have these * four return types: @@ -170,103 +188,7 @@ static int32_t write_nbytes(BSOCK * bsock, char *ptr, int32_t nbytes) */ int32_t bnet_recv(BSOCK * bsock) { - int32_t nbytes; - int32_t pktsiz; - - ASSERT(bsock != NULL); - bsock->msg[0] = 0; - bsock->msglen = 0; - if (bsock->errors || bsock->terminated) { - return BNET_HARDEOF; - } - - bsock->read_seqno++; /* bump sequence number */ - bsock->timer_start = watchdog_time; /* set start wait time */ - bsock->timed_out = 0; - /* get data size -- in int32_t */ - if ((nbytes = read_nbytes(bsock, (char *)&pktsiz, sizeof(int32_t))) <= 0) { - bsock->timer_start = 0; /* clear timer */ - /* probably pipe broken because client died */ - if (errno == 0) { - bsock->b_errno = ENODATA; - } else { - bsock->b_errno = errno; - } - bsock->errors++; - return BNET_HARDEOF; /* assume hard EOF received */ - } - bsock->timer_start = 0; /* clear timer */ - if (nbytes != sizeof(int32_t)) { - bsock->errors++; - bsock->b_errno = EIO; - Qmsg5(bsock->jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"), - sizeof(int32_t), nbytes, bsock->who, bsock->host, bsock->port); - return BNET_ERROR; - } - - pktsiz = ntohl(pktsiz); /* decode no. of bytes that follow */ - - if (pktsiz == 0) { /* No data transferred */ - bsock->timer_start = 0; /* clear timer */ - bsock->in_msg_no++; - bsock->msglen = 0; - return 0; /* zero bytes read */ - } - - /* If signal or packet size too big */ - if (pktsiz < 0 || pktsiz > 1000000) { - if (pktsiz > 0) { /* if packet too big */ - Qmsg3(bsock->jcr, M_FATAL, 0, - _("Packet size too big from \"%s:%s:%d. Terminating connection.\n"), - bsock->who, bsock->host, bsock->port); - pktsiz = BNET_TERMINATE; /* hang up */ - } - if (pktsiz == BNET_TERMINATE) { - bsock->terminated = 1; - } - bsock->timer_start = 0; /* clear timer */ - bsock->b_errno = ENODATA; - bsock->msglen = pktsiz; /* signal code */ - return BNET_SIGNAL; /* signal */ - } - - /* Make sure the buffer is big enough + one byte for EOS */ - if (pktsiz >= (int32_t) sizeof_pool_memory(bsock->msg)) { - bsock->msg = realloc_pool_memory(bsock->msg, pktsiz + 100); - } - - bsock->timer_start = watchdog_time; /* set start wait time */ - bsock->timed_out = 0; - /* now read the actual data */ - if ((nbytes = read_nbytes(bsock, bsock->msg, pktsiz)) <= 0) { - bsock->timer_start = 0; /* clear timer */ - if (errno == 0) { - bsock->b_errno = ENODATA; - } else { - bsock->b_errno = errno; - } - bsock->errors++; - Qmsg4(bsock->jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"), - bsock->who, bsock->host, bsock->port, bnet_strerror(bsock)); - return BNET_ERROR; - } - bsock->timer_start = 0; /* clear timer */ - bsock->in_msg_no++; - bsock->msglen = nbytes; - if (nbytes != pktsiz) { - bsock->b_errno = EIO; - bsock->errors++; - Qmsg5(bsock->jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"), - pktsiz, nbytes, bsock->who, bsock->host, bsock->port); - return BNET_ERROR; - } - /* 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. - */ - bsock->msg[nbytes] = 0; /* terminate in case it is a string */ - sm_check(__FILE__, __LINE__, false); - return nbytes; /* return actual length of message */ + return bsock->recv(); } @@ -284,6 +206,7 @@ bool is_bnet_stop(BSOCK * bsock) */ int is_bnet_error(BSOCK * bsock) { + errno = bsock->b_errno; return bsock->errors; } @@ -301,7 +224,7 @@ void bnet_suppress_error_messages(BSOCK * bsock, bool flag) * Transmit spooled data now to a BSOCK */ int bnet_despool_to_bsock(BSOCK * bsock, void update_attr_spool_size(ssize_t size), - ssize_t tsize) + ssize_t tsize) { int32_t pktsiz; size_t nbytes; @@ -310,35 +233,35 @@ int bnet_despool_to_bsock(BSOCK * bsock, void update_attr_spool_size(ssize_t siz rewind(bsock->spool_fd); while (fread((char *)&pktsiz, 1, sizeof(int32_t), bsock->spool_fd) == - sizeof(int32_t)) { + sizeof(int32_t)) { size += sizeof(int32_t); bsock->msglen = ntohl(pktsiz); if (bsock->msglen > 0) { - if (bsock->msglen > (int32_t) sizeof_pool_memory(bsock->msg)) { - bsock->msg = realloc_pool_memory(bsock->msg, bsock->msglen + 1); - } - nbytes = fread(bsock->msg, 1, bsock->msglen, bsock->spool_fd); - if (nbytes != (size_t) bsock->msglen) { - berrno be; - Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, bsock->msglen); - Qmsg1(bsock->jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"), - be.strerror()); - update_attr_spool_size(tsize - last); - return 0; - } - size += nbytes; - if ((++count & 0x3F) == 0) { - update_attr_spool_size(size - last); - last = size; - } + if (bsock->msglen > (int32_t) sizeof_pool_memory(bsock->msg)) { + bsock->msg = realloc_pool_memory(bsock->msg, bsock->msglen + 1); + } + nbytes = fread(bsock->msg, 1, bsock->msglen, bsock->spool_fd); + if (nbytes != (size_t) bsock->msglen) { + berrno be; + Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, bsock->msglen); + Qmsg1(bsock->jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"), + be.strerror()); + update_attr_spool_size(tsize - last); + return 0; + } + size += nbytes; + if ((++count & 0x3F) == 0) { + update_attr_spool_size(size - last); + last = size; + } } bnet_send(bsock); } update_attr_spool_size(tsize - last); if (ferror(bsock->spool_fd)) { berrno be; - Qmsg1(bsock->jcr, M_FATAL, 0, _("fread attr spool error. ERR=%s\n"), - be.strerror()); + Qmsg1(bsock->jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"), + be.strerror()); return 0; } return 1; @@ -351,8 +274,14 @@ int bnet_despool_to_bsock(BSOCK * bsock, void update_attr_spool_size(ssize_t siz * the length of the data packet which follows. * * Returns: false on failure - * true on success + * true on success */ +bool bnet_send(BSOCK *bsock) +{ + return bsock->send(); +} + +#ifdef xxx bool bnet_send(BSOCK * bsock) { int32_t rc; @@ -361,101 +290,180 @@ bool bnet_send(BSOCK * bsock) if (bsock->errors || bsock->terminated || bsock->msglen > 1000000) { return false; } - pktsiz = htonl((int32_t) bsock->msglen); + pktsiz = htonl((int32_t)bsock->msglen); /* send int32_t containing size of data packet */ - bsock->timer_start = watchdog_time; /* start timer */ + bsock->timer_start = watchdog_time; /* start timer */ bsock->timed_out = 0; rc = write_nbytes(bsock, (char *)&pktsiz, sizeof(int32_t)); - bsock->timer_start = 0; /* clear timer */ + bsock->timer_start = 0; /* clear timer */ if (rc != sizeof(int32_t)) { - if (bsock->msglen == BNET_TERMINATE) { /* if we were terminating */ - bsock->terminated = 1; - return false; /* ignore any errors */ + if (bsock->msglen == BNET_TERMINATE) { /* if we were terminating */ + bsock->terminated = 1; + return false; /* ignore any errors */ } bsock->errors++; if (errno == 0) { - bsock->b_errno = EIO; + bsock->b_errno = EIO; } else { - bsock->b_errno = errno; + bsock->b_errno = errno; } if (rc < 0) { - if (!bsock->suppress_error_msgs && !bsock->timed_out) { - Qmsg4(bsock->jcr, M_ERROR, 0, - _("Write error sending to %s:%s:%d: ERR=%s\n"), bsock->who, - bsock->host, bsock->port, bnet_strerror(bsock)); - } + if (!bsock->suppress_error_msgs && !bsock->timed_out) { + Qmsg4(bsock->jcr(), M_ERROR, 0, + _("Write error sending len to %s:%s:%d: ERR=%s\n"), bsock->who, + bsock->host(), bsock->port(), bnet_strerror(bsock)); + } } else { - Qmsg5(bsock->jcr, M_ERROR, 0, - _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"), bsock->who, - bsock->host, bsock->port, bsock->msglen, rc); + Qmsg5(bsock->jcr(), M_ERROR, 0, + _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"), + sizeof(int32_t), bsock->who(), + bsock->host(), bsock->port(), rc); } return false; } - bsock->out_msg_no++; /* increment message number */ - if (bsock->msglen <= 0) { /* length only? */ - return true; /* yes, no data */ + bsock->out_msg_no++; /* increment message number */ + if (bsock->msglen <= 0) { /* length only? */ + return true; /* yes, no data */ } /* send data packet */ - bsock->timer_start = watchdog_time; /* start timer */ + bsock->timer_start = watchdog_time; /* start timer */ bsock->timed_out = 0; rc = write_nbytes(bsock, bsock->msg, bsock->msglen); - bsock->timer_start = 0; /* clear timer */ + bsock->timer_start = 0; /* clear timer */ if (rc != bsock->msglen) { bsock->errors++; if (errno == 0) { - bsock->b_errno = EIO; + bsock->b_errno = EIO; } else { - bsock->b_errno = errno; + bsock->b_errno = errno; } if (rc < 0) { - if (!bsock->suppress_error_msgs) { - Qmsg4(bsock->jcr, M_ERROR, 0, - _("Write error sending to %s:%s:%d: ERR=%s\n"), bsock->who, - bsock->host, bsock->port, bnet_strerror(bsock)); - } + if (!bsock->suppress_error_msgs) { + Qmsg5(bsock->jcr(), M_ERROR, 0, + _("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"), + bsock->msglen, bsock->who(), + bsock->host(), bsock->port(), bnet_strerror(bsock)); + } } else { - Qmsg5(bsock->jcr, M_ERROR, 0, - _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"), - bsock->msglen, bsock->who, bsock->host, bsock->port, rc); + Qmsg5(bsock->jcr(), M_ERROR, 0, + _("Wrote %d bytes to %s:%s:%d, but only %d accepted.\n"), + bsock->msglen, bsock->who(), bsock->host(), + bsock->port(), rc); } return false; } return true; } +#endif /* - * Establish an SSL connection -- server side - * Codes that ssl_need and ssl_has can take - * BNET_SSL_NONE I cannot do ssl - * BNET_SSL_OK I can do ssl, but it is not required on my end - * BNET_SSL_REQUIRED ssl is required on my end + * Establish a TLS connection -- server side + * Returns: true on success + * false on failure */ -int bnet_ssl_server(BSOCK * bsock, char *password, int ssl_need, int ssl_has) +#ifdef HAVE_TLS +bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list) { - /* Check to see if what we need (ssl_need) corresponds to what he has (ssl_has) */ - /* The other side expects a response from us */ - return 1; + TLS_CONNECTION *tls; + + tls = new_tls_connection(ctx, bsock->fd); + if (!tls) { + Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n")); + return false; + } + + bsock->tls = tls; + + /* Initiate TLS Negotiation */ + if (!tls_bsock_accept(bsock)) { + Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS Negotiation failed.\n")); + goto err; + } + + if (verify_list) { + if (!tls_postconnect_verify_cn(tls, verify_list)) { + Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS certificate verification failed." + " Peer certificate did not match a required commonName\n"), + bsock->host()); + goto err; + } + } + return true; + +err: + free_tls_connection(tls); + bsock->tls = NULL; + return false; } /* - * Establish an SSL connection -- client side + * Establish a TLS connection -- client side + * Returns: true on success + * false on failure */ -int bnet_ssl_client(BSOCK * bsock, char *password, int ssl_need) +bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list) { - /* We are the client so we must wait for the server to notify us */ - return 1; -} + TLS_CONNECTION *tls; + + tls = new_tls_connection(ctx, bsock->fd); + if (!tls) { + Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n")); + return false; + } + + bsock->tls = tls; + + /* Initiate TLS Negotiation */ + if (!tls_bsock_connect(bsock)) { + goto err; + } + + /* If there's an Allowed CN verify list, use that to validate the remote + * certificate's CN. Otherwise, we use standard host/CN matching. */ + if (verify_list) { + if (!tls_postconnect_verify_cn(tls, verify_list)) { + Qmsg1(bsock->jcr, M_FATAL, 0, _("TLS certificate verification failed." + " Peer certificate did not match a required commonName\n"), + bsock->host); + goto err; + } + } else { + if (!tls_postconnect_verify_host(tls, bsock->host())) { + Qmsg1(bsock->jcr(), M_FATAL, 0, _("TLS host certificate verification failed. Host %s did not match presented certificate\n"), + bsock->host()); + goto err; + } + } + + return true; +err: + free_tls_connection(tls); + bsock->tls = NULL; + return false; +} +#else +bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list) +{ + Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enabled but not configured.\n")); + return false; +} +bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK * bsock, alist *verify_list, int verify_hostname) +{ + Jmsg(bsock->jcr(), M_ABORT, 0, _("TLS enable but not configured.\n")); + return false; +} +#endif /* HAVE_TLS */ /* * Wait for a specified time for data to appear on * the BSOCK connection. * * Returns: 1 if data available - * 0 if timeout - * -1 if error + * 0 if timeout + * -1 if error */ int bnet_wait_data(BSOCK * bsock, int sec) { @@ -464,22 +472,22 @@ int bnet_wait_data(BSOCK * bsock, int sec) FD_ZERO(&fdset); FD_SET((unsigned)bsock->fd, &fdset); - tv.tv_sec = sec; - tv.tv_usec = 0; for (;;) { + tv.tv_sec = sec; + tv.tv_usec = 0; switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) { - case 0: /* timeout */ - bsock->b_errno = 0; - return 0; + case 0: /* timeout */ + bsock->b_errno = 0; + return 0; case -1: - bsock->b_errno = errno; - if (errno == EINTR || errno == EAGAIN) { - continue; - } - return -1; /* error return */ + bsock->b_errno = errno; + if (errno == EINTR) { + continue; + } + return -1; /* error return */ default: - bsock->b_errno = 0; - return 1; + bsock->b_errno = 0; + return 1; } } } @@ -496,38 +504,36 @@ int bnet_wait_data_intr(BSOCK * bsock, int sec) FD_SET((unsigned)bsock->fd, &fdset); tv.tv_sec = sec; tv.tv_usec = 0; - for (;;) { - switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) { - case 0: /* timeout */ - bsock->b_errno = 0; - return 0; - case -1: - bsock->b_errno = errno; - return -1; /* error return */ - default: - bsock->b_errno = 0; - return 1; - } + switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) { + case 0: /* timeout */ + bsock->b_errno = 0; + return 0; + case -1: + bsock->b_errno = errno; + return -1; /* error return */ + default: + bsock->b_errno = 0; } + return 1; } #ifndef NETDB_INTERNAL -#define NETDB_INTERNAL -1 /* See errno. */ +#define NETDB_INTERNAL -1 /* See errno. */ #endif #ifndef NETDB_SUCCESS -#define NETDB_SUCCESS 0 /* No problem. */ +#define NETDB_SUCCESS 0 /* No problem. */ #endif #ifndef HOST_NOT_FOUND -#define HOST_NOT_FOUND 1 /* Authoritative Answer Host not found. */ +#define HOST_NOT_FOUND 1 /* Authoritative Answer Host not found. */ #endif #ifndef TRY_AGAIN -#define TRY_AGAIN 2 /* Non-Authoritative Host not found, or SERVERFAIL. */ +#define TRY_AGAIN 2 /* Non-Authoritative Host not found, or SERVERFAIL. */ #endif #ifndef NO_RECOVERY -#define NO_RECOVERY 3 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */ +#define NO_RECOVERY 3 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP. */ #endif #ifndef NO_DATA -#define NO_DATA 4 /* Valid name, no data record of requested type. */ +#define NO_DATA 4 /* Valid name, no data record of requested type. */ #endif /* @@ -536,33 +542,33 @@ int bnet_wait_data_intr(BSOCK * bsock, int sec) static const char *gethost_strerror() { const char *msg; + berrno be; switch (h_errno) { case NETDB_INTERNAL: - msg = strerror(errno); + msg = be.strerror(); break; case NETDB_SUCCESS: - msg = "No problem."; + msg = _("No problem."); break; case HOST_NOT_FOUND: - msg = "Authoritative answer for host not found."; + msg = _("Authoritative answer for host not found."); break; case TRY_AGAIN: - msg = "Non-authoritative for host not found, or ServerFail."; + msg = _("Non-authoritative for host not found, or ServerFail."); break; case NO_RECOVERY: - msg = "Non-recoverable errors, FORMERR, REFUSED, or NOTIMP."; + msg = _("Non-recoverable errors, FORMERR, REFUSED, or NOTIMP."); break; case NO_DATA: - msg = "Valid name, no data record of resquested type."; + msg = _("Valid name, no data record of resquested type."); break; default: - msg = "Unknown error."; + msg = _("Unknown error."); } return msg; } -static pthread_mutex_t ip_mutex = PTHREAD_MUTEX_INITIALIZER; static IPADDR *add_any(int family) @@ -578,7 +584,7 @@ static const char *resolv_host(int family, const char *host, dlist * addr_list) struct hostent *hp; const char *errmsg; - P(ip_mutex); + P(ip_mutex); /* gethostbyname() is not thread safe */ #ifdef HAVE_GETHOSTBYNAME2 if ((hp = gethostbyname2(host, family)) == NULL) { #else @@ -591,17 +597,17 @@ static const char *resolv_host(int family, const char *host, dlist * addr_list) } else { char **p; for (p = hp->h_addr_list; *p != 0; p++) { - IPADDR *addr = New(IPADDR(hp->h_addrtype)); - addr->set_type(IPADDR::R_MULTIPLE); - if (addr->get_family() == AF_INET) { - addr->set_addr4((struct in_addr*)*p); - } + IPADDR *addr = New(IPADDR(hp->h_addrtype)); + addr->set_type(IPADDR::R_MULTIPLE); + if (addr->get_family() == AF_INET) { + addr->set_addr4((struct in_addr*)*p); + } #ifdef HAVE_IPV6 - else { - addr->set_addr6((struct in6_addr*)*p); - } + else { + addr->set_addr6((struct in6_addr*)*p); + } #endif - addr_list->append(addr); + addr_list->append(addr); } V(ip_mutex); } @@ -623,11 +629,11 @@ dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr) dlist *addr_list = New(dlist(addr, &addr->link)); if (!host || host[0] == '\0') { if (family != 0) { - addr_list->append(add_any(family)); + addr_list->append(add_any(family)); } else { - addr_list->append(add_any(AF_INET)); + addr_list->append(add_any(AF_INET)); #ifdef HAVE_IPV6 - addr_list->append(add_any(AF_INET6)); + addr_list->append(add_any(AF_INET6)); #endif } } else if (inet_aton(host, &inaddr)) { /* MA Bug 4 */ @@ -646,24 +652,24 @@ dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr) #endif { if (family != 0) { - errmsg = resolv_host(family, host, addr_list); - if (errmsg) { - *errstr = errmsg; - free_addresses(addr_list); - return 0; - } + errmsg = resolv_host(family, host, addr_list); + if (errmsg) { + *errstr = errmsg; + free_addresses(addr_list); + return 0; + } } else { - errmsg = resolv_host(AF_INET, host, addr_list); + errmsg = resolv_host(AF_INET, host, addr_list); #ifdef HAVE_IPV6 - if (errmsg) { - errmsg = resolv_host(AF_INET6, host, addr_list); - } + if (errmsg) { + errmsg = resolv_host(AF_INET6, host, addr_list); + } #endif - if (errmsg) { - *errstr = errmsg; - free_addresses(addr_list); - return 0; - } + if (errmsg) { + *errstr = errmsg; + free_addresses(addr_list); + return 0; + } } } return addr_list; @@ -676,7 +682,7 @@ dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr) * */ static BSOCK *bnet_open(JCR * jcr, const char *name, char *host, char *service, - int port, int *fatal) + int port, int *fatal) { int sockfd = -1; dlist *addr_list; @@ -692,10 +698,10 @@ static BSOCK *bnet_open(JCR * jcr, const char *name, char *host, char *service, */ if ((addr_list = bnet_host2ipaddrs(host, 0, &errstr)) == NULL) { /* Note errstr is not malloc'ed */ - Qmsg2(jcr, M_ERROR, 0, "gethostbyname() for host \"%s\" failed: ERR=%s\n", - host, errstr); + Qmsg2(jcr, M_ERROR, 0, _("gethostbyname() for host \"%s\" failed: ERR=%s\n"), + host, errstr); Dmsg2(100, "bnet_host2ipaddrs() for host %s failed: ERR=%s\n", - host, errstr); + host, errstr); *fatal = 1; return NULL; } @@ -705,30 +711,30 @@ static BSOCK *bnet_open(JCR * jcr, const char *name, char *host, char *service, char allbuf[256 * 10]; char curbuf[256]; Dmsg2(100, "Current %sAll %s\n", - ipaddr->build_address_str(curbuf, sizeof(curbuf)), - build_addresses_str(addr_list, allbuf, sizeof(allbuf))); + ipaddr->build_address_str(curbuf, sizeof(curbuf)), + build_addresses_str(addr_list, allbuf, sizeof(allbuf))); /* Open a TCP socket */ if ((sockfd = socket(ipaddr->get_family(), SOCK_STREAM, 0)) < 0) { - berrno be; - save_errno = errno; - *fatal = 1; - Pmsg3(000, "Socket open error. proto=%d port=%d. ERR=%s\n", - ipaddr->get_family(), ipaddr->get_port_host_order(), be.strerror()); - continue; + berrno be; + save_errno = errno; + *fatal = 1; + Pmsg3(000, _("Socket open error. proto=%d port=%d. ERR=%s\n"), + ipaddr->get_family(), ipaddr->get_port_host_order(), be.strerror()); + continue; } /* * Keep socket from timing out from inactivity */ if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) { - berrno be; - Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"), - be.strerror()); + berrno be; + Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"), + be.strerror()); } /* connect to server */ if (connect(sockfd, ipaddr->get_sockaddr(), ipaddr->get_sockaddr_len()) < 0) { - save_errno = errno; - close(sockfd); - continue; + save_errno = errno; + socketClose(sockfd); + continue; } *fatal = 0; connected = true; @@ -736,18 +742,18 @@ static BSOCK *bnet_open(JCR * jcr, const char *name, char *host, char *service, } if (!connected) { - free_addresses(addr_list); + free_addresses(addr_list); errno = save_errno; return NULL; } /* * Keep socket from timing out from inactivity - * Do this a second time out of paranoia + * Do this a second time out of paranoia */ if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) { berrno be; Qmsg1(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"), - be.strerror()); + be.strerror()); } BSOCK* ret = init_bsock(jcr, sockfd, name, host, port, ipaddr->get_sockaddr()); free_addresses(addr_list); @@ -757,34 +763,37 @@ static BSOCK *bnet_open(JCR * jcr, const char *name, char *host, char *service, /* * Try to connect to host for max_retry_time at retry_time intervals. */ -BSOCK *bnet_connect(JCR * jcr, int retry_interval, int max_retry_time, - const char *name, char *host, char *service, int port, - int verbose) +BSOCK *bnet_connect(JCR * jcr, int retry_interval, utime_t max_retry_time, + const char *name, char *host, char *service, int port, + int verbose) { int i; BSOCK *bsock; int fatal = 0; + time_t begin_time = time(NULL); + time_t now; for (i = 0; (bsock = bnet_open(jcr, name, host, service, port, &fatal)) == NULL; - i -= retry_interval) { + i -= retry_interval) { berrno be; if (fatal || (jcr && job_canceled(jcr))) { - return NULL; + return NULL; } Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n", - name, host, port, be.strerror()); + name, host, port, be.strerror()); if (i < 0) { - i = 60 * 5; /* complain again in 5 minutes */ - if (verbose) - Qmsg4(jcr, M_WARNING, 0, "Could not connect to %s on %s:%d. ERR=%s\n" -"Retrying ...\n", name, host, port, be.strerror()); + i = 60 * 5; /* complain again in 5 minutes */ + if (verbose) + Qmsg4(jcr, M_WARNING, 0, _( + "Could not connect to %s on %s:%d. ERR=%s\n" + "Retrying ...\n"), name, host, port, be.strerror()); } bmicrosleep(retry_interval, 0); - max_retry_time -= retry_interval; - if (max_retry_time <= 0) { - Qmsg4(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"), - name, host, port, be.strerror()); - return NULL; + now = time(NULL); + if (begin_time + max_retry_time <= now) { + Qmsg4(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"), + name, host, port, be.strerror()); + return NULL; } } return bsock; @@ -808,7 +817,7 @@ const char *bnet_strerror(BSOCK * bsock) /* * Format and send a message * Returns: false on error - * true on success + * true on success */ bool bnet_fsend(BSOCK * bs, const char *fmt, ...) { @@ -829,19 +838,35 @@ bool bnet_fsend(BSOCK * bs, const char *fmt, ...) bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr); va_end(arg_ptr); if (bs->msglen > 0 && bs->msglen < (maxlen - 5)) { - break; + break; } bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2); } - return bnet_send(bs); + return bs->send(); +// return bnet_send(bs); } +int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen) { +#if !defined(HAVE_WIN32) + if (bs->peer_addr.sin_family == 0) { + socklen_t salen = sizeof(bs->peer_addr); + int rval = (getpeername)(bs->fd, (struct sockaddr *)&bs->peer_addr, &salen); + if (rval < 0) return rval; + } + if (!inet_ntop(bs->peer_addr.sin_family, &bs->peer_addr.sin_addr, buf, buflen)) + return -1; + + return 0; +#else + return -1; +#endif +} /* * Set the network buffer size, suggested size is in size. * Actual size obtained is returned in bs->msglen * * Returns: 0 on failure - * 1 on success + * 1 on success */ bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw) { @@ -860,25 +885,25 @@ bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw) } start_size = dbuf_size; if ((bs->msg = realloc_pool_memory(bs->msg, dbuf_size + 100)) == NULL) { - Qmsg0(bs->jcr, M_FATAL, 0, _("Could not malloc BSOCK data buffer\n")); + Qmsg0(bs->jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n")); return false; } if (rw & BNET_SETBUF_READ) { while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET, - SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) { - berrno be; - Qmsg1(bs->jcr, M_ERROR, 0, _("sockopt error: %s\n"), be.strerror()); - dbuf_size -= TAPE_BSIZE; + SO_RCVBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) { + berrno be; + Qmsg1(bs->jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.strerror()); + dbuf_size -= TAPE_BSIZE; } Dmsg1(200, "set network buffer size=%d\n", dbuf_size); if (dbuf_size != start_size) { - Qmsg1(bs->jcr, M_WARNING, 0, - _("Warning network buffer = %d bytes not max size.\n"), dbuf_size); + Qmsg1(bs->jcr(), M_WARNING, 0, + _("Warning network buffer = %d bytes not max size.\n"), dbuf_size); } if (dbuf_size % TAPE_BSIZE != 0) { - Qmsg1(bs->jcr, M_ABORT, 0, - _("Network buffer size %d not multiple of tape block size.\n"), - dbuf_size); + Qmsg1(bs->jcr(), M_ABORT, 0, + _("Network buffer size %d not multiple of tape block size.\n"), + dbuf_size); } } if (size != 0) { @@ -889,20 +914,20 @@ bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw) start_size = dbuf_size; if (rw & BNET_SETBUF_WRITE) { while ((dbuf_size > TAPE_BSIZE) && (setsockopt(bs->fd, SOL_SOCKET, - SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) { - berrno be; - Qmsg1(bs->jcr, M_ERROR, 0, _("sockopt error: %s\n"), be.strerror()); - dbuf_size -= TAPE_BSIZE; + SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) { + berrno be; + Qmsg1(bs->jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.strerror()); + dbuf_size -= TAPE_BSIZE; } - Dmsg1(200, "set network buffer size=%d\n", dbuf_size); + Dmsg1(900, "set network buffer size=%d\n", dbuf_size); if (dbuf_size != start_size) { - Qmsg1(bs->jcr, M_WARNING, 0, - _("Warning network buffer = %d bytes not max size.\n"), dbuf_size); + Qmsg1(bs->jcr(), M_WARNING, 0, + _("Warning network buffer = %d bytes not max size.\n"), dbuf_size); } if (dbuf_size % TAPE_BSIZE != 0) { - Qmsg1(bs->jcr, M_ABORT, 0, - _("Network buffer size %d not multiple of tape block size.\n"), - dbuf_size); + Qmsg1(bs->jcr(), M_ABORT, 0, + _("Network buffer size %d not multiple of tape block size.\n"), + dbuf_size); } } @@ -910,17 +935,105 @@ bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw) return true; } +/* + * Set socket non-blocking + * Returns previous socket flag + */ +int bnet_set_nonblocking (BSOCK *bsock) { +#ifndef HAVE_WIN32 + int oflags; + + /* Get current flags */ + if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) { + berrno be; + Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror()); + } + + /* Set O_NONBLOCK flag */ + if ((fcntl(bsock->fd, F_SETFL, oflags|O_NONBLOCK)) < 0) { + berrno be; + Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror()); + } + + bsock->blocking = 0; + return oflags; +#else + int flags; + u_long ioctlArg = 1; + + flags = bsock->blocking; + ioctlsocket(bsock->fd, FIONBIO, &ioctlArg); + bsock->blocking = 0; + + return flags; +#endif +} + +/* + * Set socket blocking + * Returns previous socket flags + */ +int bnet_set_blocking (BSOCK *bsock) +{ +#ifndef HAVE_WIN32 + int oflags; + /* Get current flags */ + if ((oflags = fcntl(bsock->fd, F_GETFL, 0)) < 0) { + berrno be; + Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_GETFL error. ERR=%s\n"), be.strerror()); + } + + /* Set O_NONBLOCK flag */ + if ((fcntl(bsock->fd, F_SETFL, oflags & ~O_NONBLOCK)) < 0) { + berrno be; + Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror()); + } + + bsock->blocking = 1; + return oflags; +#else + int flags; + u_long ioctlArg = 0; + + flags = bsock->blocking; + ioctlsocket(bsock->fd, FIONBIO, &ioctlArg); + bsock->blocking = 1; + + return flags; +#endif +} + +/* + * Restores socket flags + */ +void bnet_restore_blocking (BSOCK *bsock, int flags) +{ +#ifndef HAVE_WIN32 + if ((fcntl(bsock->fd, F_SETFL, flags)) < 0) { + berrno be; + Jmsg1(bsock->jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.strerror()); + } + + bsock->blocking = (flags & O_NONBLOCK); +#else + u_long ioctlArg = flags; + + ioctlsocket(bsock->fd, FIONBIO, &ioctlArg); + bsock->blocking = 1; +#endif +} + + /* * Send a network "signal" to the other end * This consists of sending a negative packet length * * Returns: false on failure - * true on success + * true on success */ -bool bnet_sig(BSOCK * bs, int sig) +bool bnet_sig(BSOCK * bs, int signal) { - bs->msglen = sig; - return bnet_send(bs); + return bs->signal(signal); } /* @@ -948,7 +1061,7 @@ const char *bnet_sig_to_ascii(BSOCK * bs) case BNET_PROMPT: return "BNET_PROMPT"; default: - sprintf(buf, "Unknown sig %d", bs->msglen); + sprintf(buf, _("Unknown sig %d"), (int)bs->msglen); return buf; } } @@ -958,39 +1071,42 @@ const char *bnet_sig_to_ascii(BSOCK * bs) * This probably should be done in net_open */ BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port, - struct sockaddr *client_addr) + struct sockaddr *client_addr) { Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port); BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK)); memset(bsock, 0, sizeof(BSOCK)); bsock->fd = sockfd; + bsock->tls = NULL; bsock->errors = 0; + bsock->blocking = 1; bsock->msg = get_pool_memory(PM_MESSAGE); bsock->errmsg = get_pool_memory(PM_MESSAGE); - bsock->who = bstrdup(who); - bsock->host = bstrdup(host); - bsock->port = port; + bsock->set_who(bstrdup(who)); + bsock->set_host(bstrdup(host)); + bsock->set_port(port); + memset(&bsock->peer_addr, 0, sizeof(bsock->peer_addr)); memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr)); /* * ****FIXME**** reduce this to a few hours once - * heartbeats are implemented + * heartbeats are implemented */ - bsock->timeout = 60 * 60 * 6 * 24; /* 6 days timeout */ - bsock->jcr = jcr; + bsock->timeout = 60 * 60 * 6 * 24; /* 6 days timeout */ + bsock->set_jcr(jcr); return bsock; } BSOCK *dup_bsock(BSOCK * osock) { - BSOCK *bsock = (BSOCK *) malloc(sizeof(BSOCK)); + BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK)); memcpy(bsock, osock, sizeof(BSOCK)); bsock->msg = get_pool_memory(PM_MESSAGE); bsock->errmsg = get_pool_memory(PM_MESSAGE); - if (osock->who) { - bsock->who = bstrdup(osock->who); + if (osock->who()) { + bsock->set_who(bstrdup(osock->who())); } - if (osock->host) { - bsock->host = bstrdup(osock->host); + if (osock->host()) { + bsock->set_host(bstrdup(osock->host())); } bsock->duped = true; return bsock; @@ -999,40 +1115,10 @@ BSOCK *dup_bsock(BSOCK * osock) /* Close the network connection */ void bnet_close(BSOCK * bsock) { - BSOCK *next; - - for (; bsock != NULL; bsock = next) { - next = bsock->next; - if (!bsock->duped) { - if (bsock->timed_out) { - shutdown(bsock->fd, 2); /* discard any pending I/O */ - } - socketClose(bsock->fd); /* normal close */ - } - term_bsock(bsock); - } - return; + bsock->close(); /* this calls destroy */ } void term_bsock(BSOCK * bsock) { - if (bsock->msg) { - free_pool_memory(bsock->msg); - bsock->msg = NULL; - } else { - ASSERT(1 == 0); /* double close */ - } - if (bsock->errmsg) { - free_pool_memory(bsock->errmsg); - bsock->errmsg = NULL; - } - if (bsock->who) { - free(bsock->who); - bsock->who = NULL; - } - if (bsock->host) { - free(bsock->host); - bsock->host = NULL; - } - free(bsock); + bsock->destroy(); }