summaryrefslogtreecommitdiffstats
path: root/libkdenetwork/libgpgme-copy/gpgme/wait-global.c
diff options
context:
space:
mode:
Diffstat (limited to 'libkdenetwork/libgpgme-copy/gpgme/wait-global.c')
-rw-r--r--libkdenetwork/libgpgme-copy/gpgme/wait-global.c384
1 files changed, 0 insertions, 384 deletions
diff --git a/libkdenetwork/libgpgme-copy/gpgme/wait-global.c b/libkdenetwork/libgpgme-copy/gpgme/wait-global.c
deleted file mode 100644
index bfa618dd1..000000000
--- a/libkdenetwork/libgpgme-copy/gpgme/wait-global.c
+++ /dev/null
@@ -1,384 +0,0 @@
-/* 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, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- 02110-1301, USA. */
-
-#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"
-
-/* 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;
-};
-
-/* 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_errno (errno);
- 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)
-{
- 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;
-
- /* 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)
-{
- 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;
-
- /* 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 occured. Close all fds in this context, and
- send the error in a done event. */
- unsigned int idx;
-
- for (idx = 0; idx <= ctx->fdt.size; idx++)
- if (ctx->fdt.fds[idx].fd != -1)
- _gpgme_io_close (ctx->fdt.fds[idx].fd);
- _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &err);
- }
- }
- break;
-
- case GPGME_EVENT_DONE:
- {
- gpgme_error_t *errp = (gpgme_error_t *) type_data;
- assert (errp);
- ctx_done (ctx, *errp);
- }
- 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 (gpgme_ctx_t ctx, gpgme_error_t *status, 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_errno = errno;
- UNLOCK (ctx_list_lock);
- if (status)
- *status = gpg_error_from_errno (saved_errno);
- 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_errno = errno;
- free (fdt.fds);
- if (status)
- *status = gpg_error_from_errno (saved_errno);
- 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;
- struct wait_item_s *item;
-
- assert (nr);
- nr--;
-
- item = (struct wait_item_s *) fdt.fds[i].opaque;
- assert (item);
- ictx = item->ctx;
- assert (ictx);
-
- err = _gpgme_run_io_cb (&fdt.fds[i], 0);
- if (err)
- {
- /* An error occured. Close all fds in this context,
- and signal it. */
- unsigned int idx;
-
- for (idx = 0; idx < ictx->fdt.size; idx++)
- if (ictx->fdt.fds[idx].fd != -1)
- _gpgme_io_close (ictx->fdt.fds[idx].fd);
- _gpgme_engine_io_event (ictx->engine, GPGME_EVENT_DONE,
- &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)
- {
- gpgme_error_t 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, &err);
- LOCK (ctx_list_lock);
- goto retry;
- }
- }
- UNLOCK (ctx_list_lock);
-
- {
- gpgme_ctx_t dctx = ctx_wait (ctx, status);
-
- if (dctx)
- {
- ctx = dctx;
- hang = 0;
- }
- else if (!hang)
- {
- ctx = NULL;
- if (status)
- *status = 0;
- }
- }
- }
- while (hang);
-
- return ctx;
-}
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-26 02:16:17 +0000