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