json: Add additional commands to help
[gpgme.git] / src / encrypt-sign.c
index c80cb2a..4db46e2 100644 (file)
@@ -1,19 +1,19 @@
 /* encrypt-sign.c -  encrypt and verify functions
    Copyright (C) 2000 Werner Koch (dd9jn)
    Copyright (C) 2001, 2002, 2003, 2004 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 Lesser General Public License as
    published by the Free Software Foundation; either version 2.1 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
    Lesser General Public License for more details.
-   
+
    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
@@ -22,6 +22,9 @@
 #if HAVE_CONFIG_H
 #include <config.h>
 #endif
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
 
 #include "gpgme.h"
 #include "debug.h"
@@ -44,19 +47,39 @@ encrypt_sign_status_handler (void *priv, gpgme_status_code_t code, char *args)
 
 
 static gpgme_error_t
+encrypt_sym_status_handler (void *priv, gpgme_status_code_t code, char *args)
+{
+  gpgme_error_t err;
+
+  err = _gpgme_progress_status_handler (priv, code, args);
+  if (!err)
+    err = _gpgme_sign_status_handler (priv, code, args);
+  if (!err)
+    err = _gpgme_passphrase_status_handler (priv, code, args);
+  return err;
+}
+
+
+static gpgme_error_t
 encrypt_sign_start (gpgme_ctx_t ctx, int synchronous, gpgme_key_t recp[],
+                    const char *recpstring,
                    gpgme_encrypt_flags_t flags,
                    gpgme_data_t plain, gpgme_data_t cipher)
 {
   gpgme_error_t err;
+  int symmetric;
 
   err = _gpgme_op_reset (ctx, synchronous);
   if (err)
     return err;
 
+  symmetric = (!recp && !recpstring) || (flags & GPGME_ENCRYPT_SYMMETRIC);
+
   if (!plain)
     return gpg_error (GPG_ERR_NO_DATA);
-  if (!cipher || !recp)
+  if (!cipher)
+    return gpg_error (GPG_ERR_INV_VALUE);
+  if (recp && !*recp)
     return gpg_error (GPG_ERR_INV_VALUE);
 
   err = _gpgme_op_encrypt_init_result (ctx);
@@ -76,70 +99,120 @@ encrypt_sign_start (gpgme_ctx_t ctx, int synchronous, gpgme_key_t recp[],
     }
 
   _gpgme_engine_set_status_handler (ctx->engine,
-                                   encrypt_sign_status_handler, ctx);
-  
-  return _gpgme_engine_op_encrypt_sign (ctx->engine, recp, flags, plain,
+                                    symmetric
+                                    ? encrypt_sym_status_handler
+                                    : encrypt_sign_status_handler,
+                                   ctx);
+
+  return _gpgme_engine_op_encrypt_sign (ctx->engine, recp, recpstring,
+                                        flags, plain,
                                        cipher, ctx->use_armor,
                                        ctx /* FIXME */);
 }
 
 
-/* Encrypt plaintext PLAIN within CTX for the recipients RECP and
-   store the resulting ciphertext in CIPHER.  Also sign the ciphertext
-   with the signers in CTX.  */
+/* Old version of gpgme_op_encrypt_sign_ext_start w/o RECPSTRING.  */
 gpgme_error_t
 gpgme_op_encrypt_sign_start (gpgme_ctx_t ctx, gpgme_key_t recp[],
                             gpgme_encrypt_flags_t flags,
                             gpgme_data_t plain, gpgme_data_t cipher)
 {
-  TRACE_BEG3 (DEBUG_CTX, "gpgme_op_encrypt_sign_start", ctx,
-             "flags=0x%x, plain=%p, cipher=%p", flags, plain, cipher);
-  
-  if (_gpgme_debug_trace () && recp)
-    {
-      int i = 0;
-
-      while (recp[i])
-       {
-         TRACE_LOG3 ("recipient[%i] = %p (%s)", i,recp[i],
-                     (recp[i]->subkeys && !recp[i]->subkeys->fpr) ? 
-                     recp[i]->subkeys->fpr : "invalid");
-         i++;
-       }
-    }
-
-  return TRACE_ERR (encrypt_sign_start (ctx, 0, recp, flags, plain, cipher));
+  return gpgme_op_encrypt_sign_ext_start (ctx, recp, NULL,
+                                          flags, plain, cipher);
 }
 
 
