core: Add 'is_mime' flags to the verify and decrypt results.
[gpgme.git] / src / gpgme-json.c
index 6ba79e5..f63f196 100644 (file)
@@ -33,6 +33,7 @@
 #include <locale.h>
 #endif
 #include <stdint.h>
+#include <sys/stat.h>
 
 #define GPGRT_ENABLE_ES_MACROS 1
 #define GPGRT_ENABLE_LOG_MACROS 1
 #include "cJSON.h"
 
 
+#if GPGRT_VERSION_NUMBER < 0x011c00 /* 1.28 */
+int main (void){fputs ("Build with Libgpg-error >= 1.28!\n", stderr);return 1;}
+#else /* libgpg-error >= 1.28 */
+
 /* We don't allow a request with more than 64 MiB.  */
 #define MAX_REQUEST_SIZE (64 * 1024 * 1024)
 
+/* Minimal, default and maximum chunk size for returned data. The
+ * first chunk is returned directly.  If the "more" flag is also
+ * returned, a "getmore" command needs to be used to get the next
+ * chunk.  Right now this value covers just the value of the "data"
+ * element; so to cover for the other returned objects this values
+ * needs to be lower than the maximum allowed size of the browser. */
+#define MIN_REPLY_CHUNK_SIZE  512
+#define DEF_REPLY_CHUNK_SIZE (512 * 1024)
+#define MAX_REPLY_CHUNK_SIZE (10 * 1024 * 1024)
+
 
 static void xoutofcore (const char *type) GPGRT_ATTR_NORETURN;
 static cjson_t error_object_v (cjson_t json, const char *message,
@@ -56,7 +71,18 @@ static char *error_object_string (const char *message,
 
 /* True if interactive mode is active.  */
 static int opt_interactive;
+/* True is debug mode is active.  */
+static int opt_debug;
 
+/* Pending data to be returned by a getmore command.  */
+static struct
+{
+  char  *buffer;   /* Malloced data or NULL if not used.  */
+  size_t length;   /* Length of that data.  */
+  size_t written;  /* # of already written bytes from BUFFER.  */
+  const char *type;/* The "type" of the data.  */
+  int base64;      /* The "base64" flag of the data.  */
+} pending_data;
 
 
 /*
@@ -141,18 +167,21 @@ xjson_AddBoolToObject (cjson_t object, const char *name, int abool)
   return ;
 }
 
-/* This is similar to cJSON_AddStringToObject but takes a gpgme DATA
- * object and adds it under NAME as a base 64 encoded string to
- * OBJECT.  Ownership of DATA is transferred to this function.  */
+/* This is similar to cJSON_AddStringToObject but takes (DATA,
+ * DATALEN) and adds it under NAME as a base 64 encoded string to
+ * OBJECT.  */
 static gpg_error_t
-add_base64_to_object (cjson_t object, const char *name, gpgme_data_t data)
+add_base64_to_object (cjson_t object, const char *name,
+                      const void *data, size_t datalen)
 {
+#if GPGRT_VERSION_NUMBER < 0x011d00 /* 1.29 */
+  return gpg_error (GPG_ERR_NOT_SUPPORTED);
+#else
   gpg_err_code_t err;
   estream_t fp = NULL;
   gpgrt_b64state_t state = NULL;
   cjson_t j_str = NULL;
   void *buffer = NULL;
-  size_t buflen;
 
   fp = es_fopenmem (0, "rwb");
   if (!fp)
@@ -167,20 +196,9 @@ add_base64_to_object (cjson_t object, const char *name, gpgme_data_t data)
       goto leave;
     }
 
-  gpgme_data_write (data, "", 1); /* Make sure we have  a string.  */
-  buffer = gpgme_data_release_and_get_mem (data, &buflen);
-  data = NULL;
-  if (!buffer)
-    {
-      err = gpg_error_from_syserror ();
-      goto leave;
-    }
-
-  err = gpgrt_b64enc_write (state, buffer, buflen);
+  err = gpgrt_b64enc_write (state, data, datalen);
   if (err)
     goto leave;
-  xfree (buffer);
-  buffer = NULL;
 
   err = gpgrt_b64enc_finish (state);
   state = NULL;
@@ -218,8 +236,8 @@ add_base64_to_object (cjson_t object, const char *name, gpgme_data_t data)
   cJSON_Delete (j_str);
   gpgrt_b64enc_finish (state);
   es_fclose (fp);
-  gpgme_data_release (data);
   return err;
+#endif
 }
 
 
@@ -345,18 +363,42 @@ get_protocol (cjson_t json, gpgme_protocol_t *r_protocol)
 }
 
 
