static ssize_t
__assuan_write (assuan_context_t ctx, assuan_fd_t fd, const void *buffer,
size_t size)
{
/* Due to the peculiarities of the W32 API we can't use write for a
network socket and thus we try to use send first and fallback to
write if send detects that it is not a network socket. */
int res;
TRACE_BEG3 (ctx, ASSUAN_LOG_SYSIO, "__assuan_write", ctx,
"fd=0x%x, buffer=%p, size=%i", fd, buffer, size);
#ifdef HAVE_W32CE_SYSTEM
/* This is a bit of a hack to support stdout over ssh. Note that
fread buffers fully while getchar is line buffered. Weird, but
that's the way it is. ASSUAN_STDIN and ASSUAN_STDOUT are
special handle values that shouldn't occur in the wild. */
if (fd == ASSUAN_STDOUT)
{
res = fwrite (buffer, 1, size, stdout);
return TRACE_SYSRES (res);
}
#endif
res = send ((int)fd, buffer, size, 0);
if (res == -1 && WSAGetLastError () == WSAENOTSOCK)
{
DWORD nwrite;
TRACE_LOG ("send call failed - trying WriteFile");
res = WriteFile (fd, buffer, size, &nwrite, NULL);
if (! res)
{
TRACE_LOG1 ("WriteFile failed: rc=%d", (int)GetLastError ());
switch (GetLastError ())
{
case ERROR_BROKEN_PIPE:
case ERROR_NO_DATA:
gpg_err_set_errno (EPIPE);
break;
case ERROR_PIPE_NOT_CONNECTED:
case ERROR_BUSY:
gpg_err_set_errno (EAGAIN);
break;
default:
gpg_err_set_errno (EIO);
break;
}
res = -1;
}
else
res = (int) nwrite;
}
else if (res == -1)
TRACE_LOG1 ("send call failed: rc=%d", (int)GetLastError ());
return TRACE_SYSRES (res);
}
int
_gpgme_io_read (int fd, void *buffer, size_t count)
{
int saved_errno = 0;
gsize nread;
GIOChannel *chan;
GIOStatus status;
TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_read", fd,
"buffer=%p, count=%u", buffer, count);
chan = find_channel (fd);
if (!chan)
{
TRACE_LOG ("no channel registered");
errno = EINVAL;
return TRACE_SYSRES (-1);
}
TRACE_LOG1 ("channel %p", chan);
{
GError *err = NULL;
status = g_io_channel_read_chars (chan, (gchar *) buffer,
count, &nread, &err);
if (err)
{
TRACE_LOG2 ("status %i, err %s", status, err->message);
g_error_free (err);
}
}
if (status == G_IO_STATUS_EOF)
nread = 0;
else if (status == G_IO_STATUS_AGAIN)
{
nread = -1;
saved_errno = EAGAIN;
}
else if (status != G_IO_STATUS_NORMAL)
{
TRACE_LOG1 ("status %d", status);
nread = -1;
saved_errno = EIO;
}
if (nread != 0 && nread != -1)
TRACE_LOGBUF (buffer, nread);
errno = saved_errno;
return TRACE_SYSRES (nread);
}
gpgme_assuan_result_t
gpgme_op_assuan_result (gpgme_ctx_t ctx)
{
gpgme_error_t err;
void *hook;
op_data_t opd;
TRACE_BEG (DEBUG_CTX, "gpgme_op_assuan_result", ctx);
err = _gpgme_op_data_lookup (ctx, OPDATA_ASSUAN, &hook, -1, NULL);
opd = hook;
/* Check in case this function is used without having run a command
before. */
if (err || !opd)
{
TRACE_SUC0 ("result=(null)");
return NULL;
}
/* All of this is a hack for the old style interface. The new style
interface returns op errors directly. */
opd->result.err = _gpgme_engine_assuan_last_op_err (ctx->engine->engine);
if (opd->result.err)
{
TRACE_LOG1 ("err = %s", gpg_strerror (0));
}
else
{
TRACE_LOG2 ("err = %s <%s>", gpg_strerror (opd->result.err),
gpg_strsource (opd->result.err));
}
TRACE_SUC1 ("result=%p", &opd->result);
return &opd->result;
}
/* Lock a spawning process. The caller needs to provide the address
of a variable to store the lock information and the name or the
process. */
gpg_error_t
gpgex_lock_spawning (lock_spawn_t *lock)
{
int waitrc;
int timeout = 5;
_TRACE (DEBUG_ASSUAN, "gpgex_lock_spawning", lock);
*lock = CreateMutexW (NULL, FALSE, L"spawn_gnupg_uiserver_sentinel");
if (!*lock)
{
TRACE_LOG1 ("failed to create the spawn mutex: rc=%d", GetLastError ());
return gpg_error (GPG_ERR_GENERAL);
}
retry:
waitrc = WaitForSingleObject (*lock, 1000);
if (waitrc == WAIT_OBJECT_0)
return 0;
if (waitrc == WAIT_TIMEOUT && timeout)
{
timeout--;
goto retry;
}
if (waitrc == WAIT_TIMEOUT)
TRACE_LOG ("error waiting for the spawn mutex: timeout");
else
TRACE_LOG2 ("error waiting for the spawn mutex: (code=%d) rc=%d",
waitrc, GetLastError ());
return gpg_error (GPG_ERR_GENERAL);
}
/* Set the engine info for the context CTX, protocol PROTO, to the
file name FILE_NAME and the home directory HOME_DIR. */
gpgme_error_t
gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto,
const char *file_name, const char *home_dir)
{
gpgme_error_t err;
TRACE_BEG4 (DEBUG_CTX, "gpgme_ctx_set_engine_info", ctx,
"protocol=%i (%s), file_name=%s, home_dir=%s",
proto, gpgme_get_protocol_name (proto)
? gpgme_get_protocol_name (proto) : "unknown",
file_name ? file_name : "(default)",
home_dir ? home_dir : "(default)");
if (!ctx)
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
/* Shut down the engine when changing engine info. */
if (ctx->engine)
{
TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
_gpgme_engine_release (ctx->engine);
ctx->engine = NULL;
}
err = _gpgme_set_engine_info (ctx->engine_info, proto,
file_name, home_dir);
return TRACE_ERR (err);
}
gpgme_error_t
gpgme_set_protocol (gpgme_ctx_t ctx, gpgme_protocol_t protocol)
{
TRACE_BEG2 (DEBUG_CTX, "gpgme_set_protocol", ctx, "protocol=%i (%s)",
protocol, gpgme_get_protocol_name (protocol)
? gpgme_get_protocol_name (protocol) : "invalid");
if (protocol != GPGME_PROTOCOL_OpenPGP
&& protocol != GPGME_PROTOCOL_CMS
&& protocol != GPGME_PROTOCOL_GPGCONF
&& protocol != GPGME_PROTOCOL_ASSUAN
&& protocol != GPGME_PROTOCOL_G13
&& protocol != GPGME_PROTOCOL_UISERVER
&& protocol != GPGME_PROTOCOL_SPAWN)
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
if (!ctx)
return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
if (ctx->protocol != protocol)
{
/* Shut down the engine when switching protocols. */
if (ctx->engine)
{
TRACE_LOG1 ("releasing ctx->engine=%p", ctx->engine);
_gpgme_engine_release (ctx->engine);
ctx->engine = NULL;
}
ctx->protocol = protocol;
}
return TRACE_ERR (0);
}
int
_gpgme_io_set_nonblocking (int fd)
{
GIOChannel *chan;
GIOStatus status;
TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_set_nonblocking", fd);
chan = find_channel (fd);
if (!chan)
{
errno = EIO;
return TRACE_SYSRES (-1);
}
status = g_io_channel_set_flags (chan,
g_io_channel_get_flags (chan) |
G_IO_FLAG_NONBLOCK, NULL);
if (status != G_IO_STATUS_NORMAL)
{
#if 0
/* glib 1.9.2 does not implement set_flags and returns an
error. */
errno = EIO;
return TRACE_SYSRES (-1);
#else
TRACE_LOG1 ("g_io_channel_set_flags failed: status=%d (ignored)",
status);
#endif
}
return TRACE_SYSRES (0);
}
gpgme_decrypt_result_t
gpgme_op_decrypt_result (gpgme_ctx_t ctx)
{
void *hook;
op_data_t opd;
gpgme_error_t err;
TRACE_BEG (DEBUG_CTX, "gpgme_op_decrypt_result", ctx);
err = _gpgme_op_data_lookup (ctx, OPDATA_DECRYPT, &hook, -1, NULL);
opd = hook;
if (err || !opd)
{
TRACE_SUC0 ("result=(null)");
return NULL;
}
if (_gpgme_debug_trace ())
{
gpgme_recipient_t rcp;
if (opd->result.unsupported_algorithm)
{
TRACE_LOG1 ("result: unsupported_algorithm: %s",
opd->result.unsupported_algorithm);
}
if (opd->result.wrong_key_usage)
{
TRACE_LOG ("result: wrong key usage");
}
rcp = opd->result.recipients;
while (rcp)
{
TRACE_LOG3 ("result: recipient: keyid=%s, pubkey_algo=%i, "
"status=%s", rcp->keyid, rcp->pubkey_algo,
gpg_strerror (rcp->status));
rcp = rcp->next;
}
if (opd->result.file_name)
{
TRACE_LOG1 ("result: original file name: %s", opd->result.file_name);
}
}
TRACE_SUC1 ("result=%p", &opd->result);
return &opd->result;
}
/* Fork and exec the program with /dev/null as stdin, stdout and
stderr. Returns 0 on success or an error code. */
gpg_error_t
gpgex_spawn_detached (const char *cmdline)
{
SECURITY_ATTRIBUTES sec_attr;
PROCESS_INFORMATION pi =
{
NULL, /* Returns process handle. */
0, /* Returns primary thread handle. */
0, /* Returns pid. */
0 /* Returns tid. */
};
STARTUPINFO si;
int cr_flags;
TRACE_BEG1 (DEBUG_ASSUAN, "gpgex_spawn_detached", cmdline,
"cmdline=%s", cmdline);
/* Prepare security attributes. */
memset (&sec_attr, 0, sizeof sec_attr);
sec_attr.nLength = sizeof sec_attr;
sec_attr.bInheritHandle = FALSE;
/* Start the process. Note that we can't run the PREEXEC function
because this would change our own environment. */
memset (&si, 0, sizeof si);
si.cb = sizeof (si);
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = DEBUG_W32_SPAWN ? SW_SHOW : SW_MINIMIZE;
cr_flags = (CREATE_DEFAULT_ERROR_MODE
| GetPriorityClass (GetCurrentProcess ())
| CREATE_NEW_PROCESS_GROUP
| DETACHED_PROCESS);
if (!CreateProcess (NULL, /* pgmname; Program to start. */
(char *) cmdline, /* Command line arguments. */
&sec_attr, /* Process security attributes. */
&sec_attr, /* Thread security attributes. */
TRUE, /* Inherit handles. */
cr_flags, /* Creation flags. */
NULL, /* Environment. */
NULL, /* Use current drive/directory. */
&si, /* Startup information. */
&pi /* Returns process information. */
))
{
(void) TRACE_LOG1 ("CreateProcess failed: %i\n", GetLastError ());
return gpg_error (GPG_ERR_GENERAL);
}
/* Process has been created suspended; resume it now. */
CloseHandle (pi.hThread);
CloseHandle (pi.hProcess);
return 0;
}
/* The writer does use a simple buffering strategy so that we are
informed about write errors as soon as possible (i. e. with the the
next call to the write function. */
static DWORD CALLBACK
writer (void *arg)
{
struct writer_context_s *ctx = arg;
DWORD nwritten;
TRACE_BEG1 (DEBUG_SYSIO, "gpgme:writer", ctx->file_hd,
"thread=%p", ctx->thread_hd);
for (;;)
{
LOCK (ctx->mutex);
if (ctx->stop_me)
{
UNLOCK (ctx->mutex);
break;
}
if (!ctx->nbytes)
{
if (!SetEvent (ctx->is_empty))
TRACE_LOG1 ("SetEvent failed: ec=%d", (int) GetLastError ());
if (!ResetEvent (ctx->have_data))
TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
UNLOCK (ctx->mutex);
TRACE_LOG ("idle");
WaitForSingleObject (ctx->have_data, INFINITE);
TRACE_LOG ("got data to send");
LOCK (ctx->mutex);
}
if (ctx->stop_me)
{
UNLOCK (ctx->mutex);
break;
}
UNLOCK (ctx->mutex);
TRACE_LOG1 ("writing %d bytes", ctx->nbytes);
/* Note that CTX->nbytes is not zero at this point, because
_gpgme_io_write always writes at least 1 byte before waking
us up, unless CTX->stop_me is true, which we catch above. */
if (!WriteFile (ctx->file_hd, ctx->buffer,
ctx->nbytes, &nwritten, NULL))
{
ctx->error_code = (int) GetLastError ();
ctx->error = 1;
TRACE_LOG1 ("write error: ec=%d", ctx->error_code);
break;
}
TRACE_LOG1 ("wrote %d bytes", (int) nwritten);
LOCK (ctx->mutex);
ctx->nbytes -= nwritten;
UNLOCK (ctx->mutex);
}
/* Indicate that we have an error. */
if (!SetEvent (ctx->is_empty))
TRACE_LOG1 ("SetEvent failed: ec=%d", (int) GetLastError ());
SetEvent (ctx->stopped);
return TRACE_SUC ();
}
/* Unlock the spawning process. */
void
gpgex_unlock_spawning (lock_spawn_t *lock)
{
if (*lock)
{
_TRACE (DEBUG_ASSUAN, "gpgex_unlock_spawning", lock);
if (!ReleaseMutex (*lock))
TRACE_LOG1 ("failed to release the spawn mutex: rc=%d", GetLastError());
CloseHandle (*lock);
*lock = NULL;
}
}
gpgme_verify_result_t
gpgme_op_verify_result (gpgme_ctx_t ctx)
{
void *hook;
op_data_t opd;
gpgme_error_t err;
TRACE_BEG (DEBUG_CTX, "gpgme_op_verify_result", ctx);
err = _gpgme_op_data_lookup (ctx, OPDATA_VERIFY, &hook, -1, NULL);
opd = hook;
if (err || !opd)
{
TRACE_SUC0 ("result=(null)");
return NULL;
}
if (_gpgme_debug_trace ())
{
gpgme_signature_t sig = opd->result.signatures;
int i = 0;
while (sig)
{
TRACE_LOG4 ("sig[%i] = fpr %s, summary 0x%x, status %s",
i, sig->fpr, sig->summary, gpg_strerror (sig->status));
TRACE_LOG6 ("sig[%i] = timestamps 0x%x/0x%x flags:%s%s%s",
i, sig->timestamp, sig->exp_timestamp,
sig->wrong_key_usage ? "wrong key usage" : "",
sig->pka_trust == 1 ? "pka bad"
: (sig->pka_trust == 2 ? "pka_okay" : "pka RFU"),
sig->chain_model ? "chain model" : "");
TRACE_LOG5 ("sig[%i] = validity 0x%x (%s), algos %s/%s",
i, sig->validity, gpg_strerror (sig->validity_reason),
gpgme_pubkey_algo_name (sig->pubkey_algo),
gpgme_hash_algo_name (sig->hash_algo));
if (sig->pka_address)
{
TRACE_LOG2 ("sig[%i] = PKA address %s", i, sig->pka_address);
}
if (sig->notations)
{
TRACE_LOG1 ("sig[%i] = has notations (not shown)", i);
}
sig = sig->next;
i++;
}
}
TRACE_SUC1 ("result=%p", &opd->result);
return &opd->result;
}
int
_gpgme_io_write (int fd, const void *buffer, size_t count)
{
int saved_errno = 0;
gsize nwritten;
GIOChannel *chan;
GIOStatus status;
GError *err = NULL;
TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_write", fd,
"buffer=%p, count=%u", buffer, count);
TRACE_LOGBUF (buffer, count);
chan = find_channel (fd);
if (!chan)
{
TRACE_LOG ("fd %d: no channel registered");
errno = EINVAL;
return -1;
}
status = g_io_channel_write_chars (chan, (gchar *) buffer, count,
&nwritten, &err);
if (err)
{
TRACE_LOG1 ("write error: %s", err->message);
g_error_free (err);
}
if (status == G_IO_STATUS_AGAIN)
{
nwritten = -1;
saved_errno = EAGAIN;
}
else if (status != G_IO_STATUS_NORMAL)
{
nwritten = -1;
saved_errno = EIO;
}
errno = saved_errno;
return TRACE_SYSRES (nwritten);
}
int
_gpgme_io_close (int fd)
{
int i;
_gpgme_close_notify_handler_t handler = NULL;
void *value = NULL;
TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_close", fd);
if (fd == -1)
{
errno = EBADF;
return TRACE_SYSRES (-1);
}
kill_reader (fd);
kill_writer (fd);
LOCK (notify_table_lock);
for (i = 0; i < DIM (notify_table); i++)
{
if (notify_table[i].inuse && notify_table[i].fd == fd)
{
handler = notify_table[i].handler;
value = notify_table[i].value;
notify_table[i].handler = NULL;
notify_table[i].value = NULL;
notify_table[i].inuse = 0;
break;
}
}
UNLOCK (notify_table_lock);
if (handler)
handler (fd, value);
if (!CloseHandle (fd_to_handle (fd)))
{
TRACE_LOG1 ("CloseHandle failed: ec=%d", (int) GetLastError ());
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
return TRACE_SYSRES (0);
}
int
_gpgme_io_connect (int fd, struct sockaddr *addr, int addrlen)
{
GIOChannel *chan;
int sockfd;
int res;
GIOFlags flags;
GIOStatus status;
GError *err = NULL;
TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_connect", fd,
"addr=%p, addrlen=%i", addr, addrlen);
chan = find_channel (fd);
if (! chan)
{
errno = EINVAL;
return TRACE_SYSRES (-1);
}
flags = g_io_channel_get_flags (chan);
if (flags & G_IO_FLAG_NONBLOCK)
{
status = g_io_channel_set_flags (chan, flags & ~G_IO_FLAG_NONBLOCK, &err);
if (err)
{
TRACE_LOG1 ("setting flags error: %s", err->message);
g_error_free (err);
err = NULL;
}
if (status != G_IO_STATUS_NORMAL)
{
errno = EIO;
return TRACE_SYSRES (-1);
}
}
sockfd = giochannel_table[fd].socket;
if (sockfd == INVALID_SOCKET)
{
errno = EINVAL;
return TRACE_SYSRES (-1);
}
TRACE_LOG1 ("connect sockfd=0x%x", sockfd);
res = connect (sockfd, addr, addrlen);
/* FIXME: Error ignored here. */
if (! (flags & G_IO_FLAG_NONBLOCK))
g_io_channel_set_flags (chan, flags, NULL);
if (res)
{
TRACE_LOG2 ("connect failed: %i %i", res, WSAGetLastError ());
errno = wsa2errno (WSAGetLastError ());
return TRACE_SYSRES (-1);
}
return TRACE_SUC ();
}
/* Select on the list of fds. Returns: -1 = error, 0 = timeout or
nothing to select, > 0 = number of signaled fds. */
int
_gpgme_io_select (struct io_select_fd_s *fds, size_t nfds, int nonblock)
{
HANDLE waitbuf[MAXIMUM_WAIT_OBJECTS];
int waitidx[MAXIMUM_WAIT_OBJECTS];
int code;
int nwait;
int i;
int any;
int count;
void *dbg_help;
TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_select", fds,
"nfds=%u, nonblock=%u", nfds, nonblock);
restart:
TRACE_SEQ (dbg_help, "select on [ ");
any = 0;
nwait = 0;
count = 0;
for (i=0; i < nfds; i++)
{
if (fds[i].fd == -1)
continue;
fds[i].signaled = 0;
if (fds[i].for_read || fds[i].for_write)
{
if (fds[i].for_read)
{
struct reader_context_s *ctx = find_reader (fds[i].fd,0);
if (!ctx)
TRACE_LOG1 ("error: no reader for FD 0x%x (ignored)",
fds[i].fd);
else
{
if (nwait >= DIM (waitbuf))
{
TRACE_END (dbg_help, "oops ]");
TRACE_LOG ("Too many objects for WFMO!");
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
waitidx[nwait] = i;
waitbuf[nwait++] = ctx->have_data_ev;
}
TRACE_ADD1 (dbg_help, "r0x%x ", fds[i].fd);
any = 1;
}
else if (fds[i].for_write)
{
struct writer_context_s *ctx = find_writer (fds[i].fd,0);
if (!ctx)
TRACE_LOG1 ("error: no writer for FD 0x%x (ignored)",
fds[i].fd);
else
{
if (nwait >= DIM (waitbuf))
{
TRACE_END (dbg_help, "oops ]");
TRACE_LOG ("Too many objects for WFMO!");
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
waitidx[nwait] = i;
waitbuf[nwait++] = ctx->is_empty;
}
TRACE_ADD1 (dbg_help, "w0x%x ", fds[i].fd);
any = 1;
}
}
}
TRACE_END (dbg_help, "]");
if (!any)
return TRACE_SYSRES (0);
code = WaitForMultipleObjects (nwait, waitbuf, 0, nonblock ? 0 : 1000);
if (code >= WAIT_OBJECT_0 && code < WAIT_OBJECT_0 + nwait)
{
/* This WFMO is a really silly function: It does return either
the index of the signaled object or if 2 objects have been
signalled at the same time, the index of the object with the
lowest object is returned - so and how do we find out how
many objects have been signaled???. The only solution I can
imagine is to test each object starting with the returned
index individually - how dull. */
any = 0;
for (i = code - WAIT_OBJECT_0; i < nwait; i++)
{
if (WaitForSingleObject (waitbuf[i], 0) == WAIT_OBJECT_0)
{
assert (waitidx[i] >=0 && waitidx[i] < nfds);
fds[waitidx[i]].signaled = 1;
any = 1;
count++;
}
}
if (!any)
{
TRACE_LOG ("no signaled objects found after WFMO");
count = -1;
}
}
else if (code == WAIT_TIMEOUT)
TRACE_LOG ("WFMO timed out");
else if (code == WAIT_FAILED)
{
int le = (int) GetLastError ();
if (le == ERROR_INVALID_HANDLE)
{
int k;
int j = handle_to_fd (waitbuf[i]);
TRACE_LOG1 ("WFMO invalid handle %d removed", j);
for (k = 0 ; k < nfds; k++)
{
if (fds[k].fd == j)
{
fds[k].for_read = fds[k].for_write = 0;
goto restart;
}
}
TRACE_LOG (" oops, or not???");
}
TRACE_LOG1 ("WFMO failed: %d", le);
count = -1;
}
else
{
TRACE_LOG1 ("WFMO returned %d", code);
count = -1;
}
if (count > 0)
{
TRACE_SEQ (dbg_help, "select OK [ ");
for (i = 0; i < nfds; i++)
{
if (fds[i].fd == -1)
continue;
if ((fds[i].for_read || fds[i].for_write) && fds[i].signaled)
TRACE_ADD2 (dbg_help, "%c0x%x ",
fds[i].for_read ? 'r' : 'w', fds[i].fd);
}
TRACE_END (dbg_help, "]");
}
if (count < 0)
{
/* FIXME: Should determine a proper error code. */
errno = EIO;
}
return TRACE_SYSRES (count);
}
gpgme_verify_result_t
gpgme_op_verify_result (gpgme_ctx_t ctx)
{
void *hook;
op_data_t opd;
gpgme_error_t err;
gpgme_signature_t sig;
TRACE_BEG (DEBUG_CTX, "gpgme_op_verify_result", ctx);
err = _gpgme_op_data_lookup (ctx, OPDATA_VERIFY, &hook, -1, NULL);
opd = hook;
if (err || !opd)
{
TRACE_SUC0 ("result=(null)");
return NULL;
}
/* It is possible that we saw a new signature only followed by an
ERROR line for that. In particular a missing X.509 key triggers
this. In this case it is surprising that the summary field has
not been updated. We fix it here by explicitly looking for this
case. The real fix would be to have GPGME emit ERRSIG. */
for (sig = opd->result.signatures; sig; sig = sig->next)
{
if (!sig->summary)
{
switch (gpg_err_code (sig->status))
{
case GPG_ERR_KEY_EXPIRED:
sig->summary |= GPGME_SIGSUM_KEY_EXPIRED;
break;
case GPG_ERR_NO_PUBKEY:
sig->summary |= GPGME_SIGSUM_KEY_MISSING;
break;
default:
break;
}
}
}
/* Now for some tracing stuff. */
if (_gpgme_debug_trace ())
{
int i;
for (sig = opd->result.signatures, i = 0; sig; sig = sig->next, i++)
{
TRACE_LOG4 ("sig[%i] = fpr %s, summary 0x%x, status %s",
i, sig->fpr, sig->summary, gpg_strerror (sig->status));
TRACE_LOG6 ("sig[%i] = timestamps 0x%x/0x%x flags:%s%s%s",
i, sig->timestamp, sig->exp_timestamp,
sig->wrong_key_usage ? "wrong key usage" : "",
sig->pka_trust == 1 ? "pka bad"
: (sig->pka_trust == 2 ? "pka_okay" : "pka RFU"),
sig->chain_model ? "chain model" : "");
TRACE_LOG5 ("sig[%i] = validity 0x%x (%s), algos %s/%s",
i, sig->validity, gpg_strerror (sig->validity_reason),
gpgme_pubkey_algo_name (sig->pubkey_algo),
gpgme_hash_algo_name (sig->hash_algo));
if (sig->pka_address)
{
TRACE_LOG2 ("sig[%i] = PKA address %s", i, sig->pka_address);
}
if (sig->notations)
{
TRACE_LOG1 ("sig[%i] = has notations (not shown)", i);
}
}
}
TRACE_SUC1 ("result=%p", &opd->result);
return &opd->result;
}
int
_gpgme_io_dup (int fd)
{
HANDLE handle = fd_to_handle (fd);
HANDLE new_handle = fd_to_handle (fd);
int i;
struct reader_context_s *rd_ctx;
struct writer_context_s *wt_ctx;
TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_dup", fd);
if (!DuplicateHandle (GetCurrentProcess(), handle,
GetCurrentProcess(), &new_handle,
0, FALSE, DUPLICATE_SAME_ACCESS))
{
TRACE_LOG1 ("DuplicateHandle failed: ec=%d\n", (int) GetLastError ());
/* FIXME: Translate error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
rd_ctx = find_reader (fd, 0);
if (rd_ctx)
{
/* No need for locking, as the only races are against the reader
thread itself, which doesn't touch refcount. */
rd_ctx->refcount++;
LOCK (reader_table_lock);
for (i = 0; i < reader_table_size; i++)
if (!reader_table[i].used)
break;
/* FIXME. */
assert (i != reader_table_size);
reader_table[i].fd = handle_to_fd (new_handle);
reader_table[i].context = rd_ctx;
reader_table[i].used = 1;
UNLOCK (reader_table_lock);
}
wt_ctx = find_writer (fd, 0);
if (wt_ctx)
{
/* No need for locking, as the only races are against the writer
thread itself, which doesn't touch refcount. */
wt_ctx->refcount++;
LOCK (writer_table_lock);
for (i = 0; i < writer_table_size; i++)
if (!writer_table[i].used)
break;
/* FIXME. */
assert (i != writer_table_size);
writer_table[i].fd = handle_to_fd (new_handle);
writer_table[i].context = wt_ctx;
writer_table[i].used = 1;
UNLOCK (writer_table_lock);
}
return TRACE_SYSRES (handle_to_fd (new_handle));
}
/* This function is similar to pipe_connect but uses a socketpair and
sets the I/O up to use sendmsg/recvmsg. */
static gpg_error_t
socketpair_connect (assuan_context_t ctx,
const char *name, const char **argv,
assuan_fd_t *fd_child_list,
void (*atfork) (void *opaque, int reserved),
void *atforkvalue)
{
gpg_error_t err;
int idx;
int fds[2];
char mypidstr[50];
pid_t pid;
int *child_fds = NULL;
int child_fds_cnt = 0;
struct at_socketpair_fork atp;
int rc;
TRACE_BEG3 (ctx, ASSUAN_LOG_CTX, "socketpair_connect", ctx,
"name=%s,atfork=%p,atforkvalue=%p", name ? name : "(null)",
atfork, atforkvalue);
atp.user_atfork = atfork;
atp.user_atforkvalue = atforkvalue;
atp.parent_pid = getpid ();
if (!ctx
|| (name && (!argv || !argv[0]))
|| (!name && !argv))
return _assuan_error (ctx, GPG_ERR_ASS_INV_VALUE);
if (! ctx->flags.no_fixsignals)
fix_signals ();
sprintf (mypidstr, "%lu", (unsigned long)getpid ());
if (fd_child_list)
while (fd_child_list[child_fds_cnt] != ASSUAN_INVALID_FD)
child_fds_cnt++;
child_fds = _assuan_malloc (ctx, (child_fds_cnt + 2) * sizeof (int));
if (! child_fds)
return TRACE_ERR (gpg_err_code_from_syserror ());
child_fds[1] = ASSUAN_INVALID_FD;
if (fd_child_list)
memcpy (&child_fds[1], fd_child_list, (child_fds_cnt + 1) * sizeof (int));
if (_assuan_socketpair (ctx, AF_LOCAL, SOCK_STREAM, 0, fds))
{
TRACE_LOG1 ("socketpair failed: %s", strerror (errno));
_assuan_free (ctx, child_fds);
return TRACE_ERR (GPG_ERR_ASS_GENERAL);
}
atp.peer_fd = fds[1];
child_fds[0] = fds[1];
rc = _assuan_spawn (ctx, &pid, name, argv, ASSUAN_INVALID_FD,
ASSUAN_INVALID_FD, child_fds, at_socketpair_fork_cb,
&atp, 0);
if (rc < 0)
{
err = gpg_err_code_from_syserror ();
_assuan_close (ctx, fds[0]);
_assuan_close (ctx, fds[1]);
_assuan_free (ctx, child_fds);
return TRACE_ERR (err);
}
/* For W32, the user needs to know the server-local names of the
inherited handles. Return them here. Note that the translation
of the peer socketpair fd (fd_child_list[0]) must be done by the
wrapper program based on the environment variable
_assuan_connection_fd. */
if (fd_child_list)
{
for (idx = 0; fd_child_list[idx] != -1; idx++)
/* We add 1 to skip over the socketpair end. */
fd_child_list[idx] = child_fds[idx + 1];
}
_assuan_free (ctx, child_fds);
/* If this is the server child process, exit early. */
if (! name && (*argv)[0] == 's')
{
_assuan_close (ctx, fds[0]);
return 0;
}
_assuan_close (ctx, fds[1]);
ctx->engine.release = _assuan_client_release;
ctx->finish_handler = _assuan_client_finish;
ctx->max_accepts = 1;
ctx->inbound.fd = fds[0];
ctx->outbound.fd = fds[0];
_assuan_init_uds_io (ctx);
err = initial_handshake (ctx);
if (err)
_assuan_reset (ctx);
return err;
}
static DWORD CALLBACK
reader (void *arg)
{
struct reader_context_s *ctx = arg;
int nbytes;
DWORD nread;
TRACE_BEG1 (DEBUG_SYSIO, "gpgme:reader", ctx->file_hd,
"thread=%p", ctx->thread_hd);
for (;;)
{
LOCK (ctx->mutex);
/* Leave a 1 byte gap so that we can see whether it is empty or
full. */
if ((ctx->writepos + 1) % READBUF_SIZE == ctx->readpos)
{
/* Wait for space. */
if (!ResetEvent (ctx->have_space_ev))
TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
UNLOCK (ctx->mutex);
TRACE_LOG ("waiting for space");
WaitForSingleObject (ctx->have_space_ev, INFINITE);
TRACE_LOG ("got space");
LOCK (ctx->mutex);
}
if (ctx->stop_me)
{
UNLOCK (ctx->mutex);
break;
}
nbytes = (ctx->readpos + READBUF_SIZE
- ctx->writepos - 1) % READBUF_SIZE;
if (nbytes > READBUF_SIZE - ctx->writepos)
nbytes = READBUF_SIZE - ctx->writepos;
UNLOCK (ctx->mutex);
TRACE_LOG1 ("reading %d bytes", nbytes);
if (!ReadFile (ctx->file_hd,
ctx->buffer + ctx->writepos, nbytes, &nread, NULL))
{
ctx->error_code = (int) GetLastError ();
if (ctx->error_code == ERROR_BROKEN_PIPE)
{
ctx->eof = 1;
TRACE_LOG ("got EOF (broken pipe)");
}
else
{
ctx->error = 1;
TRACE_LOG1 ("read error: ec=%d", ctx->error_code);
}
break;
}
if (!nread)
{
ctx->eof = 1;
TRACE_LOG ("got eof");
break;
}
TRACE_LOG1 ("got %u bytes", nread);
LOCK (ctx->mutex);
if (ctx->stop_me)
{
UNLOCK (ctx->mutex);
break;
}
ctx->writepos = (ctx->writepos + nread) % READBUF_SIZE;
if (!SetEvent (ctx->have_data_ev))
TRACE_LOG2 ("SetEvent (0x%x) failed: ec=%d", ctx->have_data_ev,
(int) GetLastError ());
UNLOCK (ctx->mutex);
}
/* Indicate that we have an error or EOF. */
if (!SetEvent (ctx->have_data_ev))
TRACE_LOG2 ("SetEvent (0x%x) failed: ec=%d", ctx->have_data_ev,
(int) GetLastError ());
SetEvent (ctx->stopped);
return TRACE_SUC ();
}
int
_gpgme_io_pipe (int filedes[2], int inherit_idx)
{
HANDLE rh;
HANDLE wh;
SECURITY_ATTRIBUTES sec_attr;
TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_pipe", filedes,
"inherit_idx=%i (GPGME uses it for %s)",
inherit_idx, inherit_idx ? "reading" : "writing");
memset (&sec_attr, 0, sizeof (sec_attr));
sec_attr.nLength = sizeof (sec_attr);
sec_attr.bInheritHandle = FALSE;
if (!CreatePipe (&rh, &wh, &sec_attr, PIPEBUF_SIZE))
{
TRACE_LOG1 ("CreatePipe failed: ec=%d", (int) GetLastError ());
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
/* Make one end inheritable. */
if (inherit_idx == 0)
{
struct writer_context_s *ctx;
HANDLE hd;
if (!DuplicateHandle (GetCurrentProcess(), rh,
GetCurrentProcess(), &hd, 0,
TRUE, DUPLICATE_SAME_ACCESS))
{
TRACE_LOG1 ("DuplicateHandle failed: ec=%d",
(int) GetLastError ());
CloseHandle (rh);
CloseHandle (wh);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
CloseHandle (rh);
rh = hd;
ctx = find_writer (handle_to_fd (wh), 0);
assert (ctx == NULL);
ctx = find_writer (handle_to_fd (wh), 1);
if (!ctx)
{
CloseHandle (rh);
CloseHandle (wh);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
}
else if (inherit_idx == 1)
{
struct reader_context_s *ctx;
HANDLE hd;
if (!DuplicateHandle( GetCurrentProcess(), wh,
GetCurrentProcess(), &hd, 0,
TRUE, DUPLICATE_SAME_ACCESS))
{
TRACE_LOG1 ("DuplicateHandle failed: ec=%d",
(int) GetLastError ());
CloseHandle (rh);
CloseHandle (wh);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
CloseHandle (wh);
wh = hd;
ctx = find_reader (handle_to_fd (rh), 0);
assert (ctx == NULL);
ctx = find_reader (handle_to_fd (rh), 1);
if (!ctx)
{
CloseHandle (rh);
CloseHandle (wh);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
}
filedes[0] = handle_to_fd (rh);
filedes[1] = handle_to_fd (wh);
return TRACE_SUC2 ("read=%p, write=%p", rh, wh);
}
int
_gpgme_io_read (int fd, void *buffer, size_t count)
{
int nread;
struct reader_context_s *ctx;
TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_read", fd,
"buffer=%p, count=%u", buffer, count);
ctx = find_reader (fd, 1);
if (!ctx)
{
errno = EBADF;
return TRACE_SYSRES (-1);
}
if (ctx->eof_shortcut)
return TRACE_SYSRES (0);
LOCK (ctx->mutex);
if (ctx->readpos == ctx->writepos && !ctx->error)
{
/* No data available. */
UNLOCK (ctx->mutex);
TRACE_LOG1 ("waiting for data from thread %p", ctx->thread_hd);
WaitForSingleObject (ctx->have_data_ev, INFINITE);
TRACE_LOG1 ("data from thread %p available", ctx->thread_hd);
LOCK (ctx->mutex);
}
if (ctx->readpos == ctx->writepos || ctx->error)
{
UNLOCK (ctx->mutex);
ctx->eof_shortcut = 1;
if (ctx->eof)
return TRACE_SYSRES (0);
if (!ctx->error)
{
TRACE_LOG ("EOF but ctx->eof flag not set");
return 0;
}
errno = ctx->error_code;
return TRACE_SYSRES (-1);
}
nread = ctx->readpos < ctx->writepos
? ctx->writepos - ctx->readpos
: READBUF_SIZE - ctx->readpos;
if (nread > count)
nread = count;
memcpy (buffer, ctx->buffer + ctx->readpos, nread);
ctx->readpos = (ctx->readpos + nread) % READBUF_SIZE;
if (ctx->readpos == ctx->writepos && !ctx->eof)
{
if (!ResetEvent (ctx->have_data_ev))
{
TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
UNLOCK (ctx->mutex);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
}
if (!SetEvent (ctx->have_space_ev))
{
TRACE_LOG2 ("SetEvent (0x%x) failed: ec=%d",
ctx->have_space_ev, (int) GetLastError ());
UNLOCK (ctx->mutex);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
UNLOCK (ctx->mutex);
TRACE_LOGBUF (buffer, nread);
return TRACE_SYSRES (nread);
}
static struct writer_context_s *
create_writer (HANDLE fd)
{
struct writer_context_s *ctx;
SECURITY_ATTRIBUTES sec_attr;
DWORD tid;
TRACE_BEG (DEBUG_SYSIO, "gpgme:create_writer", fd);
memset (&sec_attr, 0, sizeof sec_attr);
sec_attr.nLength = sizeof sec_attr;
sec_attr.bInheritHandle = FALSE;
ctx = calloc (1, sizeof *ctx);
if (!ctx)
{
TRACE_SYSERR (errno);
return NULL;
}
ctx->file_hd = fd;
ctx->refcount = 1;
ctx->have_data = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
if (ctx->have_data)
ctx->is_empty = CreateEvent (&sec_attr, TRUE, TRUE, NULL);
if (ctx->is_empty)
ctx->stopped = CreateEvent (&sec_attr, TRUE, FALSE, NULL);
if (!ctx->have_data || !ctx->is_empty || !ctx->stopped)
{
TRACE_LOG1 ("CreateEvent failed: ec=%d", (int) GetLastError ());
if (ctx->have_data)
CloseHandle (ctx->have_data);
if (ctx->is_empty)
CloseHandle (ctx->is_empty);
if (ctx->stopped)
CloseHandle (ctx->stopped);
free (ctx);
/* FIXME: Translate the error code. */
TRACE_SYSERR (EIO);
return NULL;
}
ctx->is_empty = set_synchronize (ctx->is_empty);
INIT_LOCK (ctx->mutex);
ctx->thread_hd = CreateThread (&sec_attr, 0, writer, ctx, 0, &tid );
if (!ctx->thread_hd)
{
TRACE_LOG1 ("CreateThread failed: ec=%d", (int) GetLastError ());
DESTROY_LOCK (ctx->mutex);
if (ctx->have_data)
CloseHandle (ctx->have_data);
if (ctx->is_empty)
CloseHandle (ctx->is_empty);
if (ctx->stopped)
CloseHandle (ctx->stopped);
free (ctx);
TRACE_SYSERR (EIO);
return NULL;
}
else
{
/* We set the priority of the thread higher because we know
that it only runs for a short time. This greatly helps to
increase the performance of the I/O. */
SetThreadPriority (ctx->thread_hd, get_desired_thread_priority ());
}
TRACE_SUC ();
return ctx;
}
int
_gpgme_io_write (int fd, const void *buffer, size_t count)
{
struct writer_context_s *ctx;
TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_write", fd,
"buffer=%p, count=%u", buffer, count);
TRACE_LOGBUF (buffer, count);
if (count == 0)
return TRACE_SYSRES (0);
ctx = find_writer (fd, 0);
if (!ctx)
return TRACE_SYSRES (-1);
LOCK (ctx->mutex);
if (!ctx->error && ctx->nbytes)
{
/* Bytes are pending for send. */
/* Reset the is_empty event. Better safe than sorry. */
if (!ResetEvent (ctx->is_empty))
{
TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
UNLOCK (ctx->mutex);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
UNLOCK (ctx->mutex);
TRACE_LOG1 ("waiting for empty buffer in thread %p", ctx->thread_hd);
WaitForSingleObject (ctx->is_empty, INFINITE);
TRACE_LOG1 ("thread %p buffer is empty", ctx->thread_hd);
LOCK (ctx->mutex);
}
if (ctx->error)
{
UNLOCK (ctx->mutex);
if (ctx->error_code == ERROR_NO_DATA)
errno = EPIPE;
else
errno = EIO;
return TRACE_SYSRES (-1);
}
/* If no error occured, the number of bytes in the buffer must be
zero. */
assert (!ctx->nbytes);
if (count > WRITEBUF_SIZE)
count = WRITEBUF_SIZE;
memcpy (ctx->buffer, buffer, count);
ctx->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 (ctx->is_empty))
{
TRACE_LOG1 ("ResetEvent failed: ec=%d", (int) GetLastError ());
UNLOCK (ctx->mutex);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
if (!SetEvent (ctx->have_data))
{
TRACE_LOG1 ("SetEvent failed: ec=%d", (int) GetLastError ());
UNLOCK (ctx->mutex);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
UNLOCK (ctx->mutex);
return TRACE_SYSRES ((int) count);
}
int
_gpgme_io_spawn (const char *path, char * const argv[], unsigned int flags,
struct spawn_fd_item_s *fd_list,
void (*atfork) (void *opaque, int reserved),
void *atforkvalue, pid_t *r_pid)
{
SECURITY_ATTRIBUTES sec_attr;
PROCESS_INFORMATION pi =
{
NULL, /* returns process handle */
0, /* returns primary thread handle */
0, /* returns pid */
0 /* returns tid */
};
STARTUPINFO si;
int cr_flags = (CREATE_DEFAULT_ERROR_MODE
| GetPriorityClass (GetCurrentProcess ()));
int i;
char **args;
char *arg_string;
/* FIXME. */
int debug_me = 0;
int tmp_fd;
char *tmp_name;
TRACE_BEG1 (DEBUG_SYSIO, "_gpgme_io_spawn", path,
"path=%s", path);
i = 0;
while (argv[i])
{
TRACE_LOG2 ("argv[%2i] = %s", i, argv[i]);
i++;
}
/* We do not inherit any handles by default, and just insert those
handles we want the child to have afterwards. But some handle
values occur on the command line, and we need to move
stdin/out/err to the right location. So we use a wrapper program
which gets the information from a temporary file. */
if (_gpgme_mkstemp (&tmp_fd, &tmp_name) < 0)
{
TRACE_LOG1 ("_gpgme_mkstemp failed: %s", strerror (errno));
return TRACE_SYSRES (-1);
}
TRACE_LOG1 ("tmp_name = %s", tmp_name);
args = calloc (2 + i + 1, sizeof (*args));
args[0] = (char *) _gpgme_get_w32spawn_path ();
args[1] = tmp_name;
args[2] = path;
memcpy (&args[3], &argv[1], i * sizeof (*args));
memset (&sec_attr, 0, sizeof sec_attr);
sec_attr.nLength = sizeof sec_attr;
sec_attr.bInheritHandle = FALSE;
arg_string = build_commandline (args);
free (args);
if (!arg_string)
{
close (tmp_fd);
DeleteFile (tmp_name);
return TRACE_SYSRES (-1);
}
memset (&si, 0, sizeof si);
si.cb = sizeof (si);
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.wShowWindow = debug_me ? SW_SHOW : SW_HIDE;
si.hStdInput = INVALID_HANDLE_VALUE;
si.hStdOutput = INVALID_HANDLE_VALUE;
si.hStdError = INVALID_HANDLE_VALUE;
cr_flags |= CREATE_SUSPENDED;
cr_flags |= DETACHED_PROCESS;
if (!CreateProcessA (_gpgme_get_w32spawn_path (),
arg_string,
&sec_attr, /* process security attributes */
&sec_attr, /* thread security attributes */
FALSE, /* inherit handles */
cr_flags, /* creation flags */
NULL, /* environment */
NULL, /* use current drive/directory */
&si, /* startup information */
&pi)) /* returns process information */
{
TRACE_LOG1 ("CreateProcess failed: ec=%d", (int) GetLastError ());
free (arg_string);
close (tmp_fd);
DeleteFile (tmp_name);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
free (arg_string);
if (flags & IOSPAWN_FLAG_ALLOW_SET_FG)
_gpgme_allow_set_foreground_window ((pid_t)pi.dwProcessId);
/* Insert the inherited handles. */
for (i = 0; fd_list[i].fd != -1; i++)
{
HANDLE hd;
/* Make it inheritable for the wrapper process. */
if (!DuplicateHandle (GetCurrentProcess(),
_get_osfhandle (giochannel_table[fd_list[i].fd].fd),
pi.hProcess, &hd, 0, TRUE, DUPLICATE_SAME_ACCESS))
{
TRACE_LOG1 ("DuplicateHandle failed: ec=%d", (int) GetLastError ());
TerminateProcess (pi.hProcess, 0);
/* Just in case TerminateProcess didn't work, let the
process fail on its own. */
ResumeThread (pi.hThread);
CloseHandle (pi.hThread);
CloseHandle (pi.hProcess);
close (tmp_fd);
DeleteFile (tmp_name);
/* FIXME: Should translate the error code. */
errno = EIO;
return TRACE_SYSRES (-1);
}
/* Return the child name of this handle. */
fd_list[i].peer_name = (int) hd;
}
/* Write the handle translation information to the temporary
file. */
{
/* Hold roughly MAX_TRANS quadruplets of 64 bit numbers in hex
notation: "0xFEDCBA9876543210" with an extra white space after
every quadruplet. 10*(19*4 + 1) - 1 = 769. This plans ahead
for a time when a HANDLE is 64 bit. */
#define BUFFER_MAX 800
char line[BUFFER_MAX + 1];
int res;
int written;
size_t len;
if ((flags & IOSPAWN_FLAG_ALLOW_SET_FG))
strcpy (line, "~1 \n");
else
strcpy (line, "\n");
for (i = 0; fd_list[i].fd != -1; i++)
{
/* Strip the newline. */
len = strlen (line) - 1;
/* Format is: Local name, stdin/stdout/stderr, peer name, argv idx. */
snprintf (&line[len], BUFFER_MAX - len, "0x%x %d 0x%x %d \n",
fd_list[i].fd, fd_list[i].dup_to,
fd_list[i].peer_name, fd_list[i].arg_loc);
/* Rather safe than sorry. */
line[BUFFER_MAX - 1] = '\n';
line[BUFFER_MAX] = '\0';
}
len = strlen (line);
written = 0;
do
{
res = write (tmp_fd, &line[written], len - written);
if (res > 0)
written += res;
}
while (res > 0 || (res < 0 && errno == EAGAIN));
}
close (tmp_fd);
/* The temporary file is deleted by the gpgme-w32spawn process
(hopefully). */
TRACE_LOG4 ("CreateProcess ready: hProcess=%p, hThread=%p, "
"dwProcessID=%d, dwThreadId=%d",
pi.hProcess, pi.hThread,
(int) pi.dwProcessId, (int) pi.dwThreadId);
if (r_pid)
*r_pid = (pid_t)pi.dwProcessId;
if (ResumeThread (pi.hThread) < 0)
TRACE_LOG1 ("ResumeThread failed: ec=%d", (int) GetLastError ());
if (!CloseHandle (pi.hThread))
TRACE_LOG1 ("CloseHandle of thread failed: ec=%d",
(int) GetLastError ());
TRACE_LOG1 ("process=%p", pi.hProcess);
/* We don't need to wait for the process. */
if (!CloseHandle (pi.hProcess))
TRACE_LOG1 ("CloseHandle of process failed: ec=%d",
(int) GetLastError ());
if (! (flags & IOSPAWN_FLAG_NOCLOSE))
{
for (i = 0; fd_list[i].fd != -1; i++)
_gpgme_io_close (fd_list[i].fd);
}
for (i = 0; fd_list[i].fd != -1; i++)
if (fd_list[i].dup_to == -1)
TRACE_LOG3 ("fd[%i] = 0x%x -> 0x%x", i, fd_list[i].fd,
fd_list[i].peer_name);
else
TRACE_LOG4 ("fd[%i] = 0x%x -> 0x%x (std%s)", i, fd_list[i].fd,
fd_list[i].peer_name, (fd_list[i].dup_to == 0) ? "in" :
((fd_list[i].dup_to == 1) ? "out" : "err"));
return TRACE_SYSRES (0);
}
static ssize_t
__assuan_read (assuan_context_t ctx, assuan_fd_t fd, void *buffer, size_t size)
{
/* Due to the peculiarities of the W32 API we can't use read for a
network socket and thus we try to use recv first and fallback to
read if recv detects that it is not a network socket. */
int res;
TRACE_BEG3 (ctx, ASSUAN_LOG_SYSIO, "__assuan_read", ctx,
"fd=0x%x, buffer=%p, size=%i", fd, buffer, size);
#ifdef HAVE_W32CE_SYSTEM
/* This is a bit of a hack to support stdin over ssh. Note that
fread buffers fully while getchar is line buffered. Weird, but
that's the way it is. ASSUAN_STDIN and ASSUAN_STDOUT are
special handle values that shouldn't occur in the wild. */
if (fd == ASSUAN_STDIN)
{
int i = 0;
int chr;
while (i < size)
{
chr = getchar();
if (chr == EOF)
break;
((char*)buffer)[i++] = (char) chr;
if (chr == '\n')
break;
}
return TRACE_SYSRES (i);
}
#endif
res = recv (HANDLE2SOCKET (fd), buffer, size, 0);
if (res == -1)
{
TRACE_LOG1 ("recv failed: rc=%d", (int)WSAGetLastError ());
switch (WSAGetLastError ())
{
case WSAENOTSOCK:
{
DWORD nread = 0;
res = ReadFile (fd, buffer, size, &nread, NULL);
if (! res)
{
TRACE_LOG1 ("ReadFile failed: rc=%d", (int)GetLastError ());
switch (GetLastError ())
{
case ERROR_BROKEN_PIPE:
gpg_err_set_errno (EPIPE);
break;
case ERROR_PIPE_NOT_CONNECTED:
case ERROR_BUSY:
gpg_err_set_errno (EAGAIN);
break;
default:
gpg_err_set_errno (EIO);
}
res = -1;
}
else
res = (int) nread;
}
break;
case WSAEWOULDBLOCK:
gpg_err_set_errno (EAGAIN);
break;
case ERROR_BROKEN_PIPE:
gpg_err_set_errno (EPIPE);
break;
default:
gpg_err_set_errno (EIO);
break;
}
}
return TRACE_SYSRES (res);
}