trunk/MyGPGME/wait.c

/* wait.c 
 *      Copyright (C) 2000, 2001 Werner Koch (dd9jn), g10 Code GmbH 
 *      Copyright (C) 2003 Timo Schulz
 *
 * This file is part of MyGPGME.
 *
 * MyGPGME is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * MyGPGME is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <sys/types.h>
#include <process.h>
#include <io.h>
#include <windows.h>

#include "util.h"
#include "context.h"
#include "ops.h"
#include "wait.h"
#include "sema.h"
#include "gpgme-io.h"
#include "rungpg.h"

struct wait_item_s;
struct proc_s;

static struct proc_s * proc_queue;
DEFINE_STATIC_LOCK (proc_queue_lock);

static int fd_table_size;
static struct io_select_fd_s * fd_table;
DEFINE_STATIC_LOCK (fd_table_lock);


struct proc_s {
    struct proc_s * next;
    int pid;
    gpgme_ctx_t ctx;
    struct wait_item_s * handler_list;
    int ready;
};

struct wait_item_s {
    struct wait_item_s *next;
    int (*handler)(void*, int, int);
    void *handler_value;
    int inbound;       /* this is an inbound data handler fd */
    struct proc_s * proc; /* backlink */
    int ready;
    int frozen; /* copy of the frozen flag from the fd_table */
};


static int do_select (void);

void 
wait_cleanup (void)
{
    DESTROY_LOCK (proc_queue_lock);
    DESTROY_LOCK (fd_table_lock);
}

/* only to be called with a locked proc_queue */
static int
count_running_fds ( struct proc_s *proc )
{
    struct wait_item_s *q;
    int count = 0;

    for (q=proc->handler_list; q; q=q->next) {
        if ( !q->frozen && !q->ready )
            count++;
    }
    return count;
}

/* only to be called with a locked proc_queue */
static void
set_process_ready ( struct proc_s *proc )
{
    struct wait_item_s *q, *q2;
    int i;

    assert (proc);
    DEBUG2 ("set_process_ready(%p) pid=%d", proc, proc->pid );
    LOCK (fd_table_lock);
    for (q = proc->handler_list; q; q=q2) {
        q2 = q->next;
        for (i=0; i < fd_table_size; i++ ) {
            if (fd_table[i].fd != -1 && q == fd_table[i].opaque ) {
                fd_table[i].opaque = NULL;
                fd_table[i].fd = -1;
            }
        }
        safe_free (q);
    }
    UNLOCK (fd_table_lock);
    proc->handler_list = NULL;
    proc->ready = 1;
}


void
_gpgme_remove_proc_from_wait_queue (int pid)
{
    struct proc_s *proc, *last;

    DEBUG1 ("removing process %d", pid);
    LOCK (proc_queue_lock);
    for (last=NULL, proc=proc_queue; proc; last = proc, proc = proc->next) {
        if (proc->pid == pid) {
            set_process_ready (proc);
            if (!last)
                proc_queue = proc->next;
            else
                last->next = proc->next;
            safe_free (proc);
            break;
        }
    }
    UNLOCK (proc_queue_lock);
}


/**
 * gpgme_wait:
 * @c: 
 * @hang: 
 * 
 * Wait for a finished request, if @c is given the function does only
 * wait on a finsihed request for that context, otherwise it will return
 * on any request.  When @hang is true the function will wait, otherwise
 * it will return immediately when there is no pending finished request.
 * 
 * Return value: Context of the finished request or NULL if @hang is false
 *  and no (or the given) request has finished.
 **/
gpgme_ctx_t 
gpgme_wait ( gpgme_ctx_t c, int hang ) 
{
    return _gpgme_wait_on_condition ( c, hang, NULL );
}

gpgme_ctx_t 
_gpgme_wait_on_condition (gpgme_ctx_t c, int hang, volatile int *cond)
{
    DEBUG3 ("waiting... ctx=%p hang=%d cond=%p", c, hang, cond);
    do {
        int did_work = do_select ();
        int any = 0;
        struct proc_s *proc;

        if ( cond && *cond )
            hang = 0;
        else {
            LOCK (proc_queue_lock);
            for (proc=proc_queue; proc; proc = proc->next ) {
                if (!proc->ready && !count_running_fds (proc))
                    set_process_ready (proc);
                if (c && proc->ready && proc->ctx == c)
                    hang = 0;
                if (!proc->ready)
                    any = 1;
            }
            UNLOCK (proc_queue_lock);
            if (!any)
                hang = 0;
        }
        /* fixme: we should check here for hanging processes */
        if(hang)
            _gpgme_gpg_housecleaning ();
    } while (hang && !c->cancel );
    c->cancel = 0; /* fixme: fix all functions, to return a cancel error */
    GetExitCodeProcess ((HANDLE)( _gpgme_gpg_getpid (c->gpg)), &c->proc_rc);

    return c;
}


