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 4 : add_io_cb (void *data, int fd, int dir, gpgme_io_cb_t fnc, void *fnc_data,
64 : void **r_tag)
65 : {
66 4 : struct one_fd *fds = data;
67 : int i;
68 :
69 10 : for (i = 0; i < FDLIST_MAX; i++)
70 : {
71 10 : if (fds[i].fd == -1)
72 : {
73 4 : fds[i].fd = fd;
74 4 : fds[i].dir = dir;
75 4 : fds[i].fnc = fnc;
76 4 : fds[i].fnc_data = fnc_data;
77 4 : break;
78 : }
79 : }
80 4 : if (i == FDLIST_MAX)
81 0 : return gpgme_err_make (GPG_ERR_SOURCE_USER_1, GPG_ERR_GENERAL);
82 4 : *r_tag = &fds[i];
83 4 : return 0;
84 : }
85 :
86 : void
87 4 : remove_io_cb (void *tag)
88 : {
89 4 : struct one_fd *fd = tag;
90 :
91 4 : fd->fd = -1;
92 4 : }
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 16 : do_select (void)
109 : {
110 : fd_set rfds;
111 : fd_set wfds;
112 : int i, n;
113 16 : int any = 0;
114 : struct timeval tv;
115 :
116 16 : FD_ZERO (&rfds);
117 16 : FD_ZERO (&wfds);
118 528 : for (i = 0; i < FDLIST_MAX; i++)
119 512 : if (fdlist[i].fd != -1)
120 50 : FD_SET (fdlist[i].fd, fdlist[i].dir ? &rfds : &wfds);
121 :
122 16 : tv.tv_sec = 0;
123 16 : tv.tv_usec = 1000;
124 :
125 : do
126 : {
127 16 : n = select (FD_SETSIZE, &rfds, &wfds, NULL, &tv);
128 : }
129 16 : while (n < 0 && errno == EINTR);
130 :
131 16 : if (n < 0)
132 0 : return n; /* Error or timeout. */
133 :
134 36 : for (i = 0; i < FDLIST_MAX && n; i++)
135 : {
136 20 : if (fdlist[i].fd != -1)
137 : {
138 20 : if (FD_ISSET (fdlist[i].fd, fdlist[i].dir ? &rfds : &wfds))
139 : {
140 12 : assert (n);
141 12 : n--;
142 12 : any = 1;
143 12 : (*fdlist[i].fnc) (fdlist[i].fnc_data, fdlist[i].fd);
144 : }
145 : }
146 : }
147 16 : return any;
148 : }
149 :
150 : int
151 16 : my_wait (void)
152 : {
153 : int n;
154 :
155 : do
156 : {
157 16 : n = do_select ();
158 : }
159 16 : while (n >= 0 && !op_result.done);
160 1 : return 0;
161 : }
162 :
163 :
164 : struct gpgme_io_cbs io_cbs =
165 : {
166 : add_io_cb,
167 : fdlist,
168 : remove_io_cb,
169 : io_event,
170 : &op_result
171 : };
172 :
173 :
174 : int
175 1 : main (void)
176 : {
177 : gpgme_ctx_t ctx;
178 : gpgme_error_t err;
179 : gpgme_data_t in, out;
180 1 : gpgme_key_t key[3] = { NULL, NULL, NULL };
181 : int i;
182 :
183 1 : init_gpgme (GPGME_PROTOCOL_OpenPGP);
184 :
185 33 : for (i = 0; i < FDLIST_MAX; i++)
186 32 : fdlist[i].fd = -1;
187 :
188 1 : err = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
189 1 : fail_if_err (err);
190 :
191 1 : err = gpgme_new (&ctx);
192 1 : fail_if_err (err);
193 1 : gpgme_set_armor (ctx, 1);
194 1 : gpgme_set_io_cbs (ctx, &io_cbs);
195 1 : op_result.done = 0;
196 :
197 1 : err = gpgme_data_new_from_mem (&in, "Hallo Leute\n", 12, 0);
198 1 : fail_if_err (err);
199 :
200 1 : err = gpgme_data_new (&out);
201 1 : fail_if_err (err);
202 :
203 1 : err = gpgme_get_key (ctx, "A0FF4590BB6122EDEF6E3C542D727CC768697734",
204 : &key[0], 0);
205 1 : fail_if_err (err);
206 1 : err = gpgme_get_key (ctx, "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2",
207 : &key[1], 0);
208 1 : fail_if_err (err);
209 :
210 1 : err = gpgme_op_encrypt_start (ctx, key, GPGME_ENCRYPT_ALWAYS_TRUST, in, out);
211 1 : fail_if_err (err);
212 :
213 1 : my_wait ();
214 1 : fail_if_err (op_result.err);
215 1 : fail_if_err (err);
216 :
217 1 : fflush (NULL);
218 1 : fputs ("Begin Result:\n", stdout);
219 1 : print_data (out);
220 1 : fputs ("End Result.\n", stdout);
221 :
222 1 : gpgme_key_unref (key[0]);
223 1 : gpgme_key_unref (key[1]);
224 1 : gpgme_data_release (in);
225 1 : gpgme_data_release (out);
226 1 : gpgme_release (ctx);
227 :
228 1 : return 0;
229 : }
|