-/* Extract the keys from the KEYS array in the JSON object.  CTX is a
- * GPGME context object.  On success an array with the keys is stored
- * at R_KEYS.  In failure an error code is returned.  */
+/* Get the chunksize from JSON and store it at R_CHUNKSIZE.  */
 static gpg_error_t
-get_keys (gpgme_ctx_t ctx, cjson_t json, gpgme_key_t **r_keys)
+get_chunksize (cjson_t json, size_t *r_chunksize)
+{
+  cjson_t j_item;
+
+  *r_chunksize = DEF_REPLY_CHUNK_SIZE;
+  j_item = cJSON_GetObjectItem (json, "chunksize");
+  if (!j_item)
+    ;
+  else if (!cjson_is_number (j_item))
+    return gpg_error (GPG_ERR_INV_VALUE);
+  else if ((size_t)j_item->valueint < MIN_REPLY_CHUNK_SIZE)
+    *r_chunksize = MIN_REPLY_CHUNK_SIZE;
+  else if ((size_t)j_item->valueint > MAX_REPLY_CHUNK_SIZE)
+    *r_chunksize = MAX_REPLY_CHUNK_SIZE;
+  else
+    *r_chunksize = (size_t)j_item->valueint;
+
+  return 0;
+}
+
+
+/* Extract the keys from the "keys" array in the JSON object.  On
+ * success a string with the keys identifiers is stored at R_KEYS.
+ * The keys in that string are LF delimited.  On failure an error code
+ * is returned.  */
+static gpg_error_t
+get_keys (cjson_t json, char **r_keystring)
 {
-  gpg_error_t err;
   cjson_t j_keys, j_item;
   int i, nkeys;
-  gpgme_key_t *keys;
+  char *p;
+  size_t length;
 
-  *r_keys = NULL;
+  *r_keystring = NULL;
 
   j_keys = cJSON_GetObjectItem (json, "keys");
   if (!j_keys)
@@ -364,8 +406,15 @@ get_keys (gpgme_ctx_t ctx, cjson_t json, gpgme_key_t **r_keys)
   if (!cjson_is_array (j_keys) && !cjson_is_string (j_keys))
     return gpg_error (GPG_ERR_INV_VALUE);
 
+  /* Fixme: We should better use a membuf like thing.  */
+  length = 1; /* For the EOS.  */
   if (cjson_is_string (j_keys))
-    nkeys = 1;
+    {
+      nkeys = 1;
+      length += strlen (j_keys->valuestring);
+      if (strchr (j_keys->valuestring, '\n'))
+        return gpg_error (GPG_ERR_INV_USER_ID);
+    }
   else
     {
       nkeys = cJSON_GetArraySize (j_keys);
@@ -376,43 +425,37 @@ get_keys (gpgme_ctx_t ctx, cjson_t json, gpgme_key_t **r_keys)
           j_item = cJSON_GetArrayItem (j_keys, i);
           if (!j_item || !cjson_is_string (j_item))
             return gpg_error (GPG_ERR_INV_VALUE);
+          if (i)
+            length++; /* Space for delimiter. */
+          length += strlen (j_item->valuestring);
+          if (strchr (j_item->valuestring, '\n'))
+            return gpg_error (GPG_ERR_INV_USER_ID);
         }
     }
 