/*
 * We use this function to do the select stuff for all running
 * gpgs.  A future version might provide a facility to delegate
 * those selects to the GDK select stuff.
 * This function must be called only by one thread!!
 * Returns: 0 = nothing to run
 *          1 = did run something 
 */

static int
do_select ( void )
{
    int i, n;
    int any=0;
    
    n = _gpgme_io_select ( fd_table, fd_table_size );
    if ( n <= 0 ) 
        return 0; /* error or timeout */

    for (i=0; i < fd_table_size && n; i++ ) {
        if ( fd_table[i].fd != -1 && fd_table[i].signaled 
             && !fd_table[i].frozen ) {
            struct wait_item_s *q;

            assert (n);
            n--;
            
            q = fd_table[i].opaque;
            assert ( q );
            assert ( q->proc );
            assert ( !q->ready );
            any = 1;
            if ( q->handler (q->handler_value,
                             q->proc->pid, fd_table[i].fd ) ) {
                DEBUG2 ("setting fd %d (q=%p) ready", fd_table[i].fd, q );
                q->ready = 1;
                /* free the table entry*/
                LOCK (fd_table_lock);
                fd_table[i].for_read = 0;
                fd_table[i].for_write = 0;
                fd_table[i].fd = -1;
                fd_table[i].opaque = NULL;
                UNLOCK (fd_table_lock);
            }
        }
    }
    
    return any;
}


/* 
 * called by rungpg.c to register something for select()
 */
gpgme_error_t
_gpgme_register_pipe_handler ( void *opaque, 
                              int (*handler)(void*,int,int),
                              void *handler_value,
                              int pid, int fd, int inbound )
{
    gpgme_ctx_t ctx = opaque;
    struct wait_item_s *q;
    struct proc_s *proc;
    int i;

    assert (opaque);
    assert (handler);

    /* Allocate a structure to hold info about the handler */
    q = calloc ( 1, sizeof *q );
    if ( !q )
        return mk_error (Out_Of_Core);
    q->inbound = inbound;
    q->handler = handler;
    q->handler_value = handler_value;

    /* Put this into the process queue */
    LOCK (proc_queue_lock);
    for (proc=proc_queue; proc && proc->pid != pid; proc = proc->next)
        ;
    if (!proc) { /* a new process */
        proc = calloc ( 1, sizeof *proc );
        if (!proc) {
            UNLOCK (proc_queue_lock);
            return mk_error (Out_Of_Core);
        }
        proc->pid = pid;
        proc->ctx = ctx;
        proc->next = proc_queue;
        proc_queue = proc;
    }
    assert (proc->ctx == ctx);
    q->proc = proc;
    q->next = proc->handler_list;
    proc->handler_list = q;
    UNLOCK (proc_queue_lock);
    
    LOCK (fd_table_lock);
 again:  
    for (i=0; i < fd_table_size; i++ ) {
        if ( fd_table[i].fd == -1 ) {
            fd_table[i].fd = fd;
            fd_table[i].for_read = inbound;    
            fd_table[i].for_write = !inbound;    
            fd_table[i].signaled = 0;
            fd_table[i].frozen = 0;
            fd_table[i].opaque = q;
            UNLOCK (fd_table_lock);
            return 0;
        }
    }
    if ( fd_table_size < 50 ) {
        /* FIXME: We have to wait until there are no other readers of the 
         * table, i.e that the io_select is not active in another thread */
        struct io_select_fd_s *tmp;

        tmp = realloc ( fd_table, (fd_table_size + 10) * sizeof *tmp );
        if ( tmp ) {
            for (i=0; i < 10; i++ )
                tmp[fd_table_size+i].fd = -1;
            fd_table_size += i;
            fd_table = tmp;
            goto again;
        }
    }

    UNLOCK (fd_table_lock);
    safe_free (q);
    /* FIXME: remove the proc table entry */
    return mk_error (Too_Many_Procs);
}


void
_gpgme_freeze_fd ( int fd )
{
    int i;

    LOCK (fd_table_lock);
    for (i=0; i < fd_table_size; i++ ) {
        if ( fd_table[i].fd == fd ) {
            struct wait_item_s *q;

            fd_table[i].frozen = 1;
            if ( (q=fd_table[i].opaque) )
                q->frozen = 1;
            DEBUG2 ("fd %d frozen (q=%p)", fd, q );
            break;
        }
    }
    UNLOCK (fd_table_lock);
}

void
_gpgme_thaw_fd ( int fd )
{
    int i;

    LOCK (fd_table_lock);
    for (i=0; i < fd_table_size; i++ ) {
        if ( fd_table[i].fd == fd ) {
            struct wait_item_s *q;

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