2004-04-22 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / wait-global.c
index daf3209..e642251 100644 (file)
@@ -24,6 +24,7 @@
 #include <stdlib.h>
 #include <assert.h>
 #include <string.h>
+#include <errno.h>
 
 #include "gpgme.h"
 #include "sema.h"
@@ -68,9 +69,9 @@ struct ctx_list_item
   struct ctx_list_item *next;
   struct ctx_list_item *prev;
 
-  GpgmeCtx ctx;
+  gpgme_ctx_t ctx;
   /* The status is set when the ctx is moved to the done list.  */
-  GpgmeError status;
+  gpgme_error_t status;
 };
 
 /* The active list contains all contexts that are in the global event
@@ -87,12 +88,12 @@ static struct ctx_list_item *ctx_done_list;
 
 \f
 /* Enter the context CTX into the active list.  */
-static GpgmeError
-ctx_active (GpgmeCtx ctx)
+static gpgme_error_t
+ctx_active (gpgme_ctx_t ctx)
 {
   struct ctx_list_item *li = malloc (sizeof (struct ctx_list_item));
   if (!li)
-    return GPGME_Out_Of_Core;
+    return gpg_error_from_errno (errno);
   li->ctx = ctx;
 
   LOCK (ctx_list_lock);
@@ -109,7 +110,7 @@ ctx_active (GpgmeCtx ctx)
 
 /* Enter the context CTX into the done list with status STATUS.  */
 static void
-ctx_done (GpgmeCtx ctx, GpgmeError status)
+ctx_done (gpgme_ctx_t ctx, gpgme_error_t status)
 {
   struct ctx_list_item *li;
 
@@ -143,8 +144,8 @@ ctx_done (GpgmeCtx ctx, GpgmeError status)
    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 GpgmeCtx
-ctx_wait (GpgmeCtx ctx, GpgmeError *status)
+static gpgme_ctx_t
+ctx_wait (gpgme_ctx_t ctx, gpgme_error_t *status)
 {
   struct ctx_list_item *li;
 
@@ -184,9 +185,10 @@ ctx_wait (GpgmeCtx ctx, GpgmeError *status)
    event loops.  */
 
 void
-_gpgme_wait_global_event_cb (void *data, GpgmeEventIO type, void *type_data)
+_gpgme_wait_global_event_cb (void *data, gpgme_event_io_t type,
+                            void *type_data)
 {
-  GpgmeCtx ctx = (GpgmeCtx) data;
+  gpgme_ctx_t ctx = (gpgme_ctx_t) data;
 
   assert (ctx);
 
@@ -194,13 +196,13 @@ _gpgme_wait_global_event_cb (void *data, GpgmeEventIO type, void *type_data)
     {
     case GPGME_EVENT_START:
       {
-       GpgmeError err = ctx_active (ctx);
+       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.  */
-           int idx;
+           unsigned int idx;
            
            for (idx = 0; idx <= ctx->fdt.size; idx++)
              if (ctx->fdt.fds[idx].fd != -1)
@@ -212,7 +214,7 @@ _gpgme_wait_global_event_cb (void *data, GpgmeEventIO type, void *type_data)
 
     case GPGME_EVENT_DONE:
       {
-       GpgmeError *errp = (GpgmeError *) type_data;
+       gpgme_error_t *errp = (gpgme_error_t *) type_data;
        assert (errp);
        ctx_done (ctx, *errp);
       }
@@ -248,12 +250,12 @@ _gpgme_wait_global_event_cb (void *data, GpgmeEventIO type, void *type_data)
    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.  */
-GpgmeCtx
-gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang)
+gpgme_ctx_t
+gpgme_wait (gpgme_ctx_t ctx, gpgme_error_t *status, int hang)
 {
   do
     {
-      int i = 0;
+      unsigned int i = 0;
       struct ctx_list_item *li;
       struct fd_table fdt;
       int nr;
@@ -265,9 +267,10 @@ gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang)
       fdt.fds = malloc (i * sizeof (struct io_select_fd_s));
       if (!fdt.fds)
        {
+         int saved_errno = errno;
          UNLOCK (ctx_list_lock);
          if (status)
-           *status = GPGME_Out_Of_Core;
+           *status = gpg_error_from_errno (saved_errno);
          return NULL;
        }
       fdt.size = i;
@@ -283,9 +286,10 @@ gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang)
       nr = _gpgme_io_select (fdt.fds, fdt.size, 0);
       if (nr < 0)
        {
+         int saved_errno = errno;
          free (fdt.fds);
          if (status)
-           *status = GPGME_File_Error;
+           *status = gpg_error_from_errno (saved_errno);
          return NULL;
        }
 
@@ -293,8 +297,8 @@ gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang)
        {
          if (fdt.fds[i].fd != -1 && fdt.fds[i].signaled)
            {
-             GpgmeCtx ictx;
-             GpgmeError err;
+             gpgme_ctx_t ictx;
+             gpgme_error_t err;
              struct wait_item_s *item;
              
              assert (nr);
@@ -306,18 +310,17 @@ gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang)
              assert (ictx);
 
              err = item->handler (item->handler_value, fdt.fds[i].fd);
-             if (!err && ictx->cancel)
-               err = GPGME_Canceled;
              if (err)
                {
                  /* An error occured.  Close all fds in this context,
                     and signal it.  */
-                 int idx;
+                 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);
+                 _gpgme_engine_io_event (ictx->engine, GPGME_EVENT_DONE,
+                                         &err);
                }
            }
        }
@@ -332,20 +335,19 @@ gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang)
              break;
          if (i == ctx->fdt.size)
            {
-             GpgmeError err = 0;
+             gpgme_error_t err = 0;
              _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &err);
            }
        }
       UNLOCK (ctx_list_lock);
 
       {
-       GpgmeCtx dctx = ctx_wait (ctx, status);
+       gpgme_ctx_t dctx = ctx_wait (ctx, status);
 
        if (dctx)
          {
            ctx = dctx;
            hang = 0;
-           ctx->pending = 0;
          }
       }
     }
@@ -353,5 +355,3 @@ gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang)
 
   return ctx;
 }
-
-