/*
Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
- This program is free software; you can redistribute it and/or
- modify it under the terms of the GNU General Public License as
- published by the Free Software Foundation; either version 2 of
- the License, or (at your option) any later version.
+ 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 program is distributed in the hope that it will be useful,
+ 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
- General Public License for more details.
+ 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 General Public
- License along with this program; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ 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"
+#include "jcr.h"
extern time_t watchdog_time;
#endif
+
+
/*
* Read a nbytes from the network.
* It is possible that the total bytes require in several
do {
errno = 0;
nread = read(bsock->fd, ptr, nleft);
- } while (!bsock->timed_out && nread == -1 && (errno == EINTR || errno == EAGAIN));
+ if (bsock->timed_out || bsock->terminated) {
+ return nread;
+ }
+ } while (nread == -1 && (errno == EINTR || errno == EAGAIN));
if (nread <= 0) {
return nread; /* error, or EOF */
}
do {
errno = 0;
nwritten = write(bsock->fd, ptr, nleft);
- } while (!bsock->timed_out && nwritten == -1 && (errno == EINTR || errno == EAGAIN));
+ if (bsock->timed_out || bsock->terminated) {
+ return nwritten;
+ }
+ } while (nwritten == -1 && errno == EINTR);
+ /*
+ * If connection is non-blocking, we will get EAGAIN, so
+ * use select() to keep from consuming all the CPU
+ * and try again.
+ */
+ if (nwritten == -1 && errno == EAGAIN) {
+ fd_set fdset;
+ struct timeval tv;
+
+ FD_ZERO(&fdset);
+ FD_SET(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 */
}
* Receive a message from the other end. Each message consists of
* two packets. The first is a header that contains the size
* of the data that follows in the second packet.
- * Returns number of bytes read
- * Returns 0 on end of file
- * Returns -1 on hard end of file (i.e. network connection close)
- * Returns -2 on error
+ * 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)
+ *
+ * Unfortunately, it is a bit complicated because we have these
+ * four return types:
+ * 1. Normal data
+ * 2. Signal including end of data stream
+ * 3. Hard end of file
+ * 4. Error
+ * Using is_bnet_stop() and is_bnet_error() you can figure this all out.
*/
-/* EXTPROTO */
-int32_t
-bnet_recv(BSOCK *bsock)
+int32_t bnet_recv(BSOCK *bsock)
{
int32_t nbytes;
int32_t pktsiz;
+ ASSERT(bsock != NULL);
+ mp_chr(bsock->msg)[0] = 0;
if (bsock->errors || bsock->terminated) {
- return -2;
+ return BNET_HARDEOF;
}
bsock->read_seqno++; /* bump sequence number */
bsock->b_errno = errno;
}
bsock->errors++;
- return -1; /* assume hard EOF received */
+ return BNET_HARDEOF; /* assume hard EOF received */
}
bsock->timer_start = 0; /* clear timer */
if (nbytes != sizeof(int32_t)) {
bsock->errors++;
bsock->b_errno = EIO;
- Jmsg3(bsock->jcr, M_ERROR, 0, _("Read %d expected %d from %s\n"), nbytes, sizeof(int32_t),
- bsock->who);
- return -2;
+ Jmsg5(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;
}
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 > 10000000) {
+ if (pktsiz < 0 || pktsiz > 1000000) {
+ if (pktsiz > 0) { /* if packet too big */
+ Jmsg3(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; /* return size */
- return 0; /* soft EOF */
+ bsock->msglen = pktsiz; /* signal code */
+ return BNET_SIGNAL; /* signal */
}
/* Make sure the buffer is big enough + one byte for EOS */
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) {
+ if ((nbytes = read_nbytes(bsock, mp_chr(bsock->msg), pktsiz)) <= 0) {
bsock->timer_start = 0; /* clear timer */
if (errno == 0) {
bsock->b_errno = ENODATA;
bsock->errors++;
Jmsg4(bsock->jcr, M_ERROR, 0, _("Read error from %s:%s:%d: ERR=%s\n"),
bsock->who, bsock->host, bsock->port, bnet_strerror(bsock));
- return -2;
+ return BNET_ERROR;
}
bsock->timer_start = 0; /* clear timer */
bsock->in_msg_no++;
bsock->errors++;
Jmsg5(bsock->jcr, M_ERROR, 0, _("Read expected %d got %d from %s:%s:%d\n"), pktsiz, nbytes,
bsock->who, bsock->host, bsock->port);
- return -2;
+ 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 */
+ mp_chr(bsock->msg)[nbytes] = 0; /* terminate in case it is a string */
sm_check(__FILE__, __LINE__, False);
return nbytes; /* return actual length of message */
}
+
+/*
+ * Return 1 if there are errors on this bsock or it is closed,
+ * i.e. stop communicating on this line.
+ */
+int is_bnet_stop(BSOCK *bsock)
+{
+ return bsock->errors || bsock->terminated;
+}
+
+/*
+ * Return number of errors on socket
+ */
+int is_bnet_error(BSOCK *bsock)
+{
+ return bsock->errors;
+}
+
+/*
+ * Call here after error during closing to suppress error
+ * messages which are due to the other end shutting down too.
+ */
+void
+bnet_suppress_error_messages(BSOCK *bsock, int flag)
+{
+ bsock->suppress_error_msgs = flag;
+}
+
+
+/*
+ * Transmit spooled data now
+ */
int bnet_despool(BSOCK *bsock)
{
int32_t pktsiz;
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);
+ 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) {
return 1;
}
+
/*
* Send a message over the network. The send consists of
* two network packets. The first is sends a 32 bit integer containing
{
int32_t rc;
int32_t pktsiz;
+ int32_t msglen;
if (bsock->errors || bsock->terminated) {
return 0;
}
+ msglen = bsock->msglen;
+ ASSERT(bsock->msglen < 1000000);
pktsiz = htonl((int32_t)bsock->msglen);
/* send int32_t containing size of data packet */
bsock->timer_start = watchdog_time; /* start timer */
rc = write_nbytes(bsock, (char *)&pktsiz, sizeof(int32_t));
bsock->timer_start = 0; /* clear timer */
if (rc != sizeof(int32_t)) {
+ if (bsock->msglen == BNET_TERMINATE) { /* if we were terminating */
+ bsock->terminated = 1;
+ return 0; /* ignore any errors */
+ }
bsock->errors++;
if (errno == 0) {
bsock->b_errno = EIO;
bsock->b_errno = errno;
}
if (rc < 0) {
- Jmsg4(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) {
+ Jmsg4(bsock->jcr, M_ERROR, 0, _("Write error sending to %s:%s:%d: ERR=%s\n"),
+ bsock->who, bsock->host, bsock->port, bnet_strerror(bsock));
+ }
} else {
Jmsg5(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);
bsock->out_msg_no++; /* increment message number */
if (bsock->msglen <= 0) { /* length only? */
+ ASSERT(msglen == bsock->msglen);
return 1; /* yes, no data */
}
/* send data packet */
bsock->timer_start = watchdog_time; /* start timer */
bsock->timed_out = 0;
- rc = write_nbytes(bsock, bsock->msg, bsock->msglen);
+ rc = write_nbytes(bsock, mp_chr(bsock->msg), bsock->msglen);
bsock->timer_start = 0; /* clear timer */
if (rc != bsock->msglen) {
bsock->errors++;
bsock->b_errno = errno;
}
if (rc < 0) {
- /************FIXME********* use Pmsg() **/
- Jmsg4(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) {
+ Jmsg4(bsock->jcr, M_ERROR, 0, _("Write error sending to %s:%s:%d: ERR=%s\n"),
+ bsock->who, bsock->host, bsock->port, bnet_strerror(bsock));
+ }
} else {
Jmsg5(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);
+ bsock->msglen, bsock->who, bsock->host, bsock->port, rc);
}
return 0;
}
+ ASSERT(msglen == bsock->msglen);
return 1;
}
+/*
+ * 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
+ */
+int
+bnet_ssl_server(BSOCK *bsock, char *password, int ssl_need, int ssl_has)
+{
+ /* 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;
+}
+
+/*
+ * Establish an SSL connection -- client side
+ */
+int bnet_ssl_client(BSOCK *bsock, char *password, int ssl_need)
+{
+ /* We are the client so we must wait for the server to notify us */
+ return 1;
+}
+
+
/*
* Wait for a specified time for data to appear on
* the BSOCK connection.
* -1 if error
*/
int
-bnet_wait_data(BSOCK *bsock, int sec)
+bnet_wait_data(BSOCK *bsock, int sec)
{
fd_set fdset;
struct timeval tv;
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;
- if (errno == EINTR || errno == EAGAIN) {
- continue;
- }
- return -1; /* error return */
- default:
- bsock->b_errno = 0;
- return 1;
+ 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 */
+ default:
+ bsock->b_errno = 0;
+ return 1;
}
}
}
+/*
+ * As above, but returns on interrupt
+ */
+int
+bnet_wait_data_intr(BSOCK *bsock, int sec)
+{
+ fd_set fdset;
+ struct timeval tv;
+
+ FD_ZERO(&fdset);
+ FD_SET(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;
+ }
+ }
+}
+
+#ifndef NETDB_INTERNAL
+#define NETDB_INTERNAL -1 /* See errno. */
+#endif
+#ifndef NETDB_SUCCESS
+#define NETDB_SUCCESS 0 /* No problem. */
+#endif
+#ifndef 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. */
+#endif
+#ifndef NO_RECOVERY
+#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. */
+#endif
+
+extern int h_errno; /* On error has one of the above */
+
+/*
+ * Get human readable error for gethostbyname()
+ */
+static char *gethost_strerror()
+{
+ switch (h_errno) {
+ case NETDB_INTERNAL:
+ return strerror(errno);
+ case NETDB_SUCCESS:
+ return "No problem.";
+ case HOST_NOT_FOUND:
+ return "Authoritative answer Host not found.";
+ case TRY_AGAIN:
+ return "Non-authoritative Host not found, or ServerFail.";
+ case NO_RECOVERY:
+ return "Non-recoverable errors, FORMERR, REFUSED, or NOTIMP.";
+ case NO_DATA:
+ return "Valid name, no data record of resquested type.";
+ default:
+ return "Unknown error.";
+ }
+}
+
+
+static pthread_mutex_t ip_mutex = PTHREAD_MUTEX_INITIALIZER;
+
/*
* Convert a hostname or dotted IP address into
* a s_addr. We handle only IPv4.
*/
-static uint32_t *bget_host_ip(void *jcr, char *host)
+static uint32_t *bget_host_ip(JCR *jcr, char *host)
{
struct in_addr inaddr;
uint32_t *addr_list; /* this really should be struct in_addr */
addr_list[0] = inaddr.s_addr;
addr_list[1] = (uint32_t) -1;
} else {
- /******FIXME***** use gethostbyname_r or mutex ****/
+ P(ip_mutex);
if ((hp = gethostbyname(host)) == NULL) {
- Pmsg2(0, "gethostbyname() for %s failed: ERR=%s\n", host, strerror(errno));
+ Jmsg2(jcr, M_ERROR, 0, "gethostbyname() for %s failed: ERR=%s\n",
+ host, gethost_strerror());
+ V(ip_mutex);
return NULL;
}
if (hp->h_length != sizeof(inaddr.s_addr) || hp->h_addrtype != AF_INET) {
- Jmsg2(jcr, M_WARNING, 0, _("gethostbyname() network address length error.\n\
+ Jmsg2(jcr, M_ERROR, 0, _("gethostbyname() network address length error.\n\
Wanted %d got %d bytes for s_addr.\n"), sizeof(inaddr.s_addr), hp->h_length);
- return NULL;
+ V(ip_mutex);
+ return NULL;
}
i = 0;
for (p = hp->h_addr_list; *p != 0; p++) {
i++;
}
i++;
- addr_list = (uint32_t *) malloc(sizeof(uint32_t) * i);
+ addr_list = (uint32_t *)malloc(sizeof(uint32_t) * i);
i = 0;
for (p = hp->h_addr_list; *p != 0; p++) {
addr_list[i++] = (*(struct in_addr **)p)->s_addr;
}
addr_list[i] = (uint32_t) -1;
+ V(ip_mutex);
}
return addr_list;
}
* ***FIXME*** implement service from /etc/services
*/
static BSOCK *
-bnet_open(void *jcr, char *name, char *host, char *service, int port)
+bnet_open(JCR *jcr, char *name, char *host, char *service, int port, int *fatal)
{
int sockfd;
struct sockaddr_in tcp_serv_addr; /* socket information */
tcp_serv_addr.sin_port = htons(port);
if ((addr_list=bget_host_ip(jcr, host)) == NULL) {
+ *fatal = 1;
return NULL;
}
/* Open a TCP socket */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
free(addr_list);
+ *fatal = 1;
return NULL;
}
/*
* Receive notification when connection dies.
*/
- if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &turnon, sizeof(turnon)) < 0) {
+ if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
Jmsg(jcr, M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"), strerror(errno));
}
* Try to connect to host for max_retry_time at retry_time intervals.
*/
BSOCK *
-bnet_connect(void *jcr, int retry_interval, int max_retry_time, char *name,
+bnet_connect(JCR *jcr, int retry_interval, int max_retry_time, char *name,
char *host, char *service, int port, int verbose)
{
int i;
BSOCK *bsock;
+ int fatal = 0;
- for (i=0; (bsock = bnet_open(jcr, name, host, service, port)) == NULL; i -= retry_interval) {
+ for (i=0; (bsock = bnet_open(jcr, name, host, service, port, &fatal)) == NULL; i -= retry_interval) {
+ if (fatal || (jcr && job_canceled(jcr))) {
+ return NULL;
+ }
Dmsg4(100, "Unable to connect to %s on %s:%d. ERR=%s\n",
name, host, port, strerror(errno));
- if (i <= 0) {
+ if (i < 0) {
i = 60 * 5; /* complain again in 5 minutes */
if (verbose)
Jmsg(jcr, M_WARNING, 0, "Could not connect to %s on %s:%d. ERR=%s\n\
Retrying ...\n", name, host, port, strerror(errno));
}
- sleep(retry_interval);
+ bmicrosleep(retry_interval, 0);
max_retry_time -= retry_interval;
if (max_retry_time <= 0) {
Jmsg(jcr, M_FATAL, 0, _("Unable to connect to %s on %s:%d. ERR=%s\n"),
*/
char *bnet_strerror(BSOCK *bsock)
{
- /* ***FIXME*** not thread safe */
return strerror(bsock->b_errno);
}
va_list arg_ptr;
int maxlen;
+ if (bs->errors || bs->terminated) {
+ return 0;
+ }
/* This probably won't work, but we vsnprintf, then if we
* get a negative length or a length greater than our buffer
* (depending on which library is used), the printf was truncated, so
again:
maxlen = sizeof_pool_memory(bs->msg) - 1;
va_start(arg_ptr, fmt);
- bs->msglen = bvsnprintf(bs->msg, maxlen, fmt, arg_ptr);
+ bs->msglen = bvsnprintf(mp_chr(bs->msg), maxlen, fmt, arg_ptr);
va_end(arg_ptr);
if (bs->msglen < 0 || bs->msglen >= maxlen) {
- bs->msg = realloc_pool_memory(bs->msg, maxlen + 200);
+ bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2);
goto again;
}
- return bnet_send(bs) < 0 ? 0 : 1;
+ return bnet_send(bs);
}
/*
int opt;
opt = IPTOS_THROUGHPUT;
- setsockopt(bs->fd, IPPROTO_IP, IP_TOS, (char *)&opt, sizeof(opt));
+ setsockopt(bs->fd, IPPROTO_IP, IP_TOS, (sockopt_val_t)&opt, sizeof(opt));
#endif
dbuf_size = size;
if ((bs->msg = realloc_pool_memory(bs->msg, dbuf_size+100)) == NULL) {
- Jmsg0(bs->jcr, M_FATAL, 0, _("Could not malloc 32K BSOCK data buffer\n"));
+ Jmsg0(bs->jcr, M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
return 0;
}
if (rw & BNET_SETBUF_READ) {
while ((dbuf_size > TAPE_BSIZE) &&
- (setsockopt(bs->fd, SOL_SOCKET, SO_RCVBUF, (char *)&dbuf_size, sizeof(dbuf_size)) < 0)) {
+ (setsockopt(bs->fd, SOL_SOCKET, SO_RCVBUF, (sockopt_val_t)&dbuf_size, sizeof(dbuf_size)) < 0)) {
Jmsg1(bs->jcr, M_ERROR, 0, _("sockopt error: %s\n"), strerror(errno));
dbuf_size -= TAPE_BSIZE;
}
dbuf_size = size;
if (rw & BNET_SETBUF_WRITE) {
while ((dbuf_size > TAPE_BSIZE) &&
- (setsockopt(bs->fd, SOL_SOCKET, SO_SNDBUF, (char *)&dbuf_size, sizeof(dbuf_size)) < 0)) {
+ (setsockopt(bs->fd, SOL_SOCKET, SO_SNDBUF, (sockopt_val_t)&dbuf_size, sizeof(dbuf_size)) < 0)) {
Jmsg1(bs->jcr, M_ERROR, 0, _("sockopt error: %s\n"), strerror(errno));
dbuf_size -= TAPE_BSIZE;
}
{
static char buf[30];
switch (bs->msglen) {
- case BNET_NONO: /* for compatibility */
case BNET_EOD:
return "BNET_EOD"; /* end of data stream */
case BNET_EOD_POLL:
* This probably should be done in net_open
*/
BSOCK *
-init_bsock(void *jcr, int sockfd, char *who, char *host, int port)
+init_bsock(JCR *jcr, int sockfd, char *who, char *host, int port)
{
BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
memset(bsock, 0, sizeof(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->host) {
+ bsock->host = bstrdup(osock->host);
+ }
bsock->duped = TRUE;
return bsock;
}
for ( ; bsock != NULL; bsock = next) {
next = bsock->next;
if (!bsock->duped) {
-// shutdown(bsock->fd, SHUT_RDWR);
- close(bsock->fd);
- term_bsock(bsock);
- } else {
- free(bsock);
+ if (bsock->timed_out) {
+ shutdown(bsock->fd, 2); /* discard any pending I/O */
+ }
+ close(bsock->fd); /* normal close */
}
+ term_bsock(bsock);
}
return;
}
void
term_bsock(BSOCK *bsock)
{
- free_pool_memory(bsock->msg);
- free_pool_memory(bsock->errmsg);
- free(bsock->who);
- free(bsock->host);
+ 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);
}
projects / bacula / bacula / blobdiff