2001-12-18 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / wait.c
1 /* wait.c 
2  *      Copyright (C) 2000 Werner Koch (dd9jn)
3  *      Copyright (C) 2001 g10 Code GmbH
4  *
5  * This file is part of GPGME.
6  *
7  * GPGME is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GPGME is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #include <errno.h>
28 #include <sys/types.h>
29 #include "syshdr.h"
30
31 #include "util.h"
32 #include "context.h"
33 #include "ops.h"
34 #include "wait.h"
35 #include "sema.h"
36 #include "io.h"
37 #include "engine.h"
38
39 struct wait_item_s;
40 struct proc_s;
41
42 static struct proc_s *proc_queue;
43 DEFINE_STATIC_LOCK (proc_queue_lock);
44
45 static int fd_table_size;
46 static struct io_select_fd_s *fd_table;
47 DEFINE_STATIC_LOCK (fd_table_lock);
48
49 static void (*idle_function) (void);
50
51
52 struct proc_s {
53     struct proc_s *next;
54     int pid;
55     GpgmeCtx ctx;
56     struct wait_item_s *handler_list;
57     int ready;
58 };
59
60 struct wait_item_s {
61     struct wait_item_s *next;
62     int (*handler)(void*,int,int);
63     void *handler_value;
64     int inbound;       /* this is an inbound data handler fd */
65     struct proc_s *proc; /* backlink */
66     int ready;
67     int frozen; /* copy of the frozen flag from the fd_table */
68 };
69
70
71
72 static int do_select ( void );
73 static void run_idle (void);
74
75
76 /* only to be called with a locked proc_queue */
77 static int
78 count_running_fds ( struct proc_s *proc )
79 {
80     struct wait_item_s *q;
81     int count = 0;
82
83     for (q=proc->handler_list; q; q=q->next) {
84         if ( !q->frozen && !q->ready )
85             count++;
86     }
87     return count;
88 }
89
90 /* only to be called with a locked proc_queue */
91 static void
92 set_process_ready ( struct proc_s *proc )
93 {
94     struct wait_item_s *q, *q2;
95     int i;
96
97     assert (proc);
98     DEBUG2 ("set_process_ready(%p) pid=%d", proc, proc->pid );
99     LOCK (fd_table_lock);
100     for (q = proc->handler_list; q; q=q2) {
101         q2 = q->next;
102         for (i=0; i < fd_table_size; i++ ) {
103             if (fd_table[i].fd != -1 && q == fd_table[i].opaque ) {
104                 fd_table[i].opaque = NULL;
105                 fd_table[i].fd = -1;
106             }
107         }
108         xfree (q);
109     }
110     UNLOCK (fd_table_lock);
111     proc->handler_list = NULL;
112     proc->ready = 1;
113 }
114
115 void
116 _gpgme_remove_proc_from_wait_queue ( int pid )
117 {
118     struct proc_s *proc, *last;
119
120     DEBUG1 ("removing process %d", pid );
121     LOCK (proc_queue_lock);
122     for (last=NULL, proc=proc_queue; proc; last = proc, proc = proc->next ) {
123         if (proc->pid == pid ) {
124             set_process_ready (proc);
125             if (!last) 
126                 proc_queue = proc->next;
127             else 
128                 last->next = proc->next;
129             xfree (proc);
130             break;
131         }
132     }
133     UNLOCK (proc_queue_lock);
134 }
135
136
137 /**
138  * gpgme_wait:
139  * @c: 
140  * @hang: 
141  * 
142  * Wait for a finished request, if @c is given the function does only
143  * wait on a finished request for that context, otherwise it will return
144  * on any request.  When @hang is true the function will wait, otherwise
145  * it will return immediately when there is no pending finished request.
146  * 
147  * Return value: Context of the finished request or NULL if @hang is false
148  *  and no (or the given) request has finished.
149  **/
150 GpgmeCtx 
151 gpgme_wait ( GpgmeCtx c, int hang ) 
152 {
153     return _gpgme_wait_on_condition ( c, hang, NULL );
154 }
155
156 GpgmeCtx 
157 _gpgme_wait_on_condition ( GpgmeCtx c, int hang, volatile int *cond )
158 {
159     DEBUG3 ("waiting... ctx=%p hang=%d cond=%p", c, hang, cond );
160     do {
161         int any = 0;
162         struct proc_s *proc;
163
164         do_select();
165
166         if ( cond && *cond )
167             hang = 0;
168         else {
169             LOCK (proc_queue_lock);
170             for (proc=proc_queue; proc; proc = proc->next ) {
171                 if ( !proc->ready && !count_running_fds (proc) ) {
172                     set_process_ready (proc);
173                 }
174                 if (c && proc->ready && proc->ctx == c)
175                     hang = 0;
176                 if ( !proc->ready )
177                     any = 1;
178             }
179             UNLOCK (proc_queue_lock);
180             if (!any)
181                 hang = 0;
182         }
183         /* fixme: we should check here for hanging processes */
184
185         if (hang)
186             run_idle ();
187     } while (hang && !c->cancel );
188     c->cancel = 0; /* fixme: fix all functions, to return a cancel error */
189     return c;
190 }
191
192
193
194 /*
195  * We use this function to do the select stuff for all running
196  * gpgs.  A future version might provide a facility to delegate
197  * those selects to the GDK select stuff.
198  * This function must be called only by one thread!!
199  * Returns: 0 = nothing to run
200  *          1 = did run something 
201  */
202
203 static int
204 do_select ( void )
205 {
206     int i, n;
207     int any=0;
208     
209     n = _gpgme_io_select ( fd_table, fd_table_size );
210     if ( n <= 0 ) 
211         return 0; /* error or timeout */
212
213     for (i=0; i < fd_table_size && n; i++ ) {
214         if ( fd_table[i].fd != -1 && fd_table[i].signaled 
215              && !fd_table[i].frozen ) {
216             struct wait_item_s *q;
217
218             assert (n);
219             n--;
220             
221             q = fd_table[i].opaque;
222             assert ( q );
223             assert ( q->proc );
224             assert ( !q->ready );
225             any = 1;
226             if ( q->handler (q->handler_value,
227                              q->proc->pid, fd_table[i].fd ) ) {
228                 DEBUG2 ("setting fd %d (q=%p) ready", fd_table[i].fd, q );
229                 q->ready = 1;
230                 /* free the table entry*/
231                 LOCK (fd_table_lock);
232                 fd_table[i].for_read = 0;
233                 fd_table[i].for_write = 0;
234                 fd_table[i].fd = -1;
235                 fd_table[i].opaque = NULL;
236                 UNLOCK (fd_table_lock);
237             }
238         }
239     }
240     
241     return any;
242 }
243
244
245
246 /* 
247  * called by rungpg.c to register something for select()
248  */
249 GpgmeError
250 _gpgme_register_pipe_handler ( void *opaque, 
251                               int (*handler)(void*,int,int),
252                               void *handler_value,
253                               int pid, int fd, int inbound )
254 {
255     GpgmeCtx ctx = opaque;
256     struct wait_item_s *q;
257     struct proc_s *proc;
258     int i;
259
260     assert (opaque);
261     assert (handler);
262
263     /* Allocate a structure to hold info about the handler */
264     q = xtrycalloc ( 1, sizeof *q );
265     if ( !q )
266         return mk_error (Out_Of_Core);
267     q->inbound = inbound;
268     q->handler = handler;
269     q->handler_value = handler_value;
270
271     /* Put this into the process queue */
272     LOCK (proc_queue_lock);
273     for (proc=proc_queue; proc && proc->pid != pid; proc = proc->next)
274         ;
275     if (!proc) { /* a new process */
276         proc = xtrycalloc ( 1, sizeof *proc );
277         if (!proc) {
278             UNLOCK (proc_queue_lock);
279             return mk_error (Out_Of_Core);
280         }
281         proc->pid = pid;
282         proc->ctx = ctx;
283         proc->next = proc_queue;
284         proc_queue = proc;
285     }
286     assert (proc->ctx == ctx);
287     q->proc = proc;
288     q->next = proc->handler_list;
289     proc->handler_list = q;
290     UNLOCK (proc_queue_lock);
291     
292     LOCK (fd_table_lock);
293  again:  
294     for (i=0; i < fd_table_size; i++ ) {
295         if ( fd_table[i].fd == -1 ) {
296             fd_table[i].fd = fd;
297             fd_table[i].for_read = inbound;    
298             fd_table[i].for_write = !inbound;    
299             fd_table[i].signaled = 0;
300             fd_table[i].frozen = 0;
301             fd_table[i].opaque = q;
302             UNLOCK (fd_table_lock);
303             return 0;
304         }
305     }
306     if ( fd_table_size < 50 ) {
307         /* FIXME: We have to wait until there are no other readers of the 
308          * table, i.e that the io_select is not active in another thread */
309         struct io_select_fd_s *tmp;
310
311         tmp = xtryrealloc ( fd_table, (fd_table_size + 10) * sizeof *tmp );
312         if ( tmp ) {
313             for (i=0; i < 10; i++ )
314                 tmp[fd_table_size+i].fd = -1;
315             fd_table_size += i;
316             fd_table = tmp;
317             goto again;
318         }
319     }
320
321     UNLOCK (fd_table_lock);
322     xfree (q);
323     /* FIXME: remove the proc table entry */
324     return mk_error (Too_Many_Procs);
325 }
326
327
328 void
329 _gpgme_freeze_fd ( int fd )
330 {
331     int i;
332
333     LOCK (fd_table_lock);
334     for (i=0; i < fd_table_size; i++ ) {
335         if ( fd_table[i].fd == fd ) {
336             struct wait_item_s *q;
337
338             fd_table[i].frozen = 1;
339             if ( (q=fd_table[i].opaque) )
340                 q->frozen = 1;
341             DEBUG2 ("fd %d frozen (q=%p)", fd, q );
342             break;
343         }
344     }
345     UNLOCK (fd_table_lock);
346 }
347
348 void
349 _gpgme_thaw_fd ( int fd )
350 {
351     int i;
352
353     LOCK (fd_table_lock);
354     for (i=0; i < fd_table_size; i++ ) {
355         if ( fd_table[i].fd == fd ) {
356             struct wait_item_s *q;
357
358             fd_table[i].frozen = 0;
359             if ( (q=fd_table[i].opaque) )
360                 q->frozen = 0;
361             DEBUG2 ("fd %d thawed (q=%p)", fd, q );
362             break;
363         }
364     }
365     UNLOCK (fd_table_lock);
366 }
367
368
369 /**
370  * gpgme_register_idle:
371  * @fnc: Callers idle function
372  * 
373  * Register a function with GPGME called by GPGME whenever it feels
374  * that is is idle.  NULL may be used to remove this function.
375  **/
376 void
377 gpgme_register_idle ( void (*fnc)(void) )
378 {
379     idle_function = fnc;
380 }
381
382
383 static void
384 run_idle ()
385 {
386   _gpgme_engine_housecleaning ();
387   if (idle_function)
388     idle_function ();
389 }