2008-06-27 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / wait-private.c
1 /* wait-private.c 
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003, 2004, 2005 g10 Code GmbH
4  
5    This file is part of GPGME.
6  
7    GPGME is free software; you can redistribute it and/or modify it
8    under the terms of the GNU Lesser General Public License as
9    published by the Free Software Foundation; either version 2.1 of
10    the License, or (at your option) any later version.
11    
12    GPGME is distributed in the hope that it will be useful, but
13    WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Lesser General Public License for more details.
16    
17    You should have received a copy of the GNU Lesser General Public
18    License along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
21
22 #if HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25 #include <assert.h>
26 #include <errno.h>
27
28 #include "gpgme.h"
29 #include "context.h"
30 #include "wait.h"
31 #include "ops.h"
32 #include "priv-io.h"
33 #include "util.h"
34
35 \f
36 /* The private event loops are used for all blocking operations, and
37    for the key and trust item listing operations.  They are completely
38    separated from each other.  */
39
40 \f
41 /* Internal I/O callback functions.  */
42
43 /* The add_io_cb and remove_io_cb handlers are shared with the global
44    event loops.  */
45
46 void
47 _gpgme_wait_private_event_cb (void *data, gpgme_event_io_t type,
48                               void *type_data)
49 {
50   switch (type)
51     {
52     case GPGME_EVENT_START:
53       /* Nothing to do here, as the wait routine is called after the
54          initialization is finished.  */
55       break;
56
57     case GPGME_EVENT_DONE:
58       break;
59
60     case GPGME_EVENT_NEXT_KEY:
61       _gpgme_op_keylist_event_cb (data, type, type_data);
62       break;
63
64     case GPGME_EVENT_NEXT_TRUSTITEM:
65       _gpgme_op_trustlist_event_cb (data, type, type_data);
66       break;
67     }
68 }
69
70 \f
71 /* If COND is a null pointer, wait until the blocking operation in CTX
72    finished and return its error value.  Otherwise, wait until COND is
73    satisfied or the operation finished.  */
74 gpgme_error_t
75 _gpgme_wait_on_condition (gpgme_ctx_t ctx, volatile int *cond)
76 {
77   gpgme_error_t err = 0;
78   int hang = 1;
79
80   do
81     {
82       int nr = _gpgme_io_select (ctx->fdt.fds, ctx->fdt.size, 0);
83       unsigned int i;
84
85       if (nr < 0)
86         {
87           /* An error occured.  Close all fds in this context, and
88              signal it.  */
89           unsigned int idx;
90
91           err = gpg_error_from_errno (errno);
92           for (idx = 0; idx < ctx->fdt.size; idx++)
93             if (ctx->fdt.fds[idx].fd != -1)
94               _gpgme_io_close (ctx->fdt.fds[idx].fd);
95           _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &err);
96
97           return err;
98         }
99       
100       for (i = 0; i < ctx->fdt.size && nr; i++)
101         {
102           if (ctx->fdt.fds[i].fd != -1 && ctx->fdt.fds[i].signaled)
103             {
104               ctx->fdt.fds[i].signaled = 0;
105               assert (nr);
106               nr--;
107
108               LOCK (ctx->lock);
109               if (ctx->canceled)
110                 err = gpg_error (GPG_ERR_CANCELED);
111               UNLOCK (ctx->lock);
112               
113               if (!err)
114                 err = _gpgme_run_io_cb (&ctx->fdt.fds[i], 0);
115               if (err)
116                 {
117                   /* An error occured.  Close all fds in this context,
118                      and signal it.  */
119                   unsigned int idx;
120                   
121                   for (idx = 0; idx < ctx->fdt.size; idx++)
122                     if (ctx->fdt.fds[idx].fd != -1)
123                       _gpgme_io_close (ctx->fdt.fds[idx].fd);
124                   _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &err);
125                   return err;
126                 }
127             }
128         }
129
130       for (i = 0; i < ctx->fdt.size; i++)
131         if (ctx->fdt.fds[i].fd != -1)
132           break;
133       if (i == ctx->fdt.size)
134         {
135           _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &err);
136           hang = 0;
137         }
138       if (cond && *cond)
139         hang = 0;
140     }
141   while (hang);
142
143   return 0;
144 }
145
146
147 /* Wait until the blocking operation in context CTX has finished and
148    return the error value.  */
149 gpgme_error_t
150 _gpgme_wait_one (gpgme_ctx_t ctx)
151 {
152   return _gpgme_wait_on_condition (ctx, NULL);
153 }