doc/

2003-01-29  Marcus Brinkmann  <[email protected]>

	* gpgme.texi (I/O Callback Interface): Document new even
	GPGME_EVENT_START.
	(Waiting For Completion): Document new possible return values.
	(I/O Callback Interface): Document return type of GpgmeIOCb.

gpgme/
2003-01-29  Marcus Brinkmann  <[email protected]>

	* context.h (gpgme_context_s): Remove member ERROR.
	* types.h (GpgmeStatusHandler): Change return type to GpgmeError.
	(GpgmeCommandHandler): Change return type to GpgmeError and add
	new argument RESULT.
	* gpgme.h (GpgmeIOCb): Change return type to GpgmeError.
	(GpgmeEventIO): New event GPGME_EVENT_START.
	(GpgmeIdleFunc): Remove type.
	(gpgme_register_idle): Remove prototype.
	* data.c: Include <assert.h>.
	(_gpgme_data_inbound_handler): Change return type to GpgmeError.
	Return any error instead ignoring it, don't close file descriptor
	on error.
	(_gpgme_data_outbound_handler): Likewise.
	* decrypt.c: Do not include <stdio.h>, <string.h> and <assert.h>.
	(_gpgme_decrypt_status_handler): Change return type to GpgmeError.
	Return error instead setting ctx->error.  Return success at end of
	function.
	(gpgme_op_decrypt): Don't work around the old kludge anymore.
	* decrypt-verify.c (decrypt_verify_status_handler): Change return
	type to GpgmeError.  Return possible errors.
	* delete.c: Do not include <stdio.h>, <string.h>, <time.h> and
	<assert.h>.
	(delete_status_handler): Change return type to GpgmeError.  Return
	error instead setting ctx->error.  Return success at end of
	function.
	* edit.c: Do not include <stdio.h> and <string.h>.
	(_gpgme_edit_status_handler): Change type to GpgmeError,
	make static and rename to ...
	(edit_status_handler): ... this.  Return error directly.
	(command_handler): Change return type to GpgmeError, add result
	argument.  Return error directly.
	* encrypt.c (status_handler_finish): Remove function.
	(_gpgme_encrypt_status_handler): Change return type to GpgmeError.
	Return error directly.
	(_gpgme_encrypt_sym_status_handler): Likewise.
	* encrypt-sign.c (encrypt_sign_status_handler): Likewise.
	* engine-gpgsm.c (close_notify_handler): Do not signal done event
	anymore.
	(status_handler): Change return type to GpgmeError.  Diddle things
	around a bit to return errors directly.
	(start): Send start event.
	* export.c: Do not include <stdio.h>, <string.h> and <assert.h>.
	(export_status_handler): Change return type to GpgmeError.  Don't
	check ctx->error.
	* genkey.c: Do not include <stdio.h> and <assert.h>.
	(genkey_status_handler): Change return type to GpgmeError.  Don't
	check ctx->error.  Return errors directly.
	* gpgme.c (_gpgme_release_result): Do not initialize ctx->error.
	(_gpgme_op_event_cb): Function removed.
	(_gpgme_op_event_cb_user): Likewise.
	* import.c: Do not include <stdio.h>, <string.h> and <assert.h>.
	(import_status_handler): Change return type to GpgmeError.  Don't
	check ctx->error.
	* keylist.c (keylist_colon_handler, keylist_status_handler, finish_key):
	Change return type to GpgmeError, return error directly.
	* Makefile (libgpgme_la_SOURCES): Add wait-global.c,
	wait-private.c and wait-user.c
	* ops.h (test_and_allocate_result): Return error instead setting
	ctx->error.
	(_gpgme_data_inbound_handler, _gpgme_data_outbound_handler,
	_gpgme_verify_status_handler, _gpgme_decrypt_status_handler,
	_gpgme_sign_status_handler, _gpgme_encrypt_staus_handler,
	_gpgme_passphrase_status_handler, _gpgme_progress_status_handler):
	Change return type to GpgmeError.
	(_gpgme_passphease_command_handler): Change return type to
	GpgmeError and add new argument RESULT.
	* op-support.c: Use new callback functions, and change private
	data to ctx everywhere.
	* passphrase.c (_gpgme_passphrase_status_handler): Change return
	type to GpgmeError, return error directly.
	(_gpgme_passphrase_command_handler): Change return type to
	GpgmeError, add result argument.  Return results accordingly.
	* progress.c (_gpgme_progress_status_handler): Change return type
	to GpgmeError, return errors directly.
	* rungpg.c (status_handler): Change return type to GpgmeError.
	Return error directly.
	(close_notify_handler): Don't send done event.
	(colon_line_handler): Change return type to GpgmeError, return
	errors directly.
	* rungpg.c (start): Send start event.
	* sign.c (_gpgme_sign_status_handler): Change return type to
	GpgmeError, return errors directly.
	* trustlist.c (trustlist_status_handler): Change return type to
	GpgmeError.  Return 0.
	(trustlist_colon_handler): Change return type GpgmeError.  Return
	errors directly.
	* verify.c (add_notation): Change return type to GpgmeError,
	return errors directly.
	(_gpgme_verify_status_handler): Likewise.
	* wait.h (struct fd_table): Remove lock member.
	(struct wait_item_s): Moved here from wait.c.
	(struct tag): New structure.
	(_gpgme_wait_event_cb): Remove prototype.
	(_gpgme_wait_private_event_cb, _gpgme_wait_global_event_cb,
	_gpgme_wait_user_add_io_cb, _gpgme_wait_user_remove_io_cb,
	_gpgme_wait_user_event_io_cb): New prototypes.
	* wait.c: Don't include <stdio.h>.
	(ftd_global, ctx_done_list, ctx_done_list_size,
	ctx_done_list_length, ctx_done_list_lock, idle_function): Remove
	global variable.
	(gpgme_register_idle, do_select, _gpgme_wait_event_cb): Remove
	function.
	(gpgme_wait): Move to file wait-global.c.
	(_gpgme_add_io_cb): Take ctx as private argument, initialize ctx
	member in wait item and tag.
	(_gpgme_remove_io_cb): Take ctx from tag.  Don't use FDT lock.
	(_gpgme_wait_one, _gpgme_wait_on_condition): Move to
	wait-private.c.
	(gpgme_fd_table_init): Don't initialize FDT->lock.
	(gpgme_fd_table_deinit): Don't destroy FDT->lock.
	(_gpgme_fd_table_put): Make static and rename to ...
	(fd_table_put): ... this function.  Don't use FDT->lock.
	(struct wait_item_s): Move to wait.h.
	* wait-global.c: New file.
	* wait-private.c: New file.
	* wait-user.c: New file.

