2002-06-14 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / wait.c
index a84c746..6c99d3e 100644 (file)
@@ -1,5 +1,6 @@
 /* wait.c 
  *     Copyright (C) 2000 Werner Koch (dd9jn)
+ *      Copyright (C) 2001, 2002 g10 Code GmbH
  *
  * This file is part of GPGME.
  *
 #include <string.h>
 #include <assert.h>
 #include <errno.h>
-#include <sys/time.h>
 #include <sys/types.h>
-#include <unistd.h>
-#include <sys/wait.h>
 
 #include "util.h"
 #include "context.h"
+#include "ops.h"
 #include "wait.h"
+#include "sema.h"
+#include "io.h"
+#include "engine.h"
 
-/* Fixme: implement the following stuff to make the code MT safe.
- * To avoid the need to link against a specific threads lib, such
- * an implementation should require the caller to register a function
- * which does this task.
- * enter_crit() and leave_crit() are used to embrace an area of code
- * which should be executed only by one thread at a time.
- * lock_xxxx() and unlock_xxxx()  protect access to an data object.
- *  */
-#define enter_crit()    do { } while (0)
-#define leave_crit()    do { } while (0)
-#define lock_queue()    do { } while (0)
-#define unlock_queue()  do { } while (0)
-
-struct wait_queue_item_s {
-    struct wait_queue_item_s *next;
-    volatile int used; 
-    volatile int active;
-    int (*handler)(void*,pid_t,int);
-    void *handler_value;
-    pid_t pid;
-    int   fd;  
-    int   inbound;       /* this is an inbound data handler fd */
-
-    int exited;
-    int exit_status;  
-    int exit_signal;
-
-    GpgmeCtx ctx;
-};
-
-
-static struct wait_queue_item_s wait_queue[SIZEOF_WAIT_QUEUE];
+struct fd_table fdt_global;
 
-static int the_big_select ( void );
+static GpgmeCtx *ctx_done_list;
+static int ctx_done_list_size;
+static int ctx_done_list_length;
+DEFINE_STATIC_LOCK (ctx_done_list_lock);
 
+static GpgmeIdleFunc idle_function;
 
-static void
-init_wait_queue (void)
+struct wait_item_s
 {
-    int i;
-    static int initialized = 0;
+  struct wait_item_s *next;
+  GpgmeIOCb handler;
+  void *handler_value;
+  int dir;
+};
 
-    if ( initialized )  /* FIXME: This leads to a race */
-        return;
+static void run_idle (void);
 
-    lock_queue ();
-    for (i=1; i < SIZEOF_WAIT_QUEUE; i++ )
-        wait_queue[i-1].next = &wait_queue[i];
-    initialized = 1;
-    unlock_queue();
+\f
+void
+_gpgme_fd_table_init (fd_table_t fdt)
+{
+  INIT_LOCK (fdt->lock);
+  fdt->fds = NULL;
+  fdt->size = 0;
 }
 
-static struct wait_queue_item_s *
-queue_item_from_context ( GpgmeCtx ctx )
+void
+_gpgme_fd_table_deinit (fd_table_t fdt)
 {
-    struct wait_queue_item_s *q;
+  DESTROY_LOCK (fdt->lock);
+  if (fdt->fds)
+    xfree (fdt->fds);
+}
 
