2002-07-28 Marcus Brinkmann <[email protected]>

	* data.c (gpgme_data_read): For GPGME_DATA_TYPE_NONE, return EOF
	instead an error.

	The following changes make it possible to flush an inbound data
	pipe before invoking a command handler:

	* posix-io.c (_gpgme_io_select): Accept new argument NONBLOCK to
	_gpgme_io_select.  Set timeout of 0 if this is set.
	* w32-io.c (_gpgme_io_select): Likewise.
	* io.h: Add new argument NONBLOCK to _gpgme_io_select prototype.
	* wait.c (do_select): Add new argument to _gpgme_io_select
	invocation.
	* rungpg.h (_gpgme_gpg_set_command_handler): Add new argument
	linked_data to prototype.
	* engine.h (_gpgme_engine_set_command_handler): Likewise.
	* engine.c (_gpgme_engine_set_command_handler): Likewise.
	* passphrase.c (_gpgme_passphrase_start): Pass NULL as linked_data
	argument to _gpgme_engine_set_command_handler.
	* rungpg.c (struct gpg_object_s): New members linked_data and
	linked_idx in CMD.
	(_gpgme_gpg_new): Initialize those new members.
	(_gpgme_gpg_set_command_handler): Accept new argument linked_data.
	(build_argv): Handle linked_data in the same hack as cb_data.
	(read_status): If linked_data is in use, flush the pipe before
	activating the command handler.
	* gpgme.h: Add prototypes for gpgme_op_edit_start and
	gpgme_op_edit.

	The next changes export the status codes to the user:

	* decrypt.c (_gpgme_decrypt_status_handler): Likewise, also prefix
	all STATUS_ with GPGME_.
	* delete.c (delete_status_handler): Likewise.
	* decrypt-verify.c (decrypt_verify_status_handler): Likewise.
	* encrypt.c (_gpgme_encrypt_status_handler): Likewise.
	(_gpgme_encrypt_sym_status_handler): Likewise.
	* encrypt-sign.c (encrypt_sign_status_handler): Likewise.
	* engine-gpgsm.c (parse_status): Likewise.
	(gpgsm_status_handler): Likewise.
	(gpgsm_set_recipients): Likewise.
	* export.c (export_status_handler): Likewise.
	* genkey.c (genkey_status_handler): Likewise.
	* import.c (append_xml_impinfo): Likewise.
	(import_status_handler): Likewise.
	* keylist.c (keylist_status_handler): Likewise.
	* passphrase.c (_gpgme_passphrase_status_handler): Likewise.
	(command_handler): Likewise.
	* progress.c (_gpgme_progress_status_handler): Likewise.
	* sign.c (_gpgme_sign_status_handler): Likewise.
	* trustlist.c (trustlist_status_handler): Likewise.
	* verify.c (_gpgme_verify_status_handler): Likewise.
	* gpgme.h (GpgmeEditCb): New type.
	* rungpg.h (GpgStatusCode): Rename and move to ...
	* gpgme.h (GpgmeStatusCode): ... this and here.
	* Makefile.am (status-table.h): Run mkstatus on gpgme.h, not rungpg.h.
	* mkstatus: Prefix STATUS with GPGME_.
	* rungpg.h (GpgStatusHandler, GpgCommandHandler): Change type
	accordingly.
	* ops.h (_gpgme_verify_status_handler,
	_gpgme_decrypt_status_handler, _gpgme_sign_status_handler,
	_gpgme_encrypt_status_handler, _gpgme_passphrase_status_handler,
	_gpgme_progress_status_handler): Likewise.
	* rungpg.c (struct gpg_object_s): Likewise for CMD.code.

	These changes add an edit operation to GPGME:

	* context.h (struct gpgme_context_s): New member RESULT.edit.  *
	ops.h: Add prototype for _gpgme_release_edit_result and
	_gpgme_passphrase_command_handler.
	* passphrase.c (command_handler): Make non-static and rename to ...
	(_gpgme_passphrase_command_handler): ... this.
	(_gpgme_passphrase_start): Use new name for command handler.
	* types.h: Add EditResult type.
	* gpgme.c (_gpgme_release_result): Release EDIT result.
	* edit.c: New file.
	* Makefile.am (libgpgme_la_SOURCES): Add edit.c.
	(libgpgme_la_LDADD): Rename to libgpgme_la_LIBADD, and include
	assuan_libobjs.
	(assuan_libobjs): New variable, set this instead
	libgpgme_la_LIBADD.
	* engine.h (_gpgme_engine_op_edit): New prototype.
	* engine.c (_gpgme_engine_op_edit): New function.
	* rungpg.h (_gpgme_gpg_op_edit): New prototype.
	* rungpg.c (_gpgme_gpg_op_edit): New function.