1 files changed, 127 insertions, 0 deletions

diff --git a/gpgme/wait-user.c b/gpgme/wait-user.c
new file mode 100644
index 00000000..e148491b
--- /dev/null
+++ b/gpgme/wait-user.c
@@ -0,0 +1,127 @@
+/* wait.c 
+   Copyright (C) 2000 Werner Koch (dd9jn)
+   Copyright (C) 2001, 2002, 2003 g10 Code GmbH
+ 
+   This file is part of GPGME.
+ 
+   GPGME 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.
+ 
+   GPGME 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 GPGME; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <assert.h>
+
+#include "gpgme.h"
+#include "context.h"
+#include "io.h"
+#include "wait.h"
+
+
+/* The user event loops are used for all asynchronous operations for
+   which a user callback is defined.  */
+
+
+/* Internal I/O Callbacks.  */
+
+GpgmeError
+_gpgme_user_io_cb_handler (void *data, int fd)
+{
+  GpgmeError err;
+  struct tag *tag = (struct tag *) data;
+  GpgmeCtx ctx;
+  struct wait_item_s *item;
+
+  assert (data);
+  ctx = tag->ctx;
+  assert (ctx);
+  item = (struct wait_item_s *) ctx->fdt.fds[tag->idx].opaque;
+  assert (item);
+
+  err = (*item->handler) (item->handler_value, fd);
+  if (err)
+    {
+      int idx;
+
+      for (idx = 0; idx < ctx->fdt.size; idx++)
+	if (ctx->fdt.fds[idx].fd != -1)
+	  _gpgme_io_close (ctx->fdt.fds[idx].fd);
+      _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &err);
+    }
+  return 0;
+}
+
+
+/* Register the file descriptor FD with the handler FNC (which gets
+   FNC_DATA as its first argument) for the direction DIR.  DATA should
+   be the context for which the fd is added.  R_TAG will hold the tag
+   that can be used to remove the fd.  */
+GpgmeError
+_gpgme_wait_user_add_io_cb (void *data, int fd, int dir, GpgmeIOCb fnc,
+			    void *fnc_data, void **r_tag)
+{
+  GpgmeCtx ctx = (GpgmeCtx) data;
+  struct tag *tag;
+  GpgmeError err;
+
+  assert (ctx);
+  err = _gpgme_add_io_cb (data, fd, dir, fnc, fnc_data, r_tag);
+  if (err)
+    return err;
+  tag = *r_tag;
+  assert (tag);
+  err = (*ctx->io_cbs.add) (ctx->io_cbs.add_priv, fd, dir,
+			    _gpgme_user_io_cb_handler, *r_tag,
+			    &tag->user_tag);
+  if (err)
+    _gpgme_remove_io_cb (*r_tag);
+  return err;
+}
+
+
+void
+_gpgme_wait_user_remove_io_cb (void *data)
+{
+  struct tag *tag = (struct tag *) data;
+  GpgmeCtx ctx;
+  int i;
+
+  assert (tag);
+  ctx = tag->ctx;
+
+  (*ctx->io_cbs.remove) (tag->user_tag);
+  _gpgme_remove_io_cb (data);
+
+  for (i = 0; i < ctx->fdt.size; i++)
+    if (ctx->fdt.fds[i].fd != -1)
+      break;
+  if (i == ctx->fdt.size)
+    {
+      GpgmeError err = 0;
+      _gpgme_engine_io_event (ctx->engine, GPGME_EVENT_DONE, &err);
+    }
+}
+
+
+void
+_gpgme_wait_user_event_cb (void *data, GpgmeEventIO type, void *type_data)
+{
+  GpgmeCtx ctx = data;
+
+  if (type == GPGME_EVENT_DONE)
+    ctx->pending = 0;
+
+  if (ctx->io_cbs.event)
+    (*ctx->io_cbs.event) (ctx->io_cbs.event_priv, type, type_data);
+}