int
_gpgme_io_read ( int fd, void *buffer, size_t count )
{
int nread;
struct reader_context_s *c = find_reader (fd,1);
DEBUG2 ("fd %d: about to read %d bytes\n", fd, (int)count );
if ( !c ) {
DEBUG0 ( "no reader thread\n");
return -1;
}
if (c->eof_shortcut) {
DEBUG1 ("fd %d: EOF (again)", fd );
return 0;
}
LOCK (c->mutex);
if (c->readpos == c->writepos && !c->error) { /*no data avail*/
UNLOCK (c->mutex);
DEBUG2 ("fd %d: waiting for data from thread %p", fd, c->thread_hd);
WaitForSingleObject (c->have_data_ev, INFINITE);
DEBUG2 ("fd %d: data from thread %p available", fd, c->thread_hd);
LOCK (c->mutex);
}
if (c->readpos == c->writepos || c->error) {
UNLOCK (c->mutex);
c->eof_shortcut = 1;
if (c->eof) {
DEBUG1 ("fd %d: EOF", fd );
return 0;
}
if (!c->error) {
DEBUG1 ("fd %d: EOF but eof flag not set", fd );
return 0;
}
DEBUG1 ("fd %d: read error", fd );
return -1;
}
nread = c->readpos < c->writepos? c->writepos - c->readpos
: READBUF_SIZE - c->readpos;
if (nread > count)
nread = count;
memcpy (buffer, c->buffer+c->readpos, nread);
c->readpos = (c->readpos + nread) % READBUF_SIZE;
if (c->readpos == c->writepos && !c->eof) {
if ( !ResetEvent (c->have_data_ev) )
DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
}
if (!SetEvent (c->have_space_ev))
DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
UNLOCK (c->mutex);
DEBUG2 ("fd %d: got %d bytes\n", fd, nread );
if (nread > 0)
_gpgme_debug (2, "fd %d: got `%.*s'\n", fd, nread, buffer);
return nread;
}
int
_gpgme_assuan_log_cb (assuan_context_t ctx, void *hook,
unsigned int cat, const char *msg)
{
if (msg == NULL)
return 1;
_gpgme_debug (DEBUG_ASSUAN, "%s", msg);
return 0;
}
/* Finish construction of *LINE and send it to the debug output
stream. */
void
_gpgme_debug_end(void **line)
{
if(!*line)
return;
/* The smallest possible level is 1, so force logging here by
using that. */
_gpgme_debug(1, "%s", *line);
free(*line);
*line = NULL;
}
int
_gpgme_io_write ( int fd, const void *buffer, size_t count )
{
struct writer_context_s *c = find_writer (fd,1);
DEBUG2 ("fd %d: about to write %d bytes\n", fd, (int)count );
_gpgme_debug (2, "fd %d: write `%.*s'\n", fd, (int) count, buffer);
if ( !c ) {
DEBUG0 ( "no writer thread\n");
return -1;
}
LOCK (c->mutex);
if ( c->nbytes ) { /* bytes are pending for send */
/* Reset the is_empty event. Better safe than sorry. */
if (!ResetEvent (c->is_empty))
DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
UNLOCK (c->mutex);
DEBUG2 ("fd %d: waiting for empty buffer in thread %p",
fd, c->thread_hd);
WaitForSingleObject (c->is_empty, INFINITE);
DEBUG2 ("fd %d: thread %p buffer is empty", fd, c->thread_hd);
LOCK (c->mutex);
}
if ( c->error) {
UNLOCK (c->mutex);
DEBUG1 ("fd %d: write error", fd );
return -1;
}
/* If no error occured, the number of bytes in the buffer must be
zero. */
assert (!c->nbytes);
if (count > WRITEBUF_SIZE)
count = WRITEBUF_SIZE;
memcpy (c->buffer, buffer, count);
c->nbytes = count;
/* We have to reset the is_empty event early, because it is also
used by the select() implementation to probe the channel. */
if (!ResetEvent (c->is_empty))
DEBUG1 ("ResetEvent failed: ec=%d", (int)GetLastError ());
if (!SetEvent (c->have_data))
DEBUG1 ("SetEvent failed: ec=%d", (int)GetLastError ());
UNLOCK (c->mutex);
DEBUG2 ("fd %d: copied %d bytes\n",
fd, (int)count );
return (int)count;
}
int
_gpgme_io_write(int fd, const void *buffer, size_t count)
{
int saved_errno;
int nwritten;
DEBUG2("fd %d: about to write %d bytes\n", fd, (int) count);
_gpgme_debug(2, "fd %d: write `%.*s'\n", fd, (int) count, buffer);
do
{
nwritten = _gpgme_ath_write(fd, buffer, count);
}
while(nwritten == -1 && errno == EINTR);
saved_errno = errno;
DEBUG2("fd %d: wrote %d bytes\n", fd, (int) nwritten);
errno = saved_errno;
return nwritten;
}
int
_gpgme_io_read(int fd, void *buffer, size_t count)
{
int nread;
int saved_errno;
DEBUG2("fd %d: about to read %d bytes\n", fd, (int) count);
do
{
nread = _gpgme_ath_read(fd, buffer, count);
}
while(nread == -1 && errno == EINTR);
saved_errno = errno;
DEBUG2("fd %d: got %d bytes\n", fd, nread);
if(nread > 0)
_gpgme_debug(2, "fd %d: got `%.*s'\n", fd, nread, buffer);
errno = saved_errno;
return nread;
}
int
_gpgme_io_recvmsg(int fd, struct msghdr *msg, int flags)
{
int nread;
int saved_errno;
struct iovec *iov;
nread = 0;
iov = msg->msg_iov;
while(iov < msg->msg_iov + msg->msg_iovlen)
{
nread += iov->iov_len;
iov++;
}
DEBUG2("fd %d: about to receive %d bytes\n",
fd, (int) nread);
do
{
nread = _gpgme_ath_recvmsg(fd, msg, flags);
}
while(nread == -1 && errno == EINTR);
saved_errno = errno;
DEBUG2("fd %d: got %d bytes\n", fd, nread);
if(nread > 0)
{
int nr = nread;
iov = msg->msg_iov;
while(nr > 0)
{
int len = nr > iov->iov_len ? iov->iov_len : nr;
_gpgme_debug(2, "fd %d: got `%.*s'\n", fd, len,
msg->msg_iov->iov_base);
iov++;
nr -= len;
}
}
errno = saved_errno;
return nread;
}
int
_gpgme_io_sendmsg(int fd, const struct msghdr *msg, int flags)
{
int saved_errno;
int nwritten;
struct iovec *iov;
nwritten = 0;
iov = msg->msg_iov;
while(iov < msg->msg_iov + msg->msg_iovlen)
{
nwritten += iov->iov_len;
iov++;
}
DEBUG2("fd %d: about to write %d bytes\n", fd, (int) nwritten);
iov = msg->msg_iov;
while(nwritten > 0)
{
int len = nwritten > iov->iov_len ? iov->iov_len : nwritten;
_gpgme_debug(2, "fd %d: write `%.*s'\n", fd, len,
msg->msg_iov->iov_base);
iov++;
nwritten -= len;
}
do
{
nwritten = _gpgme_ath_sendmsg(fd, msg, flags);
}
while(nwritten == -1 && errno == EINTR);
saved_errno = errno;
DEBUG2("fd %d: wrote %d bytes\n", fd, (int) nwritten);
errno = saved_errno;
return nwritten;
}
