402 lines
10 KiB
C
402 lines
10 KiB
C
/* wait-global.c
|
||
* Copyright (C) 2000 Werner Koch (dd9jn)
|
||
* Copyright (C) 2001, 2002, 2003, 2004, 2005 g10 Code GmbH
|
||
*
|
||
* This file is part of GPGME.
|
||
*
|
||
* GPGME 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.
|
||
*
|
||
* GPGME is distributed in the hope that it will be useful, but
|
||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with this program; if not, see <https://gnu.org/licenses/>.
|
||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||
*/
|
||
|
||
#if HAVE_CONFIG_H
|
||
#include <config.h>
|
||
#endif
|
||
#include <stdlib.h>
|
||
#include <assert.h>
|
||
#include <string.h>
|
||
#include <errno.h>
|
||
|
||
#include "gpgme.h"
|
||
#include "sema.h"
|
||
#include "util.h"
|
||
#include "context.h"
|
||
#include "wait.h"
|
||
#include "priv-io.h"
|
||
#include "ops.h"
|
||
#include "debug.h"
|
||
|
||
/* The global event loop is used for all asynchronous operations
|
||
(except key listing) for which no user I/O callbacks are specified.
|
||
|
||
A context sets up its initial I/O callbacks and then sends the
|
||
GPGME_EVENT_START event. After that, it is added to the global
|
||
list of active contexts.
|
||
|
||
The gpgme_wait function contains a select() loop over all file
|
||
descriptors in all active contexts. If an error occurs, it closes
|
||
all fds in that context and moves the context to the global done
|
||
list. Likewise, if a context has removed all I/O callbacks, it is
|
||
moved to the global done list.
|
||
|
||
All contexts in the global done list are eligible for being
|
||
returned by gpgme_wait if requested by the caller. */
|
||
|
||
/* The ctx_list_lock protects the list of active and done contexts.
|
||
Insertion into any of these lists is only allowed when the lock is
|
||
held. This allows a muli-threaded program to loop over gpgme_wait
|
||
and in parallel start asynchronous gpgme operations.
|
||
|
||
However, the fd tables in the contexts are not protected by this
|
||
lock. They are only allowed to change either before the context is
|
||
added to the active list (ie, before the start event is signalled)
|
||
or in a callback handler. */
|
||
DEFINE_STATIC_LOCK (ctx_list_lock);
|
||
|
||
/* A ctx_list_item is an item in the global list of active or done
|
||
contexts. */
|
||
struct ctx_list_item
|
||
{
|
||
/* Every ctx_list_item is an element in a doubly linked list. The
|
||
list pointers are protected by the ctx_list_lock. */
|
||
struct ctx_list_item *next;
|
||
struct ctx_list_item *prev;
|
||
|
||
gpgme_ctx_t ctx;
|
||
/* The status is set when the ctx is moved to the done list. */
|
||
gpgme_error_t status;
|
||
gpgme_error_t op_err;
|
||
};
|
||
|
||
/* The active list contains all contexts that are in the global event
|
||
loop, have active I/O callbacks, and have already seen the start
|
||
event. */
|
||
static struct ctx_list_item *ctx_active_list;
|
||
|
||
/* The done list contains all contexts that have previously been
|
||
active but now are not active any longer, either because they
|
||
finished successfully or an I/O callback returned an error. The
|
||
status field in the list item contains the error value (or 0 if
|
||
successful). */
|
||
static struct ctx_list_item *ctx_done_list;
|
||
|
||
|
||
/* Enter the context CTX into the active list. */
|
||
static gpgme_error_t
|
||
ctx_active (gpgme_ctx_t ctx)
|
||
{
|
||
struct ctx_list_item *li = malloc (sizeof (struct ctx_list_item));
|
||
if (!li)
|
||
return gpg_error_from_syserror ();
|
||
li->ctx = ctx;
|
||
|
||
LOCK (ctx_list_lock);
|
||
/* Add LI to active list. */
|
||
li->next = ctx_active_list;
|
||
li->prev = NULL;
|
||
if (ctx_active_list)
|
||
ctx_active_list->prev = li;
|
||
ctx_active_list = li;
|
||
UNLOCK (ctx_list_lock);
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* Enter the context CTX into the done list with status STATUS. */
|
||
static void
|
||
ctx_done (gpgme_ctx_t ctx, gpgme_error_t status, gpgme_error_t op_err)
|
||
{
|
||
struct ctx_list_item *li;
|
||
|
||
LOCK (ctx_list_lock);
|
||
li = ctx_active_list;
|
||
while (li && li->ctx != ctx)
|
||
li = li->next;
|
||
assert (li);
|
||
|
||
/* Remove LI from active list. */
|
||
if (li->next)
|
||
li->next->prev = li->prev;
|
||
if (li->prev)
|
||
li->prev->next = li->next;
|
||
else
|
||
ctx_active_list = li->next;
|
||
|
||
li->status = status;
|
||
li->op_err = op_err;
|
||
|
||
/* Add LI to done list. */
|
||
li->next = ctx_done_list;
|
||
li->prev = NULL;
|
||
if (ctx_done_list)
|
||
ctx_done_list->prev = li;
|
||
ctx_done_list = li;
|
||
UNLOCK (ctx_list_lock);
|
||
}
|
||
|
||
|
||
/* Find finished context CTX (or any context if CTX is NULL) and
|
||
return its status in STATUS after removing it from the done list.
|
||
If a matching context could be found, return it. Return NULL if no
|
||
context could be found. */
|
||
static gpgme_ctx_t
|
||
ctx_wait (gpgme_ctx_t ctx, gpgme_error_t *status, gpgme_error_t *op_err)
|
||
{
|
||
struct ctx_list_item *li;
|
||
|
||
LOCK (ctx_list_lock);
|
||
li = ctx_done_list;
|
||
if (ctx)
|
||
{
|
||
/* A specific context is requested. */
|
||
while (li && li->ctx != ctx)
|
||
li = li->next;
|
||
}
|
||
if (li)
|
||
{
|
||
ctx = li->ctx;
|
||
if (status)
|
||
*status = li->status;
|
||
if (op_err)
|
||
*op_err = li->op_err;
|
||
|
||
/* Remove LI from done list. */
|
||
if (li->next)
|
||
li->next->prev = li->prev;
|
||
if (li->prev)
|
||
li->prev->next = li->next;
|
||
else
|
||
ctx_done_list = li->next;
|
||
free (li);
|
||
}
|
||
else
|
||
ctx = NULL;
|
||
UNLOCK (ctx_list_lock);
|
||
return ctx;
|
||
}
|
||
|
||
|
||
/* Internal I/O callback functions. */
|
||
|
||
/* The add_io_cb and remove_io_cb handlers are shared with the private
|
||
event loops. */
|
||
|
||
void
|
||
_gpgme_wait_global_event_cb (void *data, gpgme_event_io_t type,
|
||
void *type_data)
|
||
{
|
||
gpgme_ctx_t ctx = (gpgme_ctx_t) data;
|
||
|
||
assert (ctx);
|
||
|
||
switch (type)
|
||
{
|
||
case GPGME_EVENT_START:
|
||
{
|
||
gpgme_error_t err = ctx_active (ctx);
|
||
|
||
if (err)
|
||
/* An error occurred. Close all fds in this context, and
|
||
send the error in a done event. */
|
||
_gpgme_cancel_with_err (ctx, err, 0);
|
||
}
|
||
break;
|
||
|
||
case GPGME_EVENT_DONE:
|
||
{
|
||
gpgme_io_event_done_data_t done_data =
|
||
(gpgme_io_event_done_data_t) type_data;
|
||
|
||
ctx_done (ctx, done_data->err, done_data->op_err);
|
||
}
|
||
break;
|
||
|
||
case GPGME_EVENT_NEXT_KEY:
|
||
assert (!"Unexpected event GPGME_EVENT_NEXT_KEY");
|
||
break;
|
||
|
||
case GPGME_EVENT_NEXT_TRUSTITEM:
|
||
assert (!"Unexpected event GPGME_EVENT_NEXT_TRUSTITEM");
|
||
break;
|
||
|
||
default:
|
||
assert (!"Unexpected event");
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* Perform asynchronous operations in the global event loop (ie, any
|
||
asynchronous operation except key listing and trustitem listing
|
||
operations). If CTX is not a null pointer, the function will
|
||
return if the asynchronous operation in the context CTX finished.
|
||
Otherwise the function will return if any asynchronous operation
|
||
finished. If HANG is zero, the function will not block for a long
|
||
time. Otherwise the function does not return until an operation
|
||
matching CTX finished.
|
||
|
||
If a matching context finished, it is returned, and *STATUS is set
|
||
to the error value of the operation in that context. Otherwise, if
|
||
the timeout expires, NULL is returned and *STATUS is 0. If an
|
||
error occurs, NULL is returned and *STATUS is set to the error
|
||
value. */
|
||
gpgme_ctx_t
|
||
gpgme_wait_ext (gpgme_ctx_t ctx, gpgme_error_t *status,
|
||
gpgme_error_t *op_err, int hang)
|
||
{
|
||
do
|
||
{
|
||
unsigned int i = 0;
|
||
struct ctx_list_item *li;
|
||
struct fd_table fdt;
|
||
int nr;
|
||
|
||
/* Collect the active file descriptors. */
|
||
LOCK (ctx_list_lock);
|
||
for (li = ctx_active_list; li; li = li->next)
|
||
i += li->ctx->fdt.size;
|
||
fdt.fds = malloc (i * sizeof (struct io_select_fd_s));
|
||
if (!fdt.fds)
|
||
{
|
||
int saved_err = gpg_error_from_syserror ();
|
||
UNLOCK (ctx_list_lock);
|
||
if (status)
|
||
*status = saved_err;
|
||
if (op_err)
|
||
*op_err = 0;
|
||
return NULL;
|
||
}
|
||
fdt.size = i;
|
||
i = 0;
|
||
for (li = ctx_active_list; li; li = li->next)
|
||
{
|
||
memcpy (&fdt.fds[i], li->ctx->fdt.fds,
|
||
li->ctx->fdt.size * sizeof (struct io_select_fd_s));
|
||
i += li->ctx->fdt.size;
|
||
}
|
||
UNLOCK (ctx_list_lock);
|
||
|
||
nr = _gpgme_io_select (fdt.fds, fdt.size, 0);
|
||
if (nr < 0)
|
||
{
|
||
int saved_err = gpg_error_from_syserror ();
|
||
free (fdt.fds);
|
||
if (status)
|
||
*status = saved_err;
|
||
if (op_err)
|
||
*op_err = 0;
|
||
return NULL;
|
||
}
|
||
|
||
for (i = 0; i < fdt.size && nr; i++)
|
||
{
|
||
if (fdt.fds[i].fd != -1 && fdt.fds[i].signaled)
|
||
{
|
||
gpgme_ctx_t ictx;
|
||
gpgme_error_t err = 0;
|
||
gpgme_error_t local_op_err = 0;
|
||
struct wait_item_s *item;
|
||
|
||
assert (nr);
|
||
nr--;
|
||
|
||
item = (struct wait_item_s *) fdt.fds[i].opaque;
|
||
assert (item);
|
||
ictx = item->ctx;
|
||
assert (ictx);
|
||
|
||
LOCK (ctx->lock);
|
||
if (ctx->canceled)
|
||
err = gpg_error (GPG_ERR_CANCELED);
|
||
UNLOCK (ctx->lock);
|
||
|
||
if (!err)
|
||
err = _gpgme_run_io_cb (&fdt.fds[i], 0, &local_op_err);
|
||
if (err || local_op_err)
|
||
{
|
||
/* An error occurred. Close all fds in this context,
|
||
and signal it. */
|
||
_gpgme_cancel_with_err (ictx, err, local_op_err);
|
||
|
||
/* Break out of the loop, and retry the select()
|
||
from scratch, because now all fds should be
|
||
gone. */
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
free (fdt.fds);
|
||
|
||
/* Now some contexts might have finished successfully. */
|
||
LOCK (ctx_list_lock);
|
||
retry:
|
||
for (li = ctx_active_list; li; li = li->next)
|
||
{
|
||
gpgme_ctx_t actx = li->ctx;
|
||
|
||
for (i = 0; i < actx->fdt.size; i++)
|
||
if (actx->fdt.fds[i].fd != -1)
|
||
break;
|
||
if (i == actx->fdt.size)
|
||
{
|
||
struct gpgme_io_event_done_data data;
|
||
data.err = 0;
|
||
data.op_err = 0;
|
||
|
||
/* FIXME: This does not perform too well. We have to
|
||
release the lock because the I/O event handler
|
||
acquires it to remove the context from the active
|
||
list. Two alternative strategies are worth
|
||
considering: Either implement the DONE event handler
|
||
here in a lock-free manner, or save a list of all
|
||
contexts to be released and call the DONE events
|
||
afterwards. */
|
||
UNLOCK (ctx_list_lock);
|
||
_gpgme_engine_io_event (actx->engine, GPGME_EVENT_DONE, &data);
|
||
LOCK (ctx_list_lock);
|
||
goto retry;
|
||
}
|
||
}
|
||
UNLOCK (ctx_list_lock);
|
||
|
||
{
|
||
gpgme_ctx_t dctx = ctx_wait (ctx, status, op_err);
|
||
|
||
if (dctx)
|
||
{
|
||
ctx = dctx;
|
||
hang = 0;
|
||
}
|
||
else if (!hang)
|
||
{
|
||
ctx = NULL;
|
||
if (status)
|
||
*status = 0;
|
||
if (op_err)
|
||
*op_err = 0;
|
||
}
|
||
}
|
||
}
|
||
while (hang);
|
||
|
||
return ctx;
|
||
}
|
||
|
||
|
||
gpgme_ctx_t
|
||
gpgme_wait (gpgme_ctx_t ctx, gpgme_error_t *status, int hang)
|
||
{
|
||
return gpgme_wait_ext (ctx, status, NULL, hang);
|
||
}
|