-  /* Now allocate an array to store the gpgme key objects.  */
-  keys = xcalloc (nkeys + 1, sizeof *keys);
+  p = *r_keystring = xtrymalloc (length);
+  if (!p)
+    return gpg_error_from_syserror ();
 
   if (cjson_is_string (j_keys))
     {
-      err = gpgme_get_key (ctx, j_keys->valuestring, &keys[0], 0);
-      if (err)
-        goto leave;
+      strcpy (p, j_keys->valuestring);
     }
   else
     {
       for (i=0; i < nkeys; i++)
         {
           j_item = cJSON_GetArrayItem (j_keys, i);
-          err = gpgme_get_key (ctx, j_item->valuestring, &keys[i], 0);
-          if (err)
-            goto leave;
+          if (i)
+            *p++ = '\n'; /* Add delimiter.  */
+          p = stpcpy (p, j_item->valuestring);
         }
     }
-  err = 0;
-  *r_keys = keys;
-  keys = NULL;
-
- leave:
-  if (keys)
-    {
-      for (i=0; keys[i]; i++)
-        gpgme_key_unref (keys[i]);
-      xfree (keys);
-    }
-  return err;
+  return 0;
 }
 
 
+
 \f
 /*
  *  GPGME support functions.
@@ -429,6 +472,7 @@ _create_new_context (gpgme_protocol_t proto)
   if (err)
     log_fatal ("error creating GPGME context: %s\n", gpg_strerror (err));
   gpgme_set_protocol (ctx, proto);
+  gpgme_set_ctx_flag (ctx, "request-origin", "browser");
   return ctx;
 }
 
@@ -536,10 +580,80 @@ data_from_base64_string (gpgme_data_t *r_data, cjson_t json)
 
 \f
 /*
- * Implementaion of the commands.
+ * Implementation of the commands.
  */
 
 
+/* Create a "data" object and the "type", "base64" and "more" flags
+ * from DATA and append them to RESULT.  Ownership if DATA is
+ * transferred to this function.  TYPE must be a fixed string.
+ * CHUNKSIZE is the chunksize requested from the caller.  Note that
+ * op_getmore has similar code but works on PENDING_DATA which is set
+ * here.  */
+static gpg_error_t
+make_data_object (cjson_t result, gpgme_data_t data, size_t chunksize,
+                  const char *type, int base64)
+{
+  gpg_error_t err;
+  char *buffer;
+  size_t buflen;
+  int c;
+
+  /* Adjust the chunksize if we need to do base64 conversion.  */
+  if (base64)
+    chunksize = (chunksize / 4) * 3;
+
+  if (!base64) /* Make sure that we really have a string.  */
+    gpgme_data_write (data, "", 1);
+
+  buffer = gpgme_data_release_and_get_mem (data, &buflen);
+  data = NULL;
+  if (!buffer)
+    {
+      err = gpg_error_from_syserror ();
+      goto leave;
+    }
+
+
+  xjson_AddStringToObject (result, "type", type);
+  xjson_AddBoolToObject (result, "base64", base64);
+
+  if (buflen > chunksize)
+    {
+      xjson_AddBoolToObject (result, "more", 1);
+
+      c = buffer[chunksize];
+      buffer[chunksize] = 0;
+      if (base64)
+        err = add_base64_to_object (result, "data", buffer, chunksize);
+      else
+        err = cjson_AddStringToObject (result, "data", buffer);
+      buffer[chunksize] = c;
+      if (err)
+        goto leave;
+
+      pending_data.buffer = buffer;
+      buffer = NULL;
+      pending_data.length = buflen;
+      pending_data.written = chunksize;
+      pending_data.type = type;
+      pending_data.base64 = base64;
+    }
+  else
+    {
+      if (base64)
+        err = add_base64_to_object (result, "data", buffer, buflen);
+      else
+        err = cjson_AddStringToObject (result, "data", buffer);
+    }
+
+ leave:
+  gpgme_free (buffer);
+  return err;
+}
+
+
+\f
 static const char hlp_encrypt[] =
   "op:     \"encrypt\"\n"
   "keys:   Array of strings with the fingerprints or user-ids\n"