-    for (q=wait_queue; q; q = q->next) {
-        if ( q->used && q->ctx == ctx )
-            return q;
+/* XXX We should keep a marker and roll over for speed.  */
+GpgmeError
+_gpgme_fd_table_put (fd_table_t fdt, int fd, int dir, void *opaque, int *idx)
+{
+  int i, j;
+  struct io_select_fd_s *new_fds;
+
+  LOCK (fdt->lock);
+  for (i = 0; i < fdt->size; i++)
+    {
+      if (fdt->fds[i].fd == -1)
+       break;
     }
-    return NULL;
+  if (i == fdt->size)
+    {
+#define FDT_ALLOCSIZE 10
+      new_fds = xtryrealloc (fdt->fds, (fdt->size + FDT_ALLOCSIZE)
+                            * sizeof (*new_fds));
+      if (!new_fds)
+       {
+         UNLOCK (fdt->lock);
+         return mk_error (Out_Of_Core);
+       }
+      
+      fdt->fds = new_fds;
+      fdt->size += FDT_ALLOCSIZE;
+      for (j = 0; j < FDT_ALLOCSIZE; j++)
+       fdt->fds[i + j].fd = -1;
+    }
+
+  fdt->fds[i].fd = fd;
+  fdt->fds[i].for_read = (dir == 1);
+  fdt->fds[i].for_write = (dir == 0);
+  fdt->fds[i].frozen = 0;
+  fdt->fds[i].signaled = 0;
+  fdt->fds[i].opaque = opaque;
+  UNLOCK (fdt->lock);
+  *idx = i;
+  return 0;
 }
 
+\f
+/**
+ * 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
-propagate_term_results ( const struct wait_queue_item_s *first_q )
+run_idle ()
 {
-    struct wait_queue_item_s *q;
-    
-    for (q=wait_queue; q; q = q->next) {
-        if ( q->used && q != first_q && !q->exited
-             && q->pid == first_q->pid  ) {
-            q->exited = first_q->exited;
-            q->exit_status = first_q->exit_status;
-            q->exit_signal = first_q->exit_signal;
-        }
-    }
+  _gpgme_engine_housecleaning ();
+  if (idle_function)
+    idle_function ();
 }
 
+\f
+/* Wait on all file descriptors listed in FDT and process them using
+   the registered callbacks.  Returns -1 on error (with errno set), 0
+   if nothing to run and 1 if it did run something.  */
 static int
-count_active_fds ( pid_t pid )
+do_select (fd_table_t fdt)
 {
-    struct wait_queue_item_s *q;
-    int count = 0;
-    
-    for (q=wait_queue; q; q = q->next) {
-        if ( q->used && q->active && q->pid == pid  ) 
-            count++;
+  int i, n;
+  int any = 0;
+
+  LOCK (fdt->lock);
+  n = _gpgme_io_select (fdt->fds, fdt->size);
+
+  if (n <= 0) 
+    {
+      UNLOCK (fdt->lock);
+      return n;        /* Error or timeout.  */
     }
-    return count;
-}
 
+  for (i = 0; i < fdt->size && n; i++)
+    {
+      if (fdt->fds[i].fd != -1 && fdt->fds[i].signaled)
+       {
+         struct wait_item_s *item;
 
-/* remove the given process from the queue */
-static void
-remove_process ( pid_t pid )
-{
-    struct wait_queue_item_s *q;
-    
-    for (q=wait_queue; q; q = q->next) {
-        if ( q->used ) {
-            close (q->fd);
-            q->handler = NULL;
-            q->ctx = NULL;
-            q->used = 0;
+         assert (n);
+         n--;
+            
+         item = (struct wait_item_s *) fdt->fds[i].opaque;
+         assert (item);
+         any = 1;
+
+         fdt->fds[i].signaled = 0;
+         UNLOCK (fdt->lock);
+         item->handler (item->handler_value, fdt->fds[i].fd);
+         LOCK (fdt->lock);
         }
     }
+  UNLOCK (fdt->lock);
+    
+  return any;
 }
 
 
+\f
+void
+_gpgme_wait_event_cb (void *data, GpgmeEventIO type, void *type_data)
+{
+  if (type != GPGME_EVENT_DONE)
+    return;
+
+  if (ctx_done_list_size == ctx_done_list_length)
+    {
+#define CTX_DONE_LIST_SIZE_INITIAL 8
+      int new_size = ctx_done_list_size ? 2 * ctx_done_list_size
+       : CTX_DONE_LIST_SIZE_INITIAL;
+      GpgmeCtx *new_list = xtryrealloc (ctx_done_list,
+                                       new_size * sizeof (GpgmeCtx *));
+      assert (new_list);
+#if 0
+      if (!new_list)
+       return mk_error (Out_Of_Core);
+#endif
+      ctx_done_list = new_list;
+      ctx_done_list_size = new_size;
+    }
+  ctx_done_list[ctx_done_list_length++] = (GpgmeCtx) data;
+}
+
 
 /**
  * gpgme_wait:
@@ -151,191 +217,178 @@ remove_process ( pid_t pid )
  * @hang: 
  * 
  * Wait for a finished request, if @c is given the function does only
- * wait on a finsihed request for that context, otherwise it will return
+ * 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.
+ *  and no (or not the given) request has finished.
  **/
 GpgmeCtx 
-gpgme_wait ( GpgmeCtx c, int hang )
+gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang)
 {
-    struct wait_queue_item_s *q;
-
-    init_wait_queue ();
-    do {
-        if ( !the_big_select() ) {
-            int status;
-
-            /* We did no read/write - see whether this process is still
-             * alive */
-            assert (c); /* !c is not yet implemented */
-            q = queue_item_from_context ( c );
-            assert (q);
-            
-            if (q->exited)
-                ;
-            else if ( waitpid ( q->pid, &status, WNOHANG ) == q->pid ) {
-                q->exited = 1;     
-                if ( WIFSIGNALED (status) ) {
-                    q->exit_status = 4; /* Need some value here */
-                    q->exit_signal = WTERMSIG (status);
-                }
-                else if ( WIFEXITED (status) ) {
-                    q->exit_status = WEXITSTATUS (status);
-                }
-                else {
-                    q->exited++;
-                    q->exit_status = 4;
-                }
-                propagate_term_results (q);
-            }
-
-            if ( q->exited ) {
-                if ( !count_active_fds (q->pid) ) {
-                    /* Hmmm, as long as we don't have a callback for
-                     * the exit status, we have no use for these
-                     * values and therefore we can remove this from
-                     * the queue */
-                    remove_process (q->pid);
-                    hang = 0;
-                }
-            }
-        }
-    } while (hang);
-    return c;
+  ctx = _gpgme_wait_on_condition (ctx, hang, NULL);
+  if (ctx && status)
+    *status = ctx->error;
+  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!!
- * FIXME: The data structures and  algorithms are stupid.
- * Returns: 0 = nothing to run
- *          1 = did run something 
- */
-
-static int
-the_big_select ( void )
+GpgmeError
+_gpgme_wait_one (GpgmeCtx ctx)
 {
-    static fd_set readfds;
-    static fd_set writefds;
-    struct wait_queue_item_s *q;
-    int max_fd, n;
-    struct timeval timeout = { 1, 0 }; /* Use a one second timeout */
-    
-    FD_ZERO ( &readfds );
-    FD_ZERO ( &writefds );
-    max_fd = 0;
-    lock_queue ();
-    for ( q = wait_queue; q; q = q->next ) {
-        if ( q->used && q->active ) {
-            if (q->inbound) {
-                assert ( !FD_ISSET ( q->fd, &readfds ) );
-                FD_SET ( q->fd, &readfds );
-            }
-            else {
-                assert ( !FD_ISSET ( q->fd, &writefds ) );
-                FD_SET ( q->fd, &writefds );
-            }
-            if ( q->fd > max_fd )
-                max_fd = q->fd;
-          }
+  GpgmeError err = 0;
+  int hang = 1;
+  DEBUG1 ("waiting... ctx=%p", ctx);
+  do
+    {
+      if (do_select (&ctx->fdt) < 0)
+       {
+         err = mk_error (File_Error);
+         hang = 0;
+       }
+      else
+       {
+         int any = 0;
+         int i;
+
+         LOCK (ctx->fdt.lock);
+         for (i = 0; i < ctx->fdt.size; i++)
+           {
+             if (ctx->fdt.fds[i].fd != -1)
+               {
+                 any = 1;
+                 break;
+               }
+           }
+         if (!any)
+           hang = 0;
+         UNLOCK (ctx->fdt.lock);
+       }
     }
-    unlock_queue ();
-
-
-    n = select ( max_fd+1, &readfds, &writefds, NULL, &timeout );
-    if ( n <= 0 ) {
-        if ( n && errno != EINTR ) {
-            fprintf (stderr, "the_big_select: select failed: %s\n",
-                     strerror (errno) );
-        }
-        return 0;
-    }
-
-    /* something has to be done.  Go over the queue and call
-     * the handlers */
- restart:
-    while ( n ) {
-        lock_queue ();
-        for ( q = wait_queue; q; q = q->next ) {
-            if ( q->used && q->active 
-                 && FD_ISSET (q->fd, q->inbound? &readfds : &writefds ) ) {
-                FD_CLR (q->fd, q->inbound? &readfds : &writefds );
-                assert (n);
-                n--;
-                unlock_queue ();
-                if ( q->handler (q->handler_value, q->pid, q->fd ) )
-                    q->active = 0;
-                goto restart;
-            }
-        }
-        unlock_queue ();
+  while (hang && !ctx->cancel);
+  if (!err && ctx->cancel)
+    {
+      /* FIXME: Paranoia?  */
+      ctx->cancel = 0;
+      ctx->pending = 0;
+      ctx->error = mk_error (Canceled);
     }
-    return 1;
+  return err ? err : ctx->error;
 }
 
 
-
-/* 
- * called by rungpg.c to register something for select()
- */
-GpgmeError
-_gpgme_register_pipe_handler( void *opaque, 
-                              int (*handler)(void*,pid_t,int),
-                              void *handler_value,
-                              pid_t pid, int fd, int inbound )
+GpgmeCtx 
+_gpgme_wait_on_condition (GpgmeCtx ctx, int hang, volatile int *cond)
 {
-    GpgmeCtx ctx = opaque;
-    struct wait_queue_item_s *q;
-
-    init_wait_queue();
-    assert (opaque);
-    assert (handler);
-    
-    lock_queue ();
-    for ( q = wait_queue; q; q = q->next ) {
-        if ( !q->used ) {
-            q->used = 1;
-            q->active = 0;
-            break;
+  DEBUG3 ("waiting... ctx=%p hang=%d cond=%p", ctx, hang, cond);
+  do
+    {
+      /* XXX We are ignoring all errors from select here.  */
+      do_select (&fdt_global);
+      
+      if (cond && *cond)
+       hang = 0;
+      else
+       {
+         int i;
+
+         LOCK (ctx_done_list_lock);
+         /* A process that is done is eligible for election if it is
+            the requested context or if it was not yet reported.  */
+         for (i = 0; i < ctx_done_list_length; i++)
+           if (!ctx || ctx == ctx_done_list[i])
+             break;
+         if (i < ctx_done_list_length)
+           {
+             if (!ctx)
+               ctx = ctx_done_list[i];
+             hang = 0;
+             ctx->pending = 0;
+             if (--ctx_done_list_length)
+               memcpy (&ctx_done_list[i],
+                       &ctx_done_list[i + 1],
+                       (ctx_done_list_length - i) * sizeof (GpgmeCtx *));
+           }
+         UNLOCK (ctx_done_list_lock);
         }
+      if (hang)
+       run_idle ();
     }
-    unlock_queue ();
-    if ( !q ) 
-        return mk_error (Too_Many_Procs);
-
-    q->fd = fd;
-    q->inbound = inbound;
-    q->handler = handler;
-    q->handler_value = handler_value;
-    q->pid = pid;
-    q->ctx = ctx;
-    
-    /* and enable this entry for the next select */
-    q->exited = 0;
-    q->active = 1;
-    return 0;
+  while (hang && (!ctx || !ctx->cancel));
+  if (ctx && ctx->cancel)
+    {
+      /* FIXME: Paranoia?  */
+      ctx->cancel = 0;
+      ctx->pending = 0;
+      ctx->error = mk_error (Canceled);
+    }
+  return ctx;
 }
 
+\f
+struct tag
+{
+  fd_table_t fdt;
+  int idx;
+};
 
+void *
+_gpgme_add_io_cb (void *data, int fd, int dir,
+                 GpgmeIOCb fnc, void *fnc_data)
+{
+  GpgmeError err;
+  fd_table_t fdt = (fd_table_t) (data ? data : &fdt_global);
+  struct wait_item_s *item;
+  struct tag *tag;
 
+  assert (fdt);
+  assert (fnc);
 
+  tag = xtrymalloc (sizeof *tag);
+  if (!tag)
+    return NULL;
+  tag->fdt = fdt;
+
+  /* Allocate a structure to hold info about the handler.  */
+  item = xtrycalloc (1, sizeof *item);
+  if (!item)
+    {
+      xfree (tag);
+      return NULL;
+    }
+  item->dir = dir;
+  item->handler = fnc;
+  item->handler_value = fnc_data;
+
+  err = _gpgme_fd_table_put (fdt, fd, dir, item, &tag->idx);
+  if (err)
+    {
+      xfree (tag);
+      xfree (item);
+      errno = ENOMEM;
+      return 0;
+    }
+  
+  return tag;
+}
 
-
-
-
-
-
-
-
-
-
-
-
+void
+_gpgme_remove_io_cb (void *data)
+{
+  struct tag *tag = data;
+  fd_table_t fdt = tag->fdt;
+  int idx = tag->idx;
+
+  LOCK (fdt->lock);
+  DEBUG2 ("setting fd %d (item=%p) done", fdt->fds[idx].fd,
+         fdt->fds[idx].opaque);
+  xfree (fdt->fds[idx].opaque);
+  xfree (tag);
+
+  /* Free the table entry.  */
+  fdt->fds[idx].fd = -1;
+  fdt->fds[idx].for_read = 0;
+  fdt->fds[idx].for_write = 0;
+  fdt->fds[idx].opaque = NULL;
+}