Line data Source code
1 : /* t-eventloop.c - Regression test.
2 : Copyright (C) 2000 Werner Koch (dd9jn)
3 : Copyright (C) 2001, 2002, 2003, 2004 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 : /* We need to include config.h so that we know whether we are building
23 : with large file system (LFS) support. */
24 : #ifdef HAVE_CONFIG_H
25 : #include <config.h>
26 : #endif
27 :
28 : #include <stdio.h>
29 : #include <stdlib.h>
30 : #include <string.h>
31 : #include <assert.h>
32 : #include <errno.h>
33 : #include <sys/types.h>
34 : #include <sys/select.h>
35 :
36 : #include <gpgme.h>
37 :
38 : #include "t-support.h"
39 :
40 :
41 : /* Stripped down version of gpgme/wait.c. */
42 :
43 : struct op_result
44 : {
45 : int done;
46 : gpgme_error_t err;
47 : };
48 :
49 : struct op_result op_result;
50 :
51 : struct one_fd
52 : {
53 : int fd;
54 : int dir;
55 : gpgme_io_cb_t fnc;
56 : void *fnc_data;
57 : };
58 :
59 : #define FDLIST_MAX 32
60 : struct one_fd fdlist[FDLIST_MAX];
61 :
62 : gpgme_error_t
63 3 : add_io_cb (void *data, int fd, int dir, gpgme_io_cb_t fnc, void *fnc_data,
64 : void **r_tag)
65 : {
66 3 : struct one_fd *fds = data;
67 : int i;
68 :
69 6 : for (i = 0; i < FDLIST_MAX; i++)
70 : {
71 6 : if (fds[i].fd == -1)
72 : {
73 3 : fds[i].fd = fd;
74 3 : fds[i].dir = dir;
75 3 : fds[i].fnc = fnc;
76 3 : fds[i].fnc_data = fnc_data;
77 3 : break;
78 : }
79 : }
80 3 : if (i == FDLIST_MAX)
81 0 : return gpgme_err_make (GPG_ERR_SOURCE_USER_1, GPG_ERR_GENERAL);
82 3 : *r_tag = &fds[i];
83 3 : return 0;
84 : }
85 :
86 : void
87 3 : remove_io_cb (void *tag)
88 : {
89 3 : struct one_fd *fd = tag;
90 :
91 3 : fd->fd = -1;
92 3 : }
93 :
94 : void
95 2 : io_event (void *data, gpgme_event_io_t type, void *type_data)
96 : {
97 2 : struct op_result *result = data;
98 :
99 2 : if (type == GPGME_EVENT_DONE)
100 : {
101 1 : result->done = 1;
102 1 : result->err = * (gpgme_error_t *) type_data;
103 : }
104 2 : }
105 :
106 :
107 : int
108 8 : do_select (void)
109 : {
110 : fd_set rfds;
111 : fd_set wfds;
112 : int i, n;
113 8 : int any = 0;
114 :
115 8 : FD_ZERO (&rfds);
116 8 : FD_ZERO (&wfds);
117 264 : for (i = 0; i < FDLIST_MAX; i++)
118 256 : if (fdlist[i].fd != -1)
119 18 : FD_SET (fdlist[i].fd, fdlist[i].dir ? &rfds : &wfds);
120 :
121 : do
122 : {
123 8 : n = select (FD_SETSIZE, &rfds, &wfds, NULL, 0);
124 : }
125 8 : while (n < 0 && errno == EINTR);
126 :
127 8 : if (n < 0)
128 0 : return n; /* Error or timeout. */
129 :
130 22 : for (i = 0; i < FDLIST_MAX && n; i++)
131 : {
132 14 : if (fdlist[i].fd != -1)
133 : {
134 14 : if (FD_ISSET (fdlist[i].fd, fdlist[i].dir ? &rfds : &wfds))
135 : {
136 9 : assert (n);
137 9 : n--;
138 9 : any = 1;
139 9 : (*fdlist[i].fnc) (fdlist[i].fnc_data, fdlist[i].fd);
140 : }
141 : }
142 : }
143 8 : return any;
144 : }
145 :
146 : int
147 8 : my_wait (void)
148 : {
149 : int n;
150 :
151 : do
152 : {
153 8 : n = do_select ();
154 : }
155 8 : while (n >= 0 && !op_result.done);
156 1 : return 0;
157 : }
158 :
159 :
160 : struct gpgme_io_cbs io_cbs =
161 : {
162 : add_io_cb,
163 : fdlist,
164 : remove_io_cb,
165 : io_event,
166 : &op_result
167 : };
168 :
169 :
170 : int
171 1 : main (int argc, char *argv[])
172 : {
173 : gpgme_ctx_t ctx;
174 : gpgme_error_t err;
175 : gpgme_data_t in, out;
176 1 : gpgme_key_t key[3] = { NULL, NULL, NULL };
177 : int i;
178 :
179 1 : init_gpgme (GPGME_PROTOCOL_OpenPGP);
180 :
181 33 : for (i = 0; i < FDLIST_MAX; i++)
182 32 : fdlist[i].fd = -1;
183 :
184 1 : err = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
185 1 : fail_if_err (err);
186 :
187 1 : err = gpgme_new (&ctx);
188 1 : fail_if_err (err);
189 1 : gpgme_set_armor (ctx, 1);
190 1 : gpgme_set_io_cbs (ctx, &io_cbs);
191 1 : op_result.done = 0;
192 :
193 1 : err = gpgme_data_new_from_mem (&in, "Hallo Leute\n", 12, 0);
194 1 : fail_if_err (err);
195 :
196 1 : err = gpgme_data_new (&out);
197 1 : fail_if_err (err);
198 :
199 1 : err = gpgme_get_key (ctx, "A0FF4590BB6122EDEF6E3C542D727CC768697734",
200 : &key[0], 0);
201 1 : fail_if_err (err);
202 1 : err = gpgme_get_key (ctx, "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2",
203 : &key[1], 0);
204 1 : fail_if_err (err);
205 :
206 1 : err = gpgme_op_encrypt_start (ctx, key, GPGME_ENCRYPT_ALWAYS_TRUST, in, out);
207 1 : fail_if_err (err);
208 :
209 1 : my_wait ();
210 1 : fail_if_err (op_result.err);
211 1 : fail_if_err (err);
212 :
213 1 : fflush (NULL);
214 1 : fputs ("Begin Result:\n", stdout);
215 1 : print_data (out);
216 1 : fputs ("End Result.\n", stdout);
217 :
218 1 : gpgme_key_unref (key[0]);
219 1 : gpgme_key_unref (key[1]);
220 1 : gpgme_data_release (in);
221 1 : gpgme_data_release (out);
222 1 : gpgme_release (ctx);
223 :
224 1 : return 0;
225 : }
|