@@ -549,6 +663,7 @@ static const char hlp_encrypt[] =
   "\n"
   "Optional parameters:\n"
   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
+  "chunksize:     Max number of bytes in the resulting \"data\".\n"
   "\n"
   "Optional boolean flags (default is false):\n"
   "base64:        Input data is base64 encoded.\n"
@@ -557,6 +672,7 @@ static const char hlp_encrypt[] =
   "no-encrypt-to: Do not use a default recipient.\n"
   "no-compress:   Do not compress the plaintext first.\n"
   "throw-keyids:  Request the --throw-keyids option.\n"
+  "want-address:  Require that the keys include a mail address.\n"
   "wrap:          Assume the input is an OpenPGP message.\n"
   "\n"
   "Response on success:\n"
@@ -564,24 +680,28 @@ static const char hlp_encrypt[] =
   "data:   Unless armor mode is used a Base64 encoded binary\n"
   "        ciphertext.  In armor mode a string with an armored\n"
   "        OpenPGP or a PEM message.\n"
-  "base64: Boolean indicating whether data is base64 encoded.";
+  "base64: Boolean indicating whether data is base64 encoded.\n"
+  "more:   Optional boolean indicating that \"getmore\" is required.";
 static gpg_error_t
 op_encrypt (cjson_t request, cjson_t result)
 {
   gpg_error_t err;
   gpgme_ctx_t ctx = NULL;
   gpgme_protocol_t protocol;
+  size_t chunksize;
   int opt_base64;
-  gpgme_key_t *keys = NULL;
+  char *keystring = NULL;
   cjson_t j_input;
   gpgme_data_t input = NULL;
   gpgme_data_t output = NULL;
-  int abool, i;
+  int abool;
   gpgme_encrypt_flags_t encrypt_flags = 0;
 
   if ((err = get_protocol (request, &protocol)))
     goto leave;
   ctx = get_context (protocol);
+  if ((err = get_chunksize (request, &chunksize)))
+    goto leave;
 
   if ((err = get_boolean_flag (request, "base64", 0, &opt_base64)))
     goto leave;
@@ -609,10 +729,14 @@ op_encrypt (cjson_t request, cjson_t result)
     goto leave;
   if (abool)
     encrypt_flags |= GPGME_ENCRYPT_WRAP;
+  if ((err = get_boolean_flag (request, "want-address", 0, &abool)))
+    goto leave;
+  if (abool)
+    encrypt_flags |= GPGME_ENCRYPT_WANT_ADDRESS;
 
 
   /* Get the keys.  */
-  err = get_keys (ctx, request, &keys);
+  err = get_keys (request, &keystring);
   if (err)
     {
       /* Provide a custom error response.  */
@@ -664,7 +788,8 @@ op_encrypt (cjson_t request, cjson_t result)
     }
 
   /* Encrypt.  */
-  err = gpgme_op_encrypt (ctx, keys, encrypt_flags, input, output);
+  err = gpgme_op_encrypt_ext (ctx, NULL, keystring, encrypt_flags,
+                              input, output);
   /* encrypt_result = gpgme_op_encrypt_result (ctx); */
   if (err)
     {
@@ -674,48 +799,106 @@ op_encrypt (cjson_t request, cjson_t result)
   gpgme_data_release (input);
   input = NULL;
 
-  xjson_AddStringToObject (result, "type", "ciphertext");
-  /* If armoring is used we do not need to base64 the output.  */
-  xjson_AddBoolToObject (result, "base64", !gpgme_get_armor (ctx));
-  if (gpgme_get_armor (ctx))
+  /* We need to base64 if armoring has not been requested.  */
+  err = make_data_object (result, output, chunksize,
+                          "ciphertext", !gpgme_get_armor (ctx));
+  output = NULL;
+
+ leave:
+  xfree (keystring);
+  release_context (ctx);
+  gpgme_data_release (input);
+  gpgme_data_release (output);
+  return err;
+}
+
+
+\f
+static const char hlp_getmore[] =
+  "op:     \"getmore\"\n"
+  "\n"
+  "Optional parameters:\n"
+  "chunksize:  Max number of bytes in the \"data\" object.\n"
+  "\n"
+  "Response on success:\n"
+  "type:       Type of the pending data\n"
+  "data:       The next chunk of data\n"
+  "base64:     Boolean indicating whether data is base64 encoded\n"
+  "more:       Optional boolean requesting another \"getmore\".";
+static gpg_error_t
+op_getmore (cjson_t request, cjson_t result)
+{
+  gpg_error_t err;
+  int c;
+  size_t n;
+  size_t chunksize;
+
+  if ((err = get_chunksize (request, &chunksize)))
+    goto leave;
+
+  /* Adjust the chunksize if we need to do base64 conversion.  */
+  if (pending_data.base64)
+    chunksize = (chunksize / 4) * 3;
+
+  /* Do we have anything pending?  */
+  if (!pending_data.buffer)
     {
-      char *buffer;
+      err = gpg_error (GPG_ERR_NO_DATA);
+      error_object (result, "Operation not possible: %s", gpg_strerror (err));
+      goto leave;
+    }
 
-      /* Make sure that we really have a string.  */
-      gpgme_data_write (output, "", 1);
-      buffer = gpgme_data_release_and_get_mem (output, NULL);
-      if (!buffer)
-        {
-          err = gpg_error_from_syserror ();
-          goto leave;
-        }
-      err = cjson_AddStringToObject (result, "data", buffer);
-      gpgme_free (buffer);
-      if (err)
-        goto leave;
+  xjson_AddStringToObject (result, "type", pending_data.type);
+  xjson_AddBoolToObject (result, "base64", pending_data.base64);
+
+  if (pending_data.written >= pending_data.length)
+    {
+      /* EOF reached.  This should not happen but we return an empty
+       * string once in case of client errors.  */
+      gpgme_free (pending_data.buffer);
+      pending_data.buffer = NULL;
+      xjson_AddBoolToObject (result, "more", 0);
+      err = cjson_AddStringToObject (result, "data", "");
     }
   else
     {
-      err = add_base64_to_object (result, "data", output);
-      output = NULL;
-      if (err)
-        goto leave;
+      n = pending_data.length - pending_data.written;
+      if (n > chunksize)
+        {
+          n = chunksize;
+          xjson_AddBoolToObject (result, "more", 1);
+        }
+      else
+        xjson_AddBoolToObject (result, "more", 0);
+
+      c = pending_data.buffer[pending_data.written + n];
+      pending_data.buffer[pending_data.written + n] = 0;
+      if (pending_data.base64)
+        err = add_base64_to_object (result, "data",
+                                    (pending_data.buffer
+                                     + pending_data.written), n);
+      else
+        err = cjson_AddStringToObject (result, "data",
+                                       (pending_data.buffer
+                                        + pending_data.written));
+      pending_data.buffer[pending_data.written + n] = c;
+      if (!err)
+        {
+          pending_data.written += n;
+          if (pending_data.written >= pending_data.length)
+            {
+              gpgme_free (pending_data.buffer);
+              pending_data.buffer = NULL;
+            }
+        }
     }
 
  leave:
-  if (keys)
-    {
-      for (i=0; keys[i]; i++)
-        gpgme_key_unref (keys[i]);
-      xfree (keys);
-    }
-  release_context (ctx);
-  gpgme_data_release (input);
   return err;
 }
 
 
-
+\f
 static const char hlp_help[] =
   "The tool expects a JSON object with the request and responds with\n"
   "another JSON object.  Even on error a JSON object is returned.  The\n"
@@ -725,6 +908,7 @@ static const char hlp_help[] =
   "returned.  To list all operations it is allowed to leave out \"op\" in\n"
   "help mode.  Supported values for \"op\" are:\n\n"
   "  encrypt     Encrypt data.\n"
+  "  getmore     Retrieve remaining data.\n"
   "  help        Help overview.";
 static gpg_error_t
 op_help (cjson_t request, cjson_t result)
@@ -747,9 +931,13 @@ op_help (cjson_t request, cjson_t result)
 }
 
 
