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