json: Fix t-decrypt-verify.out for GnuPG >= 2.3.
[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, see <https://gnu.org/licenses/>.
19  * SPDX-License-Identifier: LGPL-2.1-or-later
20  */
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_syserror ();
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_syserror ();
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       free (tag);
124       return gpg_error_from_syserror ();
125     }
126   item->ctx = ctx;
127   item->dir = dir;
128   item->handler = fnc;
129   item->handler_value = fnc_data;
130
131   err = fd_table_put (fdt, fd, dir, item, &tag->idx);
132   if (err)
133     {
134       free (tag);
135       free (item);
136       return err;
137     }
138
139   TRACE (DEBUG_CTX, "_gpgme_add_io_cb", ctx,
140           "fd=%d, dir=%d -> tag=%p", fd, dir, tag);
141
142   *r_tag = tag;
143   return 0;
144 }
145
146
147 void
148 _gpgme_remove_io_cb (void *data)
149 {
150   struct tag *tag = data;
151   gpgme_ctx_t ctx;
152   fd_table_t fdt;
153   int idx;
154
155   assert (tag);
156   ctx = tag->ctx;
157   assert (ctx);
158   fdt = &ctx->fdt;
159   assert (fdt);
160   idx = tag->idx;
161
162   TRACE (DEBUG_CTX, "_gpgme_remove_io_cb", data,
163           "setting fd 0x%x (item=%p) done", fdt->fds[idx].fd,
164           fdt->fds[idx].opaque);
165
166   free (fdt->fds[idx].opaque);
167   free (tag);
168
169   /* Free the table entry.  */
170   fdt->fds[idx].fd = -1;
171   fdt->fds[idx].for_read = 0;
172   fdt->fds[idx].for_write = 0;
173   fdt->fds[idx].opaque = NULL;
174 }
175
176 \f
177 /* This is slightly embarrassing.  The problem is that running an I/O
178    callback _may_ influence the status of other file descriptors.  Our
179    own event loops could compensate for that, but the external event
180    loops cannot.  FIXME: We may still want to optimize this a bit when
181    we are called from our own event loops.  So if CHECKED is 1, the
182    check is skipped.  FIXME: Give an example on how the status of other
183    fds can be influenced.  */
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       TRACE (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 gpg_error_from_syserror ();
208       else if (nr == 0)
209         {
210           /* The status changed in the meantime, there is nothing left
211            * to do.  */
212           return 0;
213         }
214     }
215
216   TRACE (DEBUG_CTX, "_gpgme_run_io_cb", item, "handler (%p, %d)",
217           item->handler_value, an_fds->fd);
218
219   iocb_data.handler_value = item->handler_value;
220   iocb_data.op_err = 0;
221   err = item->handler (&iocb_data, an_fds->fd);
222
223   *op_err = iocb_data.op_err;
224   return err;
225 }