+\f
+/*
+ * Dispatcher
+ */
 
 /* Process a request and return the response.  The response is a newly
- * allocated staring or NULL in case of an error.  */
+ * allocated string or NULL in case of an error.  */
 static char *
 process_request (const char *request)
 {
@@ -760,7 +948,7 @@ process_request (const char *request)
   } optbl[] = {
     { "encrypt", op_encrypt, hlp_encrypt },
 
-
+    { "getmore", op_getmore, hlp_getmore },
     { "help",    op_help,    hlp_help },
     { NULL }
   };
@@ -815,6 +1003,14 @@ process_request (const char *request)
         {
           gpg_error_t err;
 
+          /* If this is not the "getmore" command and we have any
+           * pending data release that data.  */
+          if (pending_data.buffer && optbl[idx].handler != op_getmore)
+            {
+              gpgme_free (pending_data.buffer);
+              pending_data.buffer = NULL;
+            }
+
           err = optbl[idx].handler (json, response);
           if (err)
             {
@@ -829,7 +1025,6 @@ process_request (const char *request)
 
               xjson_AddStringToObject (response, "op", op);
             }
-
         }
     }
   else  /* Operation not supported.  */
@@ -840,7 +1035,6 @@ process_request (const char *request)
 
  leave:
   cJSON_Delete (json);
