char *msg;
for (;;) {
- n = bnet_recv(bs);
+ n = bs->recv();
Dmsg2(900, "bget_dirmsg %d: %s", n, bs->msg);
if (is_bnet_stop(bs)) {
case BNET_EOD: /* end of data */
return n;
case BNET_EOD_POLL:
- bnet_fsend(bs, OK_msg);/* send response */
+ bs->fsend(OK_msg);/* send response */
return n; /* end of data */
case BNET_TERMINATE:
- bs->terminated = 1;
+ bs->m_terminated = 1;
return n;
case BNET_POLL:
- bnet_fsend(bs, OK_msg); /* send response */
+ bs->fsend(OK_msg); /* send response */
break;
case BNET_HEARTBEAT:
// encode_time(time(NULL), Job);
break;
case BNET_STATUS:
/* *****FIXME***** Implement more completely */
- bnet_fsend(bs, "Status OK\n");
- bnet_sig(bs, BNET_EOD);
+ bs->fsend("Status OK\n");
+ bs->signal(BNET_EOD);
break;
case BNET_BTIME: /* send Bacula time */
char ed1[50];
- bnet_fsend(bs, "btime %s\n", edit_uint64(get_current_btime(),ed1));
+ bs->fsend("btime %s\n", edit_uint64(get_current_btime(),ed1));
break;
default:
Emsg1(M_WARNING, 0, _("bget_dirmsg: unknown bnet signal %d\n"), bs->msglen);
V(mutex);
if (job_canceled(jcr)) {
if (jcr->SD_msg_chan) {
- jcr->store_bsock->timed_out = 1;
- jcr->store_bsock->terminated = 1;
+ jcr->store_bsock->m_timed_out = 1;
+ jcr->store_bsock->m_terminated = 1;
Dmsg2(400, "kill jobid=%d use=%d\n", (int)jcr->JobId, jcr->use_count());
pthread_kill(jcr->SD_msg_chan, TIMEOUT_SIGNAL);
}
set_jcr_job_status(jcr, JS_Running);
- Dmsg1(300, "bfiled: opened data connection %d to stored\n", sd->fd);
+ Dmsg1(300, "bfiled: opened data connection %d to stored\n", sd->m_fd);
LockRes();
CLIENT *client = (CLIENT *)GetNextRes(R_CLIENT, NULL);
}
if (jcr->hb_bsock) {
- jcr->hb_bsock->timed_out = 1; /* set timed_out to terminate read */
- jcr->hb_bsock->terminated = 1; /* set to terminate read */
+ jcr->hb_bsock->m_timed_out = true; /* set timed_out to terminate read */
+ jcr->hb_bsock->m_terminated = true; /* set to terminate read */
}
if (jcr->hb_dir_bsock) {
- jcr->hb_dir_bsock->timed_out = 1; /* set timed_out to terminate read */
- jcr->hb_dir_bsock->terminated = 1; /* set to terminate read */
+ jcr->hb_dir_bsock->m_timed_out = true; /* set timed_out to terminate read */
+ jcr->hb_dir_bsock->m_terminated = true; /* set to terminate read */
}
Dmsg0(100, "Send kill to heartbeat id\n");
pthread_kill(jcr->heartbeat_id, TIMEOUT_SIGNAL); /* make heartbeat thread go away */
bnet_fsend(dir, _("2901 Job %s not found.\n"), Job);
} else {
if (cjcr->store_bsock) {
- cjcr->store_bsock->timed_out = 1;
- cjcr->store_bsock->terminated = 1;
+ cjcr->store_bsock->m_timed_out = 1;
+ cjcr->store_bsock->m_terminated = 1;
pthread_kill(cjcr->my_thread_id, TIMEOUT_SIGNAL);
}
set_jcr_job_status(cjcr, JS_Canceled);
found = true;
if (njcr->store_bsock) {
len = Mmsg(msg, " SDReadSeqNo=%" lld " fd=%d\n",
- njcr->store_bsock->read_seqno, njcr->store_bsock->fd);
+ njcr->store_bsock->read_seqno, njcr->store_bsock->m_fd);
sendit(msg.c_str(), len, arg);
} else {
len = Mmsg(msg, _(" SDSocket closed.\n"));
{
int n;
for ( ;; ) {
- n = bnet_recv(sock);
+ n = sock->recv();
if (n >= 0) { /* normal return */
return n;
}
return n;
case BNET_EOD_POLL:
Dmsg0(msglvl, "Got BNET_EOD_POLL\n");
- if (sock->terminated) {
- bnet_fsend(sock, TERM_msg);
+ if (sock->is_terminated()) {
+ sock->fsend(TERM_msg);
} else {
- bnet_fsend(sock, OK_msg); /* send response */
+ sock->fsend(OK_msg); /* send response */
}
return n; /* end of data */
case BNET_TERMINATE:
Dmsg0(msglvl, "Got BNET_TERMINATE\n");
- sock->terminated = 1;
+ sock->set_terminated();
return n;
case BNET_POLL:
Dmsg0(msglvl, "Got BNET_POLL\n");
- if (sock->terminated) {
- bnet_fsend(sock, TERM_msg);
+ if (sock->is_terminated()) {
+ sock->fsend(TERM_msg);
} else {
- bnet_fsend(sock, OK_msg); /* send response */
+ sock->fsend(OK_msg); /* send response */
}
break;
case BNET_HEARTBEAT:
case BNET_STATUS:
/* *****FIXME***** Implement BNET_STATUS */
Dmsg0(msglvl, "Got BNET_STATUS\n");
- bnet_fsend(sock, _("Status OK\n"));
- bnet_sig(sock, BNET_EOD);
+ sock->fsend(_("Status OK\n"));
+ sock->signal(BNET_EOD);
break;
default:
Emsg1(M_ERROR, 0, _("bget_msg: unknown signal %d\n"), sock->msglen);
nleft = nbytes;
while (nleft > 0) {
errno = 0;
- nread = socketRead(bsock->fd, ptr, nleft);
- if (bsock->timed_out || bsock->terminated) {
+ nread = socketRead(bsock->m_fd, ptr, nleft);
+ if (bsock->is_timed_out() || bsock->is_terminated()) {
return nread;
}
if (nread == -1) {
{
int32_t nleft, nwritten;
- if (bsock->spool) {
- nwritten = fwrite(ptr, 1, nbytes, bsock->spool_fd);
+ if (bsock->m_spool) {
+ nwritten = fwrite(ptr, 1, nbytes, bsock->m_spool_fd);
if (nwritten != nbytes) {
berrno be;
bsock->b_errno = errno;
while (nleft > 0) {
do {
errno = 0;
- nwritten = socketWrite(bsock->fd, ptr, nleft);
- if (bsock->timed_out || bsock->terminated) {
+ nwritten = socketWrite(bsock->m_fd, ptr, nleft);
+ if (bsock->is_timed_out() || bsock->is_terminated()) {
return nwritten;
}
} while (nwritten == -1 && errno == EINTR);
struct timeval tv;
FD_ZERO(&fdset);
- FD_SET((unsigned)bsock->fd, &fdset);
+ FD_SET((unsigned)bsock->m_fd, &fdset);
tv.tv_sec = 10;
tv.tv_usec = 0;
- select(bsock->fd + 1, NULL, &fdset, NULL, &tv);
+ select(bsock->m_fd + 1, NULL, &fdset, NULL, &tv);
continue;
}
if (nwritten <= 0) {
*/
bool is_bnet_stop(BSOCK * bsock)
{
- return bsock->errors || bsock->terminated;
+ return bsock->errors || bsock->is_terminated();
}
/*
*/
void bnet_suppress_error_messages(BSOCK * bsock, bool flag)
{
- bsock->suppress_error_msgs = flag;
+ bsock->m_suppress_error_msgs = flag;
}
/*
{
TLS_CONNECTION *tls;
- tls = new_tls_connection(ctx, bsock->fd);
+ tls = new_tls_connection(ctx, bsock->m_fd);
if (!tls) {
Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
return false;
{
TLS_CONNECTION *tls;
- tls = new_tls_connection(ctx, bsock->fd);
+ tls = new_tls_connection(ctx, bsock->m_fd);
if (!tls) {
Qmsg0(bsock->jcr(), M_FATAL, 0, _("TLS connection initialization failed.\n"));
return false;
struct timeval tv;
FD_ZERO(&fdset);
- FD_SET((unsigned)bsock->fd, &fdset);
+ FD_SET((unsigned)bsock->m_fd, &fdset);
for (;;) {
tv.tv_sec = sec;
tv.tv_usec = 0;
- switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) {
+ switch (select(bsock->m_fd + 1, &fdset, NULL, NULL, &tv)) {
case 0: /* timeout */
bsock->b_errno = 0;
return 0;
struct timeval tv;
FD_ZERO(&fdset);
- FD_SET((unsigned)bsock->fd, &fdset);
+ FD_SET((unsigned)bsock->m_fd, &fdset);
tv.tv_sec = sec;
tv.tv_usec = 0;
- switch (select(bsock->fd + 1, &fdset, NULL, NULL, &tv)) {
+ switch (select(bsock->m_fd + 1, &fdset, NULL, NULL, &tv)) {
case 0: /* timeout */
bsock->b_errno = 0;
return 0;
va_list arg_ptr;
int maxlen;
- if (bs->errors || bs->terminated) {
+ if (bs->errors || bs->is_terminated()) {
return false;
}
/* This probably won't work, but we vsnprintf, then if we
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
+ return bs->get_peer(buf, buflen);
}
+
/*
* Set the network buffer size, suggested size is in size.
* Actual size obtained is returned in bs->msglen
*/
bool bnet_set_buffer_size(BSOCK * bs, uint32_t size, int rw)
{
- uint32_t dbuf_size, start_size;
-#if defined(IP_TOS) && defined(IPTOS_THROUGHPUT)
- int opt;
- opt = IPTOS_THROUGHPUT;
- setsockopt(bs->fd, IPPROTO_IP, IP_TOS, (sockopt_val_t)&opt, sizeof(opt));
-#endif
-
- if (size != 0) {
- dbuf_size = size;
- } else {
- dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
- }
- 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"));
- 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.bstrerror());
- 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);
- }
- 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);
- }
- }
- if (size != 0) {
- dbuf_size = size;
- } else {
- dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
- }
- 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.bstrerror());
- dbuf_size -= TAPE_BSIZE;
- }
- 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);
- }
- 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);
- }
- }
-
- bs->msglen = dbuf_size;
- return true;
+ return bs->set_buffer_size(size, rw);
}
/*
* 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.bstrerror());
- }
-
- /* 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.bstrerror());
- }
-
- 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
+int bnet_set_nonblocking(BSOCK *bsock)
+{
+ return bsock->set_nonblocking();
}
/*
* Set socket blocking
* Returns previous socket flags
*/
-int bnet_set_blocking (BSOCK *bsock)
+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.bstrerror());
- }
-
- /* 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.bstrerror());
- }
-
- 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
+ return bsock->set_blocking();
}
/*
*/
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.bstrerror());
- }
-
- bsock->blocking = (flags & O_NONBLOCK);
-#else
- u_long ioctlArg = flags;
-
- ioctlsocket(bsock->fd, FIONBIO, &ioctlArg);
- bsock->blocking = 1;
-#endif
+ bsock->restore_blocking(flags);
}
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->m_fd = sockfd;
bsock->tls = NULL;
bsock->errors = 0;
- bsock->blocking = 1;
+ bsock->m_blocking = 1;
bsock->msg = get_pool_memory(PM_MESSAGE);
bsock->errmsg = get_pool_memory(PM_MESSAGE);
bsock->set_who(bstrdup(who));
if (osock->host()) {
bsock->set_host(bstrdup(osock->host()));
}
- bsock->duped = true;
+ bsock->m_duped = true;
return bsock;
}
int32_t pktsiz;
int32_t *hdr;
- if (errors || terminated || msglen > 1000000) {
+ if (errors || is_terminated() || msglen > 1000000) {
return false;
}
/* Compute total packet length */
/* send data packet */
timer_start = watchdog_time; /* start timer */
- timed_out = 0;
+ m_timed_out = 0;
/* Full I/O done in one write */
rc = write_nbytes(this, (char *)hdr, pktsiz);
timer_start = 0; /* clear timer */
b_errno = errno;
}
if (rc < 0) {
- if (!suppress_error_msgs) {
+ if (!m_suppress_error_msgs) {
Qmsg5(m_jcr, M_ERROR, 0,
_("Write error sending %d bytes to %s:%s:%d: ERR=%s\n"),
msglen, m_who,
va_list arg_ptr;
int maxlen;
- if (errors || terminated) {
+ if (errors || is_terminated()) {
return false;
}
/* This probably won't work, but we vsnprintf, then if we
msg[0] = 0;
msglen = 0;
- if (errors || terminated) {
+ if (errors || is_terminated()) {
return BNET_HARDEOF;
}
read_seqno++; /* bump sequence number */
timer_start = watchdog_time; /* set start wait time */
- timed_out = 0;
+ m_timed_out = 0;
/* get data size -- in int32_t */
if ((nbytes = read_nbytes(this, (char *)&pktsiz, sizeof(int32_t))) <= 0) {
timer_start = 0; /* clear timer */
pktsiz = BNET_TERMINATE; /* hang up */
}
if (pktsiz == BNET_TERMINATE) {
- terminated = 1;
+ set_terminated();
}
timer_start = 0; /* clear timer */
b_errno = ENODATA;
}
timer_start = watchdog_time; /* set start wait time */
- timed_out = 0;
+ m_timed_out = 0;
/* now read the actual data */
if ((nbytes = read_nbytes(this, msg, pktsiz)) <= 0) {
timer_start = 0; /* clear timer */
{
msglen = signal;
if (signal == BNET_TERMINATE) {
- suppress_error_msgs = true;
+ m_suppress_error_msgs = true;
}
return send();
}
ssize_t last = 0, size = 0;
int count = 0;
- rewind(spool_fd);
+ rewind(m_spool_fd);
#if defined(HAVE_POSIX_FADVISE) && defined(POSIX_FADV_WILLNEED)
- posix_fadvise(fileno(spool_fd), 0, 0, POSIX_FADV_WILLNEED);
+ posix_fadvise(fileno(m_spool_fd), 0, 0, POSIX_FADV_WILLNEED);
#endif
- while (fread((char *)&pktsiz, 1, sizeof(int32_t), spool_fd) ==
+ while (fread((char *)&pktsiz, 1, sizeof(int32_t), m_spool_fd) ==
sizeof(int32_t)) {
size += sizeof(int32_t);
msglen = ntohl(pktsiz);
if (msglen > (int32_t) sizeof_pool_memory(msg)) {
msg = realloc_pool_memory(msg, msglen + 1);
}
- nbytes = fread(msg, 1, msglen, spool_fd);
+ nbytes = fread(msg, 1, msglen, m_spool_fd);
if (nbytes != (size_t) msglen) {
berrno be;
Dmsg2(400, "nbytes=%d msglen=%d\n", nbytes, msglen);
send();
}
update_attr_spool_size(tsize - last);
- if (ferror(spool_fd)) {
+ if (ferror(m_spool_fd)) {
berrno be;
Qmsg1(jcr(), M_FATAL, 0, _("fread attr spool error. ERR=%s\n"),
be.bstrerror());
return true;
}
+/*
+ * Return the string for the error that occurred
+ * on the socket. Only the first error is retained.
+ */
+const char *BSOCK::bstrerror()
+{
+ berrno be;
+ if (errmsg == NULL) {
+ errmsg = get_pool_memory(PM_MESSAGE);
+ }
+ pm_strcpy(errmsg, be.bstrerror(b_errno));
+ return errmsg;
+}
+
+int BSOCK::get_peer(char *buf, socklen_t buflen)
+{
+#if !defined(HAVE_WIN32)
+ if (peer_addr.sin_family == 0) {
+ socklen_t salen = sizeof(peer_addr);
+ int rval = (getpeername)(m_fd, (struct sockaddr *)&peer_addr, &salen);
+ if (rval < 0) return rval;
+ }
+ if (!inet_ntop(peer_addr.sin_family, &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: false on failure
+ * true on success
+ */
+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;
+ setsockopt(fd, IPPROTO_IP, IP_TOS, (sockopt_val_t)&opt, sizeof(opt));
+#endif
+
+ if (size != 0) {
+ dbuf_size = size;
+ } else {
+ dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
+ }
+ start_size = dbuf_size;
+ if ((msg = realloc_pool_memory(msg, dbuf_size + 100)) == NULL) {
+ Qmsg0(jcr(), M_FATAL, 0, _("Could not malloc BSOCK data buffer\n"));
+ return false;
+ }
+ 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)) {
+ berrno be;
+ Qmsg1(jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
+ dbuf_size -= TAPE_BSIZE;
+ }
+ Dmsg1(200, "set network buffer size=%d\n", dbuf_size);
+ if (dbuf_size != start_size) {
+ Qmsg1(jcr(), M_WARNING, 0,
+ _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
+ }
+ if (dbuf_size % TAPE_BSIZE != 0) {
+ Qmsg1(jcr(), M_ABORT, 0,
+ _("Network buffer size %d not multiple of tape block size.\n"),
+ dbuf_size);
+ }
+ }
+ if (size != 0) {
+ dbuf_size = size;
+ } else {
+ dbuf_size = DEFAULT_NETWORK_BUFFER_SIZE;
+ }
+ start_size = dbuf_size;
+ if (rw & BNET_SETBUF_WRITE) {
+ while ((dbuf_size > TAPE_BSIZE) && (setsockopt(m_fd, SOL_SOCKET,
+ SO_SNDBUF, (sockopt_val_t) & dbuf_size, sizeof(dbuf_size)) < 0)) {
+ berrno be;
+ Qmsg1(jcr(), M_ERROR, 0, _("sockopt error: %s\n"), be.bstrerror());
+ dbuf_size -= TAPE_BSIZE;
+ }
+ Dmsg1(900, "set network buffer size=%d\n", dbuf_size);
+ if (dbuf_size != start_size) {
+ Qmsg1(jcr(), M_WARNING, 0,
+ _("Warning network buffer = %d bytes not max size.\n"), dbuf_size);
+ }
+ if (dbuf_size % TAPE_BSIZE != 0) {
+ Qmsg1(jcr(), M_ABORT, 0,
+ _("Network buffer size %d not multiple of tape block size.\n"),
+ dbuf_size);
+ }
+ }
+
+ msglen = dbuf_size;
+ return true;
+}
+
+/*
+ * Set socket non-blocking
+ * Returns previous socket flag
+ */
+int BSOCK::set_nonblocking()
+{
+#ifndef HAVE_WIN32
+ int oflags;
+
+ /* Get current flags */
+ if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
+ berrno be;
+ Jmsg1(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(jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
+ }
+
+ m_blocking = 0;
+ return oflags;
+#else
+ int flags;
+ u_long ioctlArg = 1;
+
+ flags = m_blocking;
+ ioctlsocket(m_fd, FIONBIO, &ioctlArg);
+ m_blocking = 0;
+
+ return flags;
+#endif
+}
+
+/*
+ * Set socket blocking
+ * Returns previous socket flags
+ */
+int BSOCK::set_blocking()
+{
+#ifndef HAVE_WIN32
+ int oflags;
+ /* Get current flags */
+ if ((oflags = fcntl(m_fd, F_GETFL, 0)) < 0) {
+ berrno be;
+ Jmsg1(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(jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
+ }
+
+ m_blocking = 1;
+ return oflags;
+#else
+ int flags;
+ u_long ioctlArg = 0;
+
+ flags = m_blocking;
+ ioctlsocket(m_fd, FIONBIO, &ioctlArg);
+ m_blocking = 1;
+
+ return flags;
+#endif
+}
+
+/*
+ * Restores socket flags
+ */
+void BSOCK::restore_blocking (int flags)
+{
+#ifndef HAVE_WIN32
+ if ((fcntl(m_fd, F_SETFL, flags)) < 0) {
+ berrno be;
+ Jmsg1(jcr(), M_ABORT, 0, _("fcntl F_SETFL error. ERR=%s\n"), be.bstrerror());
+ }
+
+ m_blocking = (flags & O_NONBLOCK) ? true : false;
+#else
+ u_long ioctlArg = flags;
+
+ ioctlsocket(m_fd, FIONBIO, &ioctlArg);
+ m_blocking = 1;
+#endif
+}
+
void BSOCK::close()
{
for (; bsock; bsock = next) {
next = bsock->m_next; /* get possible pointer to next before destoryed */
- if (!bsock->duped) {
+ if (!bsock->m_duped) {
#ifdef HAVE_TLS
/* Shutdown tls cleanly. */
if (bsock->tls) {
bsock->tls = NULL;
}
#endif /* HAVE_TLS */
- if (bsock->timed_out) {
- shutdown(bsock->fd, 2); /* discard any pending I/O */
+ if (bsock->is_timed_out()) {
+ shutdown(bsock->m_fd, 2); /* discard any pending I/O */
}
- socketClose(bsock->fd); /* normal close */
+ socketClose(bsock->m_fd); /* normal close */
}
destroy(); /* free the packet */
}
Switzerland, email:ftf@fsfeurope.org.
*/
/*
- * Bacula Sock Structure definition
+ * Bacula Sock Class definition
+ * Note, the old non-class code is in bnet.c, and the
+ * new class code associated with this file is in bsock.c
*
* Kern Sibbald, May MM
*
uint64_t read_seqno; /* read sequence number */
uint32_t in_msg_no; /* input message number */
uint32_t out_msg_no; /* output message number */
- int fd; /* socket file descriptor */
+ int m_fd; /* socket file descriptor */
TLS_CONNECTION *tls; /* associated tls connection */
int32_t msglen; /* message length */
int b_errno; /* bsock errno */
- int blocking; /* blocking state (0 = nonblocking, 1 = blocking) */
+ int m_blocking; /* blocking state (0 = nonblocking, 1 = blocking) */
volatile int errors; /* incremented for each error on socket */
- volatile bool suppress_error_msgs: 1; /* set to suppress error messages */
- volatile bool timed_out: 1; /* timed out in read/write */
- volatile bool terminated: 1; /* set when BNET_TERMINATE arrives */
- bool duped: 1; /* set if duped BSOCK */
- bool spool: 1; /* set for spooling */
+ volatile bool m_suppress_error_msgs: 1; /* set to suppress error messages */
+ volatile bool m_timed_out: 1; /* timed out in read/write */
+ volatile bool m_terminated: 1; /* set when BNET_TERMINATE arrives */
+ bool m_duped: 1; /* set if duped BSOCK */
+ bool m_spool: 1; /* set for spooling */
volatile time_t timer_start; /* time started read/write */
volatile time_t timeout; /* timeout BSOCK after this interval */
POOLMEM *msg; /* message pool buffer */
POOLMEM *errmsg; /* edited error message */
RES *res; /* Resource to which we are connected */
- FILE *spool_fd; /* spooling file */
+ FILE *m_spool_fd; /* spooling file */
struct sockaddr client_addr; /* client's IP address */
struct sockaddr_in peer_addr; /* peer's IP address */
bool signal(int signal);
void close(); /* close connection and destroy packet */
void destroy(); /* destroy socket packet */
+ const char *bstrerror(); /* last error on socket */
+ int get_peer(char *buf, socklen_t buflen);
+ bool despool(void update_attr_spool_size(ssize_t size), ssize_t tsize);
+ bool set_buffer_size(uint32_t size, int rw);
+ int set_nonblocking();
+ int set_blocking();
+ void restore_blocking(int flags);
+
+ /* Inline functions */
void set_jcr(JCR *jcr) { m_jcr = jcr; };
void set_who(char *who) { m_who = who; };
void set_host(char *host) { m_host = host; };
char *host() { return m_host; };
int port() { return m_port; };
JCR *jcr() { return m_jcr; };
- bool despool(void update_attr_spool_size(ssize_t size), ssize_t tsize);
+ bool is_terminated() { return m_terminated; };
+ bool is_timed_out() { return m_timed_out; };
+ void set_terminated() { m_terminated = true; };
};
/*
* Signal definitions for use in bnet_sig()
* Note! These must be negative. There are signals that are generated
- * by the software ...
+ * by the bsock software not by the OS ...
*/
enum {
BNET_EOD = -1, /* End of data stream, new data may follow */
wid->type == TYPE_BSOCK ? "bsock" : "thread", wid->tid, time(NULL));
if (wid->type == TYPE_BSOCK && wid->bsock) {
- wid->bsock->timed_out = true;
+ wid->bsock->m_timed_out = true;
}
pthread_kill(wid->tid, TIMEOUT_SIGNAL);
}
timer_start = fd->timer_start;
if (timer_start && (watchdog_time - timer_start) > fd->timeout) {
fd->timer_start = 0; /* turn off timer */
- fd->timed_out = true;
+ fd->m_timed_out = true;
Jmsg(jcr, M_ERROR, 0, _(
"Watchdog sending kill after %d secs to thread stalled reading Storage daemon.\n"),
watchdog_time - timer_start);
timer_start = fd->timer_start;
if (timer_start && (watchdog_time - timer_start) > fd->timeout) {
fd->timer_start = 0; /* turn off timer */
- fd->timed_out = true;
+ fd->m_timed_out = true;
Jmsg(jcr, M_ERROR, 0, _(
"Watchdog sending kill after %d secs to thread stalled reading File daemon.\n"),
watchdog_time - timer_start);
timer_start = fd->timer_start;
if (timer_start && (watchdog_time - timer_start) > fd->timeout) {
fd->timer_start = 0; /* turn off timer */
- fd->timed_out = true;
+ fd->m_timed_out = true;
Jmsg(jcr, M_ERROR, 0, _(
"Watchdog sending kill after %d secs to thread stalled reading Director.\n"),
watchdog_time - timer_start);
/* Zero the fdset, we'll set our fd prior to each invocation of select() */
FD_ZERO(&fdset);
- fdmax = bsock->fd + 1;
+ fdmax = bsock->m_fd + 1;
/* Ensure that socket is non-blocking */
flags = bnet_set_nonblocking(bsock);
/* start timer */
bsock->timer_start = watchdog_time;
- bsock->timed_out = 0;
+ bsock->m_timed_out = 0;
for (;;) {
if (server) {
goto cleanup;
case SSL_ERROR_WANT_READ:
/* If we timeout of a select, this will be unset */
- FD_SET((unsigned) bsock->fd, &fdset);
+ FD_SET((unsigned) bsock->m_fd, &fdset);
/* Set our timeout */
tv.tv_sec = 10;
tv.tv_usec = 0;
break;
case SSL_ERROR_WANT_WRITE:
/* If we timeout of a select, this will be unset */
- FD_SET((unsigned) bsock->fd, &fdset);
+ FD_SET((unsigned) bsock->m_fd, &fdset);
/* Set our timeout */
tv.tv_sec = 10;
tv.tv_usec = 0;
goto cleanup;
}
- if (bsock->timed_out) {
+ if (bsock->is_timed_out()) {
goto cleanup;
}
}
int flags;
/* Set socket blocking for shutdown */
- flags = bnet_set_blocking(bsock);
+ flags = bsock->set_blocking();
err = SSL_shutdown(bsock->tls->openssl);
}
/* Restore saved flags */
- bnet_restore_blocking(bsock, flags);
+ bsock->restore_blocking(flags);
}
/* Does all the manual labor for tls_bsock_readn() and tls_bsock_writen() */
/* Zero the fdset, we'll set our fd prior to each invocation of select() */
FD_ZERO(&fdset);
- fdmax = bsock->fd + 1;
+ fdmax = bsock->m_fd + 1;
/* Ensure that socket is non-blocking */
- flags = bnet_set_nonblocking(bsock);
+ flags = bsock->set_nonblocking();
/* start timer */
bsock->timer_start = watchdog_time;
- bsock->timed_out = 0;
+ bsock->m_timed_out = 0;
nleft = nbytes;
goto cleanup;
case SSL_ERROR_WANT_READ:
/* If we timeout of a select, this will be unset */
- FD_SET((unsigned) bsock->fd, &fdset);
+ FD_SET((unsigned) bsock->m_fd, &fdset);
tv.tv_sec = 10;
tv.tv_usec = 0;
/* Block until we can read */
break;
case SSL_ERROR_WANT_WRITE:
/* If we timeout of a select, this will be unset */
- FD_SET((unsigned) bsock->fd, &fdset);
+ FD_SET((unsigned) bsock->m_fd, &fdset);
tv.tv_sec = 10;
tv.tv_usec = 0;
/* Block until we can write */
}
/* Timeout/Termination, let's take what we can get */
- if (bsock->timed_out || bsock->terminated) {
+ if (bsock->is_timed_out() || bsock->is_terminated()) {
goto cleanup;
}
}
cleanup:
/* Restore saved flags */
- bnet_restore_blocking(bsock, flags);
+ bsock->restore_blocking(flags);
/* Clear timer */
bsock->timer_start = 0;
mainWin->set_status(_("Initializing ..."));
/* Set up input notifier */
- m_notifier = new QSocketNotifier(m_sock->fd, QSocketNotifier::Read, 0);
+ m_notifier = new QSocketNotifier(m_sock->m_fd, QSocketNotifier::Read, 0);
QObject::connect(m_notifier, SIGNAL(activated(int)), this, SLOT(read_dir(int)));
write(".api 1");
crypto_digest_stream_type(stream) != CRYPTO_DIGEST_NONE) {
if (!jcr->no_attributes) {
if (are_attributes_spooled(jcr)) {
- jcr->dir_bsock->spool = true;
+ jcr->dir_bsock->m_spool = true;
}
Dmsg0(850, "Send attributes to dir.\n");
if (!dir_update_file_attributes(dcr, &rec)) {
- jcr->dir_bsock->spool = false;
+ jcr->dir_bsock->m_spool = false;
Jmsg(jcr, M_FATAL, 0, _("Error updating file attributes. ERR=%s\n"),
bnet_strerror(jcr->dir_bsock));
ok = false;
break;
}
- jcr->dir_bsock->spool = false;
+ jcr->dir_bsock->m_spool = false;
}
}
Dmsg0(650, "Enter bnet_get\n");
crypto_digest_stream_type(stream) != CRYPTO_DIGEST_NONE) {
if (!jcr->no_attributes) {
if (are_attributes_spooled(jcr)) {
- jcr->dir_bsock->spool = true;
+ jcr->dir_bsock->m_spool = true;
}
Dmsg0(850, "Send attributes to dir.\n");
if (!dir_update_file_attributes(jcr->dcr, rec)) {
- jcr->dir_bsock->spool = false;
+ jcr->dir_bsock->m_spool = false;
Jmsg(jcr, M_FATAL, 0, _("Error updating file attributes. ERR=%s\n"),
bnet_strerror(jcr->dir_bsock));
return false;
}
- jcr->dir_bsock->spool = false;
+ jcr->dir_bsock->m_spool = false;
}
}
bool are_attributes_spooled(JCR *jcr)
{
- return jcr->spool_attributes && jcr->dir_bsock->spool_fd;
+ return jcr->spool_attributes && jcr->dir_bsock->m_spool_fd;
}
/*
char ec1[30];
if (are_attributes_spooled(jcr)) {
- if (fseeko(jcr->dir_bsock->spool_fd, 0, SEEK_END) != 0) {
+ if (fseeko(jcr->dir_bsock->m_spool_fd, 0, SEEK_END) != 0) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("Fseek on attributes file failed: ERR=%s\n"),
be.bstrerror());
goto bail_out;
}
- size = ftello(jcr->dir_bsock->spool_fd);
+ size = ftello(jcr->dir_bsock->m_spool_fd);
if (size < 0) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("Fseek on attributes file failed: ERR=%s\n"),
{
POOLMEM *name = get_pool_memory(PM_MESSAGE);
- make_unique_spool_filename(jcr, &name, bs->fd);
- bs->spool_fd = fopen(name, "w+b");
- if (!bs->spool_fd) {
+ make_unique_spool_filename(jcr, &name, bs->m_fd);
+ bs->m_spool_fd = fopen(name, "w+b");
+ if (!bs->m_spool_fd) {
berrno be;
Jmsg(jcr, M_FATAL, 0, _("fopen attr spool file %s failed: ERR=%s\n"), name,
be.bstrerror());
{
POOLMEM *name;
- if (!bs->spool_fd) {
+ if (!bs->m_spool_fd) {
return true;
}
name = get_pool_memory(PM_MESSAGE);
spool_stats.attr_jobs--;
spool_stats.total_attr_jobs++;
V(mutex);
- make_unique_spool_filename(jcr, &name, bs->fd);
- fclose(bs->spool_fd);
+ make_unique_spool_filename(jcr, &name, bs->m_fd);
+ fclose(bs->m_spool_fd);
unlink(name);
free_pool_memory(name);
- bs->spool_fd = NULL;
- bs->spool = false;
+ bs->m_spool_fd = NULL;
+ bs->m_spool = false;
return true;
}
len = Mmsg(msg, _(" FDReadSeqNo=%s in_msg=%u out_msg=%d fd=%d\n"),
edit_uint64_with_commas(jcr->file_bsock->read_seqno, b1),
jcr->file_bsock->in_msg_no, jcr->file_bsock->out_msg_no,
- jcr->file_bsock->fd);
+ jcr->file_bsock->m_fd);
sendit(msg, len, arg);
} else {
len = Mmsg(msg, _(" FDSocket closed\n"));
set_jcr_job_status(jcr, JS_Canceled);
fd = jcr->file_bsock;
if (fd) {
- fd->timed_out = true;
+ fd->m_timed_out = true;
Dmsg1(100, "term_stored killing JobId=%d\n", jcr->JobId);
pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
/* ***FIXME*** wiffle through all dcrs */
General:
20May07
+kes Move more bnet functions into the BSOCK class.
kes Fix tray-monitor by not requiring a timer interval in bnet_connect()
kes Complete change of berrno strerror() method to bstrerror()
Release: 2.1.10 beta
projects / bacula / bacula / commitdiff