3e50d68ae4
2002-02-06 Marcus Brinkmann <marcus@g10code.de> * gpgme.texi (Waiting For Completion): Adjust doc to changes in the code. gpgme/ 2002-02-06 Marcus Brinkmann <marcus@g10code.de> * wait.c (gpgme_wait): Add new argument STATUS, in which the status of the returned context is returned. (_gpgme_wait_on_condition): Rework the function a bit, to make it aware of cancelled processes, and to allow to use gpgme_wait with CTX being NULL (as documented in the source). (struct proc_s): New member REPORTED. * gpgme.h: Fix prototype. * verify.c (gpgme_op_verify): Fix use of gpgme_wait. * sign.c (gpgme_op_sign): * import.c (gpgme_op_import): * genkey.c (gpgme_op_genkey): * export.c (gpgme_op_export): * encrypt.c (gpgme_op_encrypt): * delete.c (gpgme_op_delete): * decrypt-verify.c (gpgme_op_decrypt_verify):
450 lines
9.9 KiB
C
450 lines
9.9 KiB
C
/* wait.c
|
|
* Copyright (C) 2000 Werner Koch (dd9jn)
|
|
* Copyright (C) 2001, 2001 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 General Public License as published by
|
|
* the Free Software Foundation; either version 2 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <sys/types.h>
|
|
#include "syshdr.h"
|
|
|
|
#include "util.h"
|
|
#include "context.h"
|
|
#include "ops.h"
|
|
#include "wait.h"
|
|
#include "sema.h"
|
|
#include "io.h"
|
|
#include "engine.h"
|
|
|
|
struct wait_item_s;
|
|
struct proc_s;
|
|
|
|
static struct proc_s *proc_queue;
|
|
DEFINE_STATIC_LOCK (proc_queue_lock);
|
|
|
|
static int fd_table_size;
|
|
static struct io_select_fd_s *fd_table;
|
|
DEFINE_STATIC_LOCK (fd_table_lock);
|
|
|
|
static GpgmeIdleFunc idle_function;
|
|
|
|
|
|
struct proc_s
|
|
{
|
|
struct proc_s *next;
|
|
int pid;
|
|
GpgmeCtx ctx;
|
|
struct wait_item_s *handler_list;
|
|
/* Non-zero if the process has been completed. */
|
|
int done;
|
|
/* Non-zero if the status for this process has been returned
|
|
already. */
|
|
int reported;
|
|
};
|
|
|
|
struct wait_item_s {
|
|
struct wait_item_s *next;
|
|
int (*handler)(void*,int,int);
|
|
void *handler_value;
|
|
int inbound; /* this is an inbound data handler fd */
|
|
struct proc_s *proc; /* backlink */
|
|
int done;
|
|
int frozen; /* copy of the frozen flag from the fd_table */
|
|
};
|
|
|
|
|
|
|
|
static int do_select ( void );
|
|
static void run_idle (void);
|
|
|
|
|
|
/* only to be called with a locked proc_queue */
|
|
static int
|
|
count_running_fds (struct proc_s *proc)
|
|
{
|
|
struct wait_item_s *q;
|
|
int count = 0;
|
|
|
|
for (q = proc->handler_list; q; q=q->next)
|
|
{
|
|
if (!q->frozen && !q->done)
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/* only to be called with a locked proc_queue */
|
|
static void
|
|
set_process_done (struct proc_s *proc)
|
|
{
|
|
struct wait_item_s *q, *q2;
|
|
int i;
|
|
|
|
assert (proc);
|
|
DEBUG2 ("set_process_done(%p) pid=%d", proc, proc->pid);
|
|
LOCK (fd_table_lock);
|
|
for (q = proc->handler_list; q; q=q2)
|
|
{
|
|
q2 = q->next;
|
|
for (i = 0; i < fd_table_size; i++)
|
|
{
|
|
if (fd_table[i].fd != -1 && q == fd_table[i].opaque)
|
|
{
|
|
fd_table[i].opaque = NULL;
|
|
fd_table[i].fd = -1;
|
|
}
|
|
}
|
|
xfree (q);
|
|
}
|
|
UNLOCK (fd_table_lock);
|
|
proc->handler_list = NULL;
|
|
proc->done = 1;
|
|
}
|
|
|
|
void
|
|
_gpgme_remove_proc_from_wait_queue (int pid)
|
|
{
|
|
struct proc_s *proc, *last;
|
|
|
|
DEBUG1 ("removing process %d", pid);
|
|
LOCK (proc_queue_lock);
|
|
for (last = NULL, proc = proc_queue; proc; last = proc, proc = proc->next)
|
|
{
|
|
if (proc->pid == pid)
|
|
{
|
|
set_process_done (proc);
|
|
if (!last)
|
|
proc_queue = proc->next;
|
|
else
|
|
last->next = proc->next;
|
|
xfree (proc);
|
|
break;
|
|
}
|
|
}
|
|
UNLOCK (proc_queue_lock);
|
|
}
|
|
|
|
|
|
/**
|
|
* gpgme_wait:
|
|
* @c:
|
|
* @hang:
|
|
*
|
|
* Wait for a finished request, if @c is given the function does only
|
|
* wait on a finished request for that context, otherwise it will return
|
|
* on any request. When @hang is true the function will wait, otherwise
|
|
* it will return immediately when there is no pending finished request.
|
|
*
|
|
* Return value: Context of the finished request or NULL if @hang is false
|
|
* and no (or the given) request has finished.
|
|
**/
|
|
GpgmeCtx
|
|
gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang)
|
|
{
|
|
GpgmeCtx retctx = _gpgme_wait_on_condition (ctx, hang, NULL);
|
|
if (status)
|
|
*status = retctx->error;
|
|
return retctx;
|
|
}
|
|
|
|
GpgmeCtx
|
|
_gpgme_wait_on_condition (GpgmeCtx ctx, int hang, volatile int *cond)
|
|
{
|
|
DEBUG3 ("waiting... ctx=%p hang=%d cond=%p", ctx, hang, cond);
|
|
do
|
|
{
|
|
int any = 0;
|
|
struct proc_s *proc;
|
|
|
|
do_select ();
|
|
|
|
if (cond && *cond)
|
|
hang = 0;
|
|
else
|
|
{
|
|
LOCK (proc_queue_lock);
|
|
for (proc = proc_queue; proc; proc = proc->next)
|
|
{
|
|
/* A process is done if it has completed voluntarily, or
|
|
if the context it lived in was canceled. */
|
|
if (!proc->done && !count_running_fds (proc))
|
|
set_process_done (proc);
|
|
else if (!proc->done && proc->ctx->cancel)
|
|
{
|
|
set_process_done (proc);
|
|
proc->ctx->cancel = 0;
|
|
proc->ctx->error = mk_error (Canceled);
|
|
}
|
|
/* A process that is done is eligible for election if it
|
|
is in the requested context or if it was not yet
|
|
reported. */
|
|
if (proc->done && (proc->ctx == ctx || (!ctx && !proc->reported)))
|
|
{
|
|
if (!ctx)
|
|
ctx = proc->ctx;
|
|
hang = 0;
|
|
ctx->pending = 0;
|
|
proc->reported = 1;
|
|
}
|
|
if (!proc->done)
|
|
any = 1;
|
|
}
|
|
UNLOCK (proc_queue_lock);
|
|
if (!any)
|
|
hang = 0;
|
|
}
|
|
/* fixme: We should check here for hanging processes. */
|
|
|
|
if (hang)
|
|
run_idle ();
|
|
}
|
|
while (hang && (!ctx || !ctx->cancel));
|
|
if (ctx && ctx->cancel)
|
|
{
|
|
/* FIXME: Paranoia? */
|
|
ctx->cancel = 0;
|
|
ctx->pending = 0;
|
|
ctx->error = mk_error (Canceled);
|
|
}
|
|
return ctx;
|
|
}
|
|
|
|
|
|
/*
|
|
* We use this function to do the select stuff for all running
|
|
* gpgs. A future version might provide a facility to delegate
|
|
* those selects to the GDK select stuff.
|
|
* This function must be called only by one thread!!
|
|
* Returns: 0 = nothing to run
|
|
* 1 = did run something
|
|
*/
|
|
|
|
static int
|
|
do_select (void)
|
|
{
|
|
int i, n;
|
|
int any = 0;
|
|
|
|
n = _gpgme_io_select (fd_table, fd_table_size);
|
|
if (n <= 0)
|
|
return 0; /* error or timeout */
|
|
|
|
for (i = 0; i < fd_table_size && n; i++)
|
|
{
|
|
if (fd_table[i].fd != -1 && fd_table[i].signaled
|
|
&& !fd_table[i].frozen)
|
|
{
|
|
struct wait_item_s *q;
|
|
|
|
assert (n);
|
|
n--;
|
|
|
|
q = fd_table[i].opaque;
|
|
assert (q);
|
|
assert (q->proc);
|
|
assert (!q->done);
|
|
any = 1;
|
|
if (q->handler (q->handler_value,
|
|
q->proc->pid, fd_table[i].fd))
|
|
{
|
|
DEBUG2 ("setting fd %d (q=%p) done", fd_table[i].fd, q);
|
|
q->done = 1;
|
|
/* Free the table entry. */
|
|
LOCK (fd_table_lock);
|
|
fd_table[i].for_read = 0;
|
|
fd_table[i].for_write = 0;
|
|
fd_table[i].fd = -1;
|
|
fd_table[i].opaque = NULL;
|
|
UNLOCK (fd_table_lock);
|
|
}
|
|
}
|
|
}
|
|
|
|
return any;
|
|
}
|
|
|
|
|
|
/*
|
|
* called by rungpg.c to register something for select()
|
|
*/
|
|
GpgmeError
|
|
_gpgme_register_pipe_handler (void *opaque,
|
|
int (*handler)(void*,int,int),
|
|
void *handler_value,
|
|
int pid, int fd, int inbound)
|
|
{
|
|
GpgmeCtx ctx = opaque;
|
|
struct wait_item_s *q;
|
|
struct proc_s *proc;
|
|
int i;
|
|
|
|
assert (opaque);
|
|
assert (handler);
|
|
|
|
/* Allocate a structure to hold info about the handler. */
|
|
q = xtrycalloc (1, sizeof *q);
|
|
if (!q)
|
|
return mk_error (Out_Of_Core);
|
|
q->inbound = inbound;
|
|
q->handler = handler;
|
|
q->handler_value = handler_value;
|
|
|
|
/* Put this into the process queue. */
|
|
LOCK (proc_queue_lock);
|
|
for (proc = proc_queue; proc && proc->pid != pid; proc = proc->next)
|
|
;
|
|
if (!proc)
|
|
{
|
|
/* A new process. */
|
|
proc = xtrycalloc (1, sizeof *proc);
|
|
if (!proc)
|
|
{
|
|
UNLOCK (proc_queue_lock);
|
|
return mk_error (Out_Of_Core);
|
|
}
|
|
proc->pid = pid;
|
|
proc->ctx = ctx;
|
|
proc->next = proc_queue;
|
|
proc_queue = proc;
|
|
}
|
|
assert (proc->ctx == ctx);
|
|
q->proc = proc;
|
|
q->next = proc->handler_list;
|
|
proc->handler_list = q;
|
|
UNLOCK (proc_queue_lock);
|
|
|
|
LOCK (fd_table_lock);
|
|
again:
|
|
for (i=0; i < fd_table_size; i++)
|
|
{
|
|
if (fd_table[i].fd == -1)
|
|
{
|
|
fd_table[i].fd = fd;
|
|
fd_table[i].for_read = inbound;
|
|
fd_table[i].for_write = !inbound;
|
|
fd_table[i].signaled = 0;
|
|
fd_table[i].frozen = 0;
|
|
fd_table[i].opaque = q;
|
|
UNLOCK (fd_table_lock);
|
|
return 0;
|
|
}
|
|
}
|
|
if ( fd_table_size < 50 ) {
|
|
/* FIXME: We have to wait until there are no other readers of the
|
|
* table, i.e that the io_select is not active in another thread */
|
|
struct io_select_fd_s *tmp;
|
|
|
|
tmp = xtryrealloc (fd_table, (fd_table_size + 10) * sizeof *tmp);
|
|
if (tmp)
|
|
{
|
|
for (i = 0; i < 10; i++)
|
|
tmp[fd_table_size+i].fd = -1;
|
|
fd_table_size += i;
|
|
fd_table = tmp;
|
|
goto again;
|
|
}
|
|
}
|
|
|
|
UNLOCK (fd_table_lock);
|
|
xfree (q);
|
|
/* FIXME: Remove the proc table entry. */
|
|
return mk_error (Too_Many_Procs);
|
|
}
|
|
|
|
|
|
void
|
|
_gpgme_freeze_fd (int fd)
|
|
{
|
|
int i;
|
|
|
|
LOCK (fd_table_lock);
|
|
for (i = 0; i < fd_table_size; i++)
|
|
{
|
|
if (fd_table[i].fd == fd)
|
|
{
|
|
struct wait_item_s *q;
|
|
|
|
fd_table[i].frozen = 1;
|
|
q = fd_table[i].opaque;
|
|
if (q)
|
|
q->frozen = 1;
|
|
DEBUG2 ("fd %d frozen (q=%p)", fd, q);
|
|
break;
|
|
}
|
|
}
|
|
UNLOCK (fd_table_lock);
|
|
}
|
|
|
|
void
|
|
_gpgme_thaw_fd (int fd)
|
|
{
|
|
int i;
|
|
|
|
LOCK (fd_table_lock);
|
|
for (i = 0; i < fd_table_size; i++)
|
|
{
|
|
if (fd_table[i].fd == fd)
|
|
{
|
|
struct wait_item_s *q;
|
|
|
|
fd_table[i].frozen = 0;
|
|
q = fd_table[i].opaque;
|
|
if (q)
|
|
q->frozen = 0;
|
|
DEBUG2 ("fd %d thawed (q=%p)", fd, q);
|
|
break;
|
|
}
|
|
}
|
|
UNLOCK (fd_table_lock);
|
|
}
|
|
|
|
|
|
/**
|
|
* gpgme_register_idle:
|
|
* @fnc: Callers idle function
|
|
*
|
|
* Register a function with GPGME called by GPGME whenever it feels
|
|
* that is is idle. NULL may be used to remove this function.
|
|
*
|
|
* Return value: The idle function pointer that was passed to the
|
|
* function at the last time it was invoked, or NULL if the function
|
|
* is invoked the first time.
|
|
**/
|
|
GpgmeIdleFunc
|
|
gpgme_register_idle (GpgmeIdleFunc idle)
|
|
{
|
|
GpgmeIdleFunc old_idle = idle_function;
|
|
|
|
idle_function = idle;
|
|
return old_idle;
|
|
}
|
|
|
|
|
|
static void
|
|
run_idle ()
|
|
{
|
|
_gpgme_engine_housecleaning ();
|
|
if (idle_function)
|
|
idle_function ();
|
|
}
|