-/* Encrypt plaintext PLAIN within CTX for the recipients RECP and
-   store the resulting ciphertext in CIPHER.  Also sign the ciphertext
-   with the signers in CTX.  */
+/* Old version of gpgme_op_encrypt_sign_ext w/o RECPSTRING.  */
 gpgme_error_t
 gpgme_op_encrypt_sign (gpgme_ctx_t ctx, gpgme_key_t recp[],
                       gpgme_encrypt_flags_t flags,
                       gpgme_data_t plain, gpgme_data_t cipher)
 {
+  return gpgme_op_encrypt_sign_ext (ctx, recp, NULL, flags, plain, cipher);
+}
+
+
+/* Encrypt plaintext PLAIN within CTX for the recipients RECP and
+ * store the resulting ciphertext in CIPHER.  Also sign the ciphertext
+ * with the signers in CTX.  */
+gpgme_error_t
+gpgme_op_encrypt_sign_ext (gpgme_ctx_t ctx, gpgme_key_t recp[],
+                           const char *recpstring,
+                           gpgme_encrypt_flags_t flags,
+                           gpgme_data_t plain, gpgme_data_t cipher)
+{
   gpgme_error_t err;
 
   TRACE_BEG3 (DEBUG_CTX, "gpgme_op_encrypt_sign", ctx,
              "flags=0x%x, plain=%p, cipher=%p", flags, plain, cipher);
-  
-  if (_gpgme_debug_trace () && recp)
+
+  if (!ctx)
+    return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
+
+  if (_gpgme_debug_trace () && (recp || recpstring))
     {
-      int i = 0;
-
-      while (recp[i])
-       {
-         TRACE_LOG3 ("recipient[%i] = %p (%s)", i,recp[i],
-                     (recp[i]->subkeys && !recp[i]->subkeys->fpr) ? 
-                     recp[i]->subkeys->fpr : "invalid");
-         i++;
-       }
+      if (recp)
+        {
+          int i = 0;
+
+          while (recp[i])
+            {
+              TRACE_LOG3 ("recipient[%i] = %p (%s)", i, recp[i],
+                          (recp[i]->subkeys && recp[i]->subkeys->fpr) ?
+                          recp[i]->subkeys->fpr : "invalid");
+              i++;
+            }
+        }
+      else
+        {
+          TRACE_LOG1 ("recipients = '%s'", recpstring);
+        }
     }
 
-  err = encrypt_sign_start (ctx, 1, recp, flags, plain, cipher);
+  err = encrypt_sign_start (ctx, 1, recp, recpstring, flags, plain, cipher);
   if (!err)
     err = _gpgme_wait_one (ctx);
   return TRACE_ERR (err);
 }
+
+
+/* Encrypt plaintext PLAIN within CTX for the recipients RECP and
+   store the resulting ciphertext in CIPHER.  Also sign the ciphertext
+   with the signers in CTX.  */
+gpgme_error_t
+gpgme_op_encrypt_sign_ext_start (gpgme_ctx_t ctx, gpgme_key_t recp[],
+                                 const char *recpstring,
+                                 gpgme_encrypt_flags_t flags,
+                                 gpgme_data_t plain, gpgme_data_t cipher)
+{
+  gpgme_error_t err;
+
+  TRACE_BEG3 (DEBUG_CTX, "gpgme_op_encrypt_sign_start", ctx,
+             "flags=0x%x, plain=%p, cipher=%p", flags, plain, cipher);
+
+  if (!ctx)
+    return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
+
+  if (_gpgme_debug_trace () && (recp || recpstring))
+    {
+      if (recp)
+        {
+          int i = 0;
+
+          while (recp[i])
+            {
+              TRACE_LOG3 ("recipient[%i] = %p (%s)", i, recp[i],
+                          (recp[i]->subkeys && recp[i]->subkeys->fpr) ?
+                          recp[i]->subkeys->fpr : "invalid");
+              i++;
+            }
+        }
+      else
+        {
+          TRACE_LOG1 ("recipients = '%s'", recpstring);
+        }
+    }
+
+  err = encrypt_sign_start (ctx, 0, recp, recpstring, flags, plain, cipher);
+  return err;
+}