1 files changed, 158 insertions, 0 deletions

diff --git a/gpgme/edit.c b/gpgme/edit.c
new file mode 100644
index 00000000..9b9ee740
--- /dev/null
+++ b/gpgme/edit.c
@@ -0,0 +1,158 @@
+/* edit.c - key edit functions
+ *      Copyright (C) 2002 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "util.h"
+#include "context.h"
+#include "ops.h"
+
+
+struct edit_result_s
+{
+  GpgmeEditCb fnc;
+  void *fnc_value;
+};
+
+void
+_gpgme_release_edit_result (EditResult result)
+{
+  if (!result)
+    return;
+  xfree (result);
+}
+
+void
+_gpgme_edit_status_handler (GpgmeCtx ctx, GpgmeStatusCode status, char *args)
+{
+  _gpgme_passphrase_status_handler (ctx, status, args);
+
+  if (ctx->error)
+    return;
+
+  ctx->error = (*ctx->result.edit->fnc) (ctx->result.edit->fnc_value, status, args, NULL);
+}
+
+static const char *
+command_handler (void *opaque, GpgmeStatusCode status, const char *args)
+{
+  GpgmeCtx ctx = opaque;
+  const char *result;
+
+  result = _gpgme_passphrase_command_handler (ctx, status, args);
+
+  if (!result)
+    ctx->error = (*ctx->result.edit->fnc) (ctx->result.edit->fnc_value, status, args, &result);
+
+  return result;
+}
+
+static GpgmeError
+_gpgme_op_edit_start (GpgmeCtx ctx, int synchronous,
+		      GpgmeKey key,
+		      GpgmeEditCb fnc, void *fnc_value,
+		      GpgmeData out)
+{
+  GpgmeError err = 0;
+
+  if (!fnc)
+    return mk_error (Invalid_Value);
+
+  err = _gpgme_op_reset (ctx, synchronous);
+  if (err)
+    goto leave;
+
+  assert (!ctx->result.edit);
+  ctx->result.edit = xtrymalloc (sizeof *ctx->result.edit);
+  if (!ctx->result.edit)
+    {
+      err = mk_error (Out_Of_Core);
+      goto leave;
+    }
+  ctx->result.edit->fnc = fnc;
+  ctx->result.edit->fnc_value = fnc_value;
+
+  /* Check the supplied data.  */
+  if (!out || gpgme_data_get_type (out) != GPGME_DATA_TYPE_NONE)
+    {
+      err = mk_error (Invalid_Value);
+      goto leave;
+    }
+  _gpgme_data_set_mode (out, GPGME_DATA_MODE_IN);
+
+  err = _gpgme_engine_set_command_handler (ctx->engine, command_handler,
+					   ctx, out);
+  if (err)
+    goto leave;
+
+  _gpgme_engine_set_status_handler (ctx->engine, _gpgme_edit_status_handler,
+				    ctx);
+
+  _gpgme_engine_set_verbosity (ctx->engine, ctx->verbosity);
+
+  _gpgme_engine_op_edit (ctx->engine, key, out);
+
+  /* And kick off the process.  */
+  err = _gpgme_engine_start (ctx->engine, ctx);
+  
+ leave:
+  if (err)
+    {
+      ctx->pending = 0; 
+      _gpgme_engine_release (ctx->engine);
+      ctx->engine = NULL;
+    }
+  return err;
+}
+
+GpgmeError
+gpgme_op_edit_start (GpgmeCtx ctx,
+		     GpgmeKey key,
+		     GpgmeEditCb fnc, void *fnc_value,
+		     GpgmeData out)
+{
+  return _gpgme_op_edit_start (ctx, 0, key, fnc, fnc_value, out);
+}
+
+/**
+ * gpgme_op_edit:
+ * @ctx: The context
+ * @key: The key to be edited.
+ * @fnc: An edit callback handler.
+ * @fnc_value: To be passed to @fnc as first arg.
+ * @out: The output.
+ * 
+ * Return value: 0 on success or an error code.
+ **/
+GpgmeError
+gpgme_op_edit (GpgmeCtx ctx,
+	       GpgmeKey key,
+	       GpgmeEditCb fnc, void *fnc_value,
+	       GpgmeData out)
+{
+  GpgmeError err = _gpgme_op_edit_start (ctx, 1, key, fnc, fnc_value, out);
+  if (!err)
+    err = _gpgme_wait_one (ctx);
+  return err;
+}