-  json = NULL;
   if (opt_interactive)
     res = cJSON_Print (response);
   else
@@ -857,6 +1051,48 @@ process_request (const char *request)
  *  Driver code
  */
 
+static char *
+get_file (const char *fname)
+{
+  gpg_error_t err;
+  estream_t fp;
+  struct stat st;
+  char *buf;
+  size_t buflen;
+
+  fp = es_fopen (fname, "r");
+  if (!fp)
+    {
+      err = gpg_error_from_syserror ();
+      log_error ("can't open '%s': %s\n", fname, gpg_strerror (err));
+      return NULL;
+    }
+
+  if (fstat (es_fileno(fp), &st))
+    {
+      err = gpg_error_from_syserror ();
+      log_error ("can't stat '%s': %s\n", fname, gpg_strerror (err));
+      es_fclose (fp);
+      return NULL;
+    }
+
+  buflen = st.st_size;
+  buf = xmalloc (buflen+1);
+  if (es_fread (buf, buflen, 1, fp) != 1)
+    {
+      err = gpg_error_from_syserror ();
+      log_error ("error reading '%s': %s\n", fname, gpg_strerror (err));
+      es_fclose (fp);
+      xfree (buf);
+      return NULL;
+    }
+  buf[buflen] = 0;
+  es_fclose (fp);
+
+  return buf;
+}
+
+
 /* Return a malloced line or NULL on EOF.  Terminate on read
  * error.  */
 static char *
@@ -920,14 +1156,39 @@ process_meta_commands (const char *request)
     request++;
 
   if (!strncmp (request, "help", 4) && (spacep (request+4) || !request[4]))
-    result = process_request ("{ \"op\": \"help\","
-                              " \"interactive_help\": "
-                              "\"\\nMeta commands:\\n"
-                              "  ,help       This help\\n"
-                              "  ,quit       Terminate process\""
-                              "}");
+    {
+      if (request[4])
+        {
+          char *buf = xstrconcat ("{ \"help\":true, \"op\":\"", request+5,
+                                  "\" }", NULL);
+          result = process_request (buf);
+          xfree (buf);
+        }
+      else
+        result = process_request ("{ \"op\": \"help\","
+                                  " \"interactive_help\": "
+                                  "\"\\nMeta commands:\\n"
+                                  "  ,read FNAME Process data from FILE\\n"
+                                  "  ,help CMD   Print help for a command\\n"
+                                  "  ,quit       Terminate process\""
+                                  "}");
+    }
   else if (!strncmp (request, "quit", 4) && (spacep (request+4) || !request[4]))
     exit (0);
+  else if (!strncmp (request, "read", 4) && (spacep (request+4) || !request[4]))
+    {
+      if (!request[4])
+        log_info ("usage: ,read FILENAME\n");
+      else
+        {
+          char *buffer = get_file (request + 5);
+          if (buffer)
+            {
+              result = process_request (buffer);
+              xfree (buffer);
+            }
+        }
+    }
   else
     log_info ("invalid meta command\n");
 
@@ -1067,7 +1328,7 @@ interactive_repl (void)
 }
 
 
-/* Read and process  asingle request.  */
+/* Read and process single request.  */
 static void
 read_and_process_single_request (void)
 {
@@ -1121,6 +1382,7 @@ native_messaging_repl (void)
    * binary mode.  */
   es_set_binary (es_stdin);
   es_set_binary (es_stdout);
+  es_setbuf (es_stdin, NULL);  /* stdin needs to be unbuffered! */
 
   for (;;)
     {
@@ -1144,7 +1406,7 @@ native_messaging_repl (void)
         {
           log_error ("error reading request: request too long (%zu MiB)\n",
                      (size_t)nrequest / (1024*1024));
-          /* Fixme: Shall we read the request t the bit bucket and
+          /* Fixme: Shall we read the request to the bit bucket and
            * return an error reponse or just return an error reponse
            * and terminate?  Needs some testing.  */
           break;
@@ -1176,8 +1438,12 @@ native_messaging_repl (void)
         }
       else /* Process request  */
         {
+          if (opt_debug)
+            log_debug ("request='%s'\n", request);
           xfree (response);
           response = process_request (request);
+          if (opt_debug)
+            log_debug ("response='%s'\n", response);
         }
       nresponse = strlen (response);
 
@@ -1258,12 +1524,18 @@ main (int argc, char *argv[])
   enum { CMD_DEFAULT     = 0,
          CMD_INTERACTIVE = 'i',
          CMD_SINGLE      = 's',
-         CMD_LIBVERSION  = 501
+         CMD_LIBVERSION  = 501,
   } cmd = CMD_DEFAULT;
+  enum {
+    OPT_DEBUG = 600
+  };
+
   static gpgrt_opt_t opts[] = {
     ARGPARSE_c  (CMD_INTERACTIVE, "interactive", "Interactive REPL"),
     ARGPARSE_c  (CMD_SINGLE,      "single",      "Single request mode"),
     ARGPARSE_c  (CMD_LIBVERSION,  "lib-version", "Show library version"),
+    ARGPARSE_s_n(OPT_DEBUG,       "debug",       "Flyswatter"),
+
     ARGPARSE_end()
   };
   gpgrt_argparse_t pargs = { &argc, &argv};
@@ -1293,6 +1565,8 @@ main (int argc, char *argv[])
           cmd = pargs.r_opt;
           break;
 
+        case OPT_DEBUG: opt_debug = 1; break;
+
         default:
           pargs.err = ARGPARSE_PRINT_WARNING;
          break;
@@ -1300,6 +1574,29 @@ main (int argc, char *argv[])
     }
   gpgrt_argparse (NULL, &pargs, NULL);
 
+  if (!opt_debug)
+    {
+      const char *s = getenv ("GPGME_JSON_DEBUG");
+      if (s && atoi (s) > 0)
+        opt_debug = 1;
+    }
+
+  if (opt_debug)
+    {
+      const char *home = getenv ("HOME");
+      char *file = xstrconcat ("socket://",
+                               home? home:"/tmp",
+                               "/.gnupg/S.gpgme-json.log", NULL);
+      log_set_file (file);
+      xfree (file);
+    }
+
+  if (opt_debug)
+    { int i;
+      for (i=0; argv[i]; i++)
+        log_debug ("argv[%d]='%s'\n", i, argv[i]);
+    }
+
   switch (cmd)
     {
     case CMD_DEFAULT:
@@ -1322,6 +1619,10 @@ main (int argc, char *argv[])
       break;
     }
 
+  if (opt_debug)
+    log_debug ("ready");
+
 #endif /* This is a modern libgp-error.  */
   return 0;
 }
+#endif /* libgpg-error >= 1.28 */