More include guards.
[gpgme.git] / src / wait.c
1 /* wait.c 
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007 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 <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28 #include <errno.h>
29 #ifdef HAVE_SYS_TYPES_H
30 # include <sys/types.h>
31 #endif
32
33 #include "util.h"
34 #include "context.h"
35 #include "ops.h"
36 #include "wait.h"
37 #include "sema.h"
38 #include "priv-io.h"
39 #include "engine.h"
40 #include "debug.h"
41
42 \f
43 void
44 _gpgme_fd_table_init (fd_table_t fdt)
45 {
46   fdt->fds = NULL;
47   fdt->size = 0;
48 }
49
50 void
51 _gpgme_fd_table_deinit (fd_table_t fdt)
52 {
53   if (fdt->fds)
54     free (fdt->fds);
55 }
56
57
58 /* XXX We should keep a marker and roll over for speed.  */
59 static gpgme_error_t
60 fd_table_put (fd_table_t fdt, int fd, int dir, void *opaque, int *idx)
61 {
62   unsigned int i, j;
63   struct io_select_fd_s *new_fds;
64
65   for (i = 0; i < fdt->size; i++)
66     {
67       if (fdt->fds[i].fd == -1)
68         break;
69     }
70   if (i == fdt->size)
71     {
72 #define FDT_ALLOCSIZE 10
73       new_fds = realloc (fdt->fds, (fdt->size + FDT_ALLOCSIZE)
74                          * sizeof (*new_fds));
75       if (!new_fds)
76         return gpg_error_from_errno (errno);
77       
78       fdt->fds = new_fds;
79       fdt->size += FDT_ALLOCSIZE;
80       for (j = 0; j < FDT_ALLOCSIZE; j++)
81         fdt->fds[i + j].fd = -1;
82     }
83
84   fdt->fds[i].fd = fd;
85   fdt->fds[i].for_read = (dir == 1);
86   fdt->fds[i].for_write = (dir == 0);
87   fdt->fds[i].signaled = 0;
88   fdt->fds[i].opaque = opaque;
89   *idx = i;
90   return 0;
91 }
92
93 \f
94 /* Register the file descriptor FD with the handler FNC (which gets
95    FNC_DATA as its first argument) for the direction DIR.  DATA should
96    be the context for which the fd is added.  R_TAG will hold the tag
97    that can be used to remove the fd.  */
98 gpgme_error_t
99 _gpgme_add_io_cb (void *data, int fd, int dir, gpgme_io_cb_t fnc,
100                   void *fnc_data, void **r_tag)
101 {
102   gpgme_error_t err;
103   gpgme_ctx_t ctx = (gpgme_ctx_t) data;
104   fd_table_t fdt;
105   struct wait_item_s *item;
106   struct tag *tag;
107
108   assert (fnc);
109   assert (ctx);
110
111   fdt = &ctx->fdt;
112   assert (fdt);
113
114   tag = malloc (sizeof *tag);
115   if (!tag)
116     return gpg_error_from_errno (errno);
117   tag->ctx = ctx;
118
119   /* Allocate a structure to hold information about the handler.  */
120   item = calloc (1, sizeof *item);
121   if (!item)
122     {
123       int saved_errno = errno;
124       free (tag);
125       return gpg_error_from_errno (saved_errno);
126     }
127   item->ctx = ctx;
128   item->dir = dir;
129   item->handler = fnc;
130   item->handler_value = fnc_data;
131
132   err = fd_table_put (fdt, fd, dir, item, &tag->idx);
133   if (err)
134     {
135       free (tag);
136       free (item);
137       return err;
138     }
139
140   TRACE3 (DEBUG_CTX, "_gpgme_add_io_cb", ctx,
141           "fd %d, dir=%d -> tag=%p", fd, dir, tag);
142
143   *r_tag = tag;
144   return 0;
145 }
146
147
148 void
149 _gpgme_remove_io_cb (void *data)
150 {
151   struct tag *tag = data;
152   gpgme_ctx_t ctx;
153   fd_table_t fdt;
154   int idx;
155
156   assert (tag);
157   ctx = tag->ctx;
158   assert (ctx);
159   fdt = &ctx->fdt;
160   assert (fdt);
161   idx = tag->idx;
162
163   TRACE2 (DEBUG_CTX, "_gpgme_remove_io_cb", data,
164           "setting fd 0x%x (item=%p) done", fdt->fds[idx].fd,
165           fdt->fds[idx].opaque);
166
167   free (fdt->fds[idx].opaque);
168   free (tag);
169
170   /* Free the table entry.  */
171   fdt->fds[idx].fd = -1;
172   fdt->fds[idx].for_read = 0;
173   fdt->fds[idx].for_write = 0;
174   fdt->fds[idx].opaque = NULL;
175 }
176
177 \f
178 /* This is slightly embarrassing.  The problem is that running an I/O
179    callback _may_ influence the status of other file descriptors.  Our
180    own event loops could compensate for that, but the external event
181    loops cannot.  FIXME: We may still want to optimize this a bit when
182    we are called from our own event loops.  So if CHECKED is 1, the
183    check is skipped.  */
184 gpgme_error_t
185 _gpgme_run_io_cb (struct io_select_fd_s *an_fds, int checked,
186                   gpgme_error_t *op_err)
187 {
188   struct wait_item_s *item;
189   struct io_cb_data iocb_data;
190   gpgme_error_t err;
191
192   item = (struct wait_item_s *) an_fds->opaque;
193   assert (item);
194
195   if (!checked)
196     {
197       int nr;
198       struct io_select_fd_s fds;
199
200       TRACE0 (DEBUG_CTX, "_gpgme_run_io_cb", item, "need to check");
201       fds = *an_fds;
202       fds.signaled = 0;
203       /* Just give it a quick poll.  */
204       nr = _gpgme_io_select (&fds, 1, 1);
205       assert (nr <= 1);
206       if (nr < 0)
207         return errno;
208       else if (nr == 0)
209         /* The status changed in the meantime, there is nothing left
210            to do.  */
211         return 0;
212     }
213
214   TRACE2 (DEBUG_CTX, "_gpgme_run_io_cb", item, "handler (%p, %d)",
215           item->handler_value, an_fds->fd);
216
217   iocb_data.handler_value = item->handler_value;
218   iocb_data.op_err = 0;
219   err = item->handler (&iocb_data, an_fds->fd);
220
221   *op_err = iocb_data.op_err;
222   return err;
223 }