json: Add guard in create_keylist_patterns
[gpgme.git] / src / gpgme-json.c
1 /* gpgme-json.c - JSON based interface to gpgme (server)
2  * Copyright (C) 2018 g10 Code GmbH
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * GPGME is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  * SPDX-License-Identifier: LGPL-2.1+
19  */
20
21 /* This is tool implements the Native Messaging protocol of web
22  * browsers and provides the server part of it.  A Javascript based
23  * client can be found in lang/javascript.
24  */
25
26 #include <config.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <stdarg.h>
31 #ifdef HAVE_LOCALE_H
32 #include <locale.h>
33 #endif
34 #include <stdint.h>
35 #include <sys/stat.h>
36
37 #define GPGRT_ENABLE_ES_MACROS 1
38 #define GPGRT_ENABLE_LOG_MACROS 1
39 #define GPGRT_ENABLE_ARGPARSE_MACROS 1
40 #include "gpgme.h"
41 #include "cJSON.h"
42
43
44 #if GPGRT_VERSION_NUMBER < 0x011c00 /* 1.28 */
45 int main (void){fputs ("Build with Libgpg-error >= 1.28!\n", stderr);return 1;}
46 #else /* libgpg-error >= 1.28 */
47
48 /* We don't allow a request with more than 64 MiB.  */
49 #define MAX_REQUEST_SIZE (64 * 1024 * 1024)
50
51 /* Minimal, default and maximum chunk size for returned data. The
52  * first chunk is returned directly.  If the "more" flag is also
53  * returned, a "getmore" command needs to be used to get the next
54  * chunk.  Right now this value covers just the value of the "data"
55  * element; so to cover for the other returned objects this values
56  * needs to be lower than the maximum allowed size of the browser. */
57 #define MIN_REPLY_CHUNK_SIZE  512
58 #define DEF_REPLY_CHUNK_SIZE (512 * 1024)
59 #define MAX_REPLY_CHUNK_SIZE (10 * 1024 * 1024)
60
61
62 static void xoutofcore (const char *type) GPGRT_ATTR_NORETURN;
63 static cjson_t error_object_v (cjson_t json, const char *message,
64                                va_list arg_ptr, gpg_error_t err)
65                                GPGRT_ATTR_PRINTF(2,0);
66 static cjson_t error_object (cjson_t json, const char *message,
67                             ...) GPGRT_ATTR_PRINTF(2,3);
68 static char *error_object_string (const char *message,
69                                   ...) GPGRT_ATTR_PRINTF(1,2);
70
71
72 /* True if interactive mode is active.  */
73 static int opt_interactive;
74 /* True is debug mode is active.  */
75 static int opt_debug;
76
77 /* Pending data to be returned by a getmore command.  */
78 static struct
79 {
80   char  *buffer;   /* Malloced data or NULL if not used.  */
81   size_t length;   /* Length of that data.  */
82   size_t written;  /* # of already written bytes from BUFFER.  */
83   const char *type;/* The "type" of the data.  */
84   int base64;      /* The "base64" flag of the data.  */
85 } pending_data;
86
87
88 /*
89  * Helper functions and macros
90  */
91
92 #define xtrymalloc(a)  gpgrt_malloc ((a))
93 #define xtrystrdup(a)  gpgrt_strdup ((a))
94 #define xmalloc(a) ({                           \
95       void *_r = gpgrt_malloc ((a));            \
96       if (!_r)                                  \
97         xoutofcore ("malloc");                  \
98       _r; })
99 #define xcalloc(a,b) ({                         \
100       void *_r = gpgrt_calloc ((a), (b));       \
101       if (!_r)                                  \
102         xoutofcore ("calloc");                  \
103       _r; })
104 #define xstrdup(a) ({                           \
105       char *_r = gpgrt_strdup ((a));            \
106       if (!_r)                                  \
107         xoutofcore ("strdup");                  \
108       _r; })
109 #define xstrconcat(a, ...) ({                           \
110       char *_r = gpgrt_strconcat ((a), __VA_ARGS__);    \
111       if (!_r)                                          \
112         xoutofcore ("strconcat");                       \
113       _r; })
114 #define xfree(a) gpgrt_free ((a))
115
116 #define spacep(p)   (*(p) == ' ' || *(p) == '\t')
117
118 #ifndef HAVE_STPCPY
119 static GPGRT_INLINE char *
120 _my_stpcpy (char *a, const char *b)
121 {
122   while (*b)
123     *a++ = *b++;
124   *a = 0;
125   return a;
126 }
127 #define stpcpy(a,b) _my_stpcpy ((a), (b))
128 #endif /*!HAVE_STPCPY*/
129
130
131 /* Free a NULL terminated array */
132 static void
133 xfree_array (char **array)
134 {
135   if (array)
136     {
137       int idx;
138       for (idx = 0; array[idx]; idx++)
139         xfree (array[idx]);
140       xfree (array);
141     }
142 }
143
144
145 static void
146 xoutofcore (const char *type)
147 {
148   gpg_error_t err = gpg_error_from_syserror ();
149   log_error ("%s failed: %s\n", type, gpg_strerror (err));
150   exit (2);
151 }
152
153
154 /* Call cJSON_CreateObject but terminate in case of an error.  */
155 static cjson_t
156 xjson_CreateObject (void)
157 {
158   cjson_t json = cJSON_CreateObject ();
159   if (!json)
160     xoutofcore ("cJSON_CreateObject");
161   return json;
162 }
163
164 /* Call cJSON_CreateArray but terminate in case of an error.  */
165 static cjson_t
166 xjson_CreateArray (void)
167 {
168   cjson_t json = cJSON_CreateArray ();
169   if (!json)
170     xoutofcore ("cJSON_CreateArray");
171   return json;
172 }
173
174
175 /* Wrapper around cJSON_AddStringToObject which returns an gpg-error
176  * code instead of the NULL or the new object.  */
177 static gpg_error_t
178 cjson_AddStringToObject (cjson_t object, const char *name, const char *string)
179 {
180   if (!cJSON_AddStringToObject (object, name, string))
181     return gpg_error_from_syserror ();
182   return 0;
183 }
184
185
186 /* Same as cjson_AddStringToObject but prints an error message and
187  * terminates the process.  */
188 static void
189 xjson_AddStringToObject (cjson_t object, const char *name, const char *string)
190 {
191   if (!cJSON_AddStringToObject (object, name, string))
192     xoutofcore ("cJSON_AddStringToObject");
193 }
194
195
196 /* Same as xjson_AddStringToObject but ignores NULL strings */
197 static void
198 xjson_AddStringToObject0 (cjson_t object, const char *name, const char *string)
199 {
200   if (!string)
201     return;
202   xjson_AddStringToObject (object, name, string);
203 }
204
205 /* Wrapper around cJSON_AddBoolToObject which terminates the process
206  * in case of an error.  */
207 static void
208 xjson_AddBoolToObject (cjson_t object, const char *name, int abool)
209 {
210   if (!cJSON_AddBoolToObject (object, name, abool))
211     xoutofcore ("cJSON_AddStringToObject");
212   return ;
213 }
214
215 /* Wrapper around cJSON_AddNumberToObject which terminates the process
216  * in case of an error.  */
217 static void
218 xjson_AddNumberToObject (cjson_t object, const char *name, double dbl)
219 {
220   if (!cJSON_AddNumberToObject (object, name, dbl))
221     xoutofcore ("cJSON_AddNumberToObject");
222   return ;
223 }
224
225 /* Wrapper around cJSON_AddItemToObject which terminates the process
226  * in case of an error.  */
227 static void
228 xjson_AddItemToObject (cjson_t object, const char *name, cjson_t item)
229 {
230   if (!cJSON_AddItemToObject (object, name, item))
231     xoutofcore ("cJSON_AddItemToObject");
232   return ;
233 }
234
235 /* This is similar to cJSON_AddStringToObject but takes (DATA,
236  * DATALEN) and adds it under NAME as a base 64 encoded string to
237  * OBJECT.  */
238 static gpg_error_t
239 add_base64_to_object (cjson_t object, const char *name,
240                       const void *data, size_t datalen)
241 {
242 #if GPGRT_VERSION_NUMBER < 0x011d00 /* 1.29 */
243   return gpg_error (GPG_ERR_NOT_SUPPORTED);
244 #else
245   gpg_err_code_t err;
246   estream_t fp = NULL;
247   gpgrt_b64state_t state = NULL;
248   cjson_t j_str = NULL;
249   void *buffer = NULL;
250
251   fp = es_fopenmem (0, "rwb");
252   if (!fp)
253     {
254       err = gpg_err_code_from_syserror ();
255       goto leave;
256     }
257   state = gpgrt_b64enc_start (fp, "");
258   if (!state)
259     {
260       err = gpg_err_code_from_syserror ();
261       goto leave;
262     }
263
264   err = gpgrt_b64enc_write (state, data, datalen);
265   if (err)
266     goto leave;
267
268   err = gpgrt_b64enc_finish (state);
269   state = NULL;
270   if (err)
271     return err;
272
273   es_fputc (0, fp);
274   if (es_fclose_snatch (fp, &buffer, NULL))
275     {
276       fp = NULL;
277       err = gpg_error_from_syserror ();
278       goto leave;
279     }
280   fp = NULL;
281
282   j_str = cJSON_CreateStringConvey (buffer);
283   if (!j_str)
284     {
285       err = gpg_error_from_syserror ();
286       goto leave;
287     }
288   buffer = NULL;
289
290   if (!cJSON_AddItemToObject (object, name, j_str))
291     {
292       err = gpg_error_from_syserror ();
293       cJSON_Delete (j_str);
294       j_str = NULL;
295       goto leave;
296     }
297   j_str = NULL;
298
299  leave:
300   xfree (buffer);
301   cJSON_Delete (j_str);
302   gpgrt_b64enc_finish (state);
303   es_fclose (fp);
304   return err;
305 #endif
306 }
307
308
309 /* Create a JSON error object.  If JSON is not NULL the error message
310  * is appended to that object.  An existing "type" item will be replaced. */
311 static cjson_t
312 error_object_v (cjson_t json, const char *message, va_list arg_ptr,
313                 gpg_error_t err)
314 {
315   cjson_t response, j_tmp;
316   char *msg;
317
318   msg = gpgrt_vbsprintf (message, arg_ptr);
319   if (!msg)
320     xoutofcore ("error_object");
321
322   response = json? json : xjson_CreateObject ();
323
324   if (!(j_tmp = cJSON_GetObjectItem (response, "type")))
325     xjson_AddStringToObject (response, "type", "error");
326   else /* Replace existing "type".  */
327     {
328       j_tmp = cJSON_CreateString ("error");
329       if (!j_tmp)
330         xoutofcore ("cJSON_CreateString");
331       cJSON_ReplaceItemInObject (response, "type", j_tmp);
332      }
333   xjson_AddStringToObject (response, "msg", msg);
334   xfree (msg);
335
336   xjson_AddNumberToObject (response, "code", err);
337
338   return response;
339 }
340
341
342 /* Call cJSON_Print but terminate in case of an error.  */
343 static char *
344 xjson_Print (cjson_t object)
345 {
346   char *buf;
347   buf = cJSON_Print (object);
348   if (!buf)
349     xoutofcore ("cJSON_Print");
350   return buf;
351 }
352
353
354 static cjson_t
355 error_object (cjson_t json, const char *message, ...)
356 {
357   cjson_t response;
358   va_list arg_ptr;
359
360   va_start (arg_ptr, message);
361   response = error_object_v (json, message, arg_ptr, 0);
362   va_end (arg_ptr);
363   return response;
364 }
365
366
367 static cjson_t
368 gpg_error_object (cjson_t json, gpg_error_t err, const char *message, ...)
369 {
370   cjson_t response;
371   va_list arg_ptr;
372
373   va_start (arg_ptr, message);
374   response = error_object_v (json, message, arg_ptr, err);
375   va_end (arg_ptr);
376   return response;
377 }
378
379
380 static char *
381 error_object_string (const char *message, ...)
382 {
383   cjson_t response;
384   va_list arg_ptr;
385   char *msg;
386
387   va_start (arg_ptr, message);
388   response = error_object_v (NULL, message, arg_ptr, 0);
389   va_end (arg_ptr);
390
391   msg = xjson_Print (response);
392   cJSON_Delete (response);
393   return msg;
394 }
395
396
397 /* Get the boolean property NAME from the JSON object and store true
398  * or valse at R_VALUE.  If the name is unknown the value of DEF_VALUE
399  * is returned.  If the type of the value is not boolean,
400  * GPG_ERR_INV_VALUE is returned and R_VALUE set to DEF_VALUE.  */
401 static gpg_error_t
402 get_boolean_flag (cjson_t json, const char *name, int def_value, int *r_value)
403 {
404   cjson_t j_item;
405
406   j_item = cJSON_GetObjectItem (json, name);
407   if (!j_item)
408     *r_value = def_value;
409   else if (cjson_is_true (j_item))
410     *r_value = 1;
411   else if (cjson_is_false (j_item))
412     *r_value = 0;
413   else
414     {
415       *r_value = def_value;
416       return gpg_error (GPG_ERR_INV_VALUE);
417     }
418
419   return 0;
420 }
421
422
423 /* Get the boolean property PROTOCOL from the JSON object and store
424  * its value at R_PROTOCOL.  The default is OpenPGP.  */
425 static gpg_error_t
426 get_protocol (cjson_t json, gpgme_protocol_t *r_protocol)
427 {
428   cjson_t j_item;
429
430   *r_protocol = GPGME_PROTOCOL_OpenPGP;
431   j_item = cJSON_GetObjectItem (json, "protocol");
432   if (!j_item)
433     ;
434   else if (!cjson_is_string (j_item))
435     return gpg_error (GPG_ERR_INV_VALUE);
436   else if (!strcmp(j_item->valuestring, "openpgp"))
437     ;
438   else if (!strcmp(j_item->valuestring, "cms"))
439     *r_protocol = GPGME_PROTOCOL_CMS;
440   else
441     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
442
443   return 0;
444 }
445
446
447 /* Get the chunksize from JSON and store it at R_CHUNKSIZE.  */
448 static gpg_error_t
449 get_chunksize (cjson_t json, size_t *r_chunksize)
450 {
451   cjson_t j_item;
452
453   *r_chunksize = DEF_REPLY_CHUNK_SIZE;
454   j_item = cJSON_GetObjectItem (json, "chunksize");
455   if (!j_item)
456     ;
457   else if (!cjson_is_number (j_item))
458     return gpg_error (GPG_ERR_INV_VALUE);
459   else if ((size_t)j_item->valueint < MIN_REPLY_CHUNK_SIZE)
460     *r_chunksize = MIN_REPLY_CHUNK_SIZE;
461   else if ((size_t)j_item->valueint > MAX_REPLY_CHUNK_SIZE)
462     *r_chunksize = MAX_REPLY_CHUNK_SIZE;
463   else
464     *r_chunksize = (size_t)j_item->valueint;
465
466   return 0;
467 }
468
469
470 /* Extract the keys from the "keys" array in the JSON object.  On
471  * success a string with the keys identifiers is stored at R_KEYS.
472  * The keys in that string are LF delimited.  On failure an error code
473  * is returned.  */
474 static gpg_error_t
475 get_keys (cjson_t json, char **r_keystring)
476 {
477   cjson_t j_keys, j_item;
478   int i, nkeys;
479   char *p;
480   size_t length;
481
482   *r_keystring = NULL;
483
484   j_keys = cJSON_GetObjectItem (json, "keys");
485   if (!j_keys)
486     return gpg_error (GPG_ERR_NO_KEY);
487   if (!cjson_is_array (j_keys) && !cjson_is_string (j_keys))
488     return gpg_error (GPG_ERR_INV_VALUE);
489
490   /* Fixme: We should better use a membuf like thing.  */
491   length = 1; /* For the EOS.  */
492   if (cjson_is_string (j_keys))
493     {
494       nkeys = 1;
495       length += strlen (j_keys->valuestring);
496       if (strchr (j_keys->valuestring, '\n'))
497         return gpg_error (GPG_ERR_INV_USER_ID);
498     }
499   else
500     {
501       nkeys = cJSON_GetArraySize (j_keys);
502       if (!nkeys)
503         return gpg_error (GPG_ERR_NO_KEY);
504       for (i=0; i < nkeys; i++)
505         {
506           j_item = cJSON_GetArrayItem (j_keys, i);
507           if (!j_item || !cjson_is_string (j_item))
508             return gpg_error (GPG_ERR_INV_VALUE);
509           if (i)
510             length++; /* Space for delimiter. */
511           length += strlen (j_item->valuestring);
512           if (strchr (j_item->valuestring, '\n'))
513             return gpg_error (GPG_ERR_INV_USER_ID);
514         }
515     }
516
517   p = *r_keystring = xtrymalloc (length);
518   if (!p)
519     return gpg_error_from_syserror ();
520
521   if (cjson_is_string (j_keys))
522     {
523       strcpy (p, j_keys->valuestring);
524     }
525   else
526     {
527       for (i=0; i < nkeys; i++)
528         {
529           j_item = cJSON_GetArrayItem (j_keys, i);
530           if (i)
531             *p++ = '\n'; /* Add delimiter.  */
532           p = stpcpy (p, j_item->valuestring);
533         }
534     }
535   return 0;
536 }
537
538
539
540 \f
541 /*
542  *  GPGME support functions.
543  */
544
545 /* Helper for get_context.  */
546 static gpgme_ctx_t
547 _create_new_context (gpgme_protocol_t proto)
548 {
549   gpg_error_t err;
550   gpgme_ctx_t ctx;
551
552   err = gpgme_new (&ctx);
553   if (err)
554     log_fatal ("error creating GPGME context: %s\n", gpg_strerror (err));
555   gpgme_set_protocol (ctx, proto);
556   gpgme_set_ctx_flag (ctx, "request-origin", "browser");
557   return ctx;
558 }
559
560
561 /* Return a context object for protocol PROTO.  This is currently a
562  * statically allocated context initialized for PROTO.  Terminates
563  * process on failure.  */
564 static gpgme_ctx_t
565 get_context (gpgme_protocol_t proto)
566 {
567   static gpgme_ctx_t ctx_openpgp, ctx_cms;
568
569   if (proto == GPGME_PROTOCOL_OpenPGP)
570     {
571       if (!ctx_openpgp)
572         ctx_openpgp = _create_new_context (proto);
573       return ctx_openpgp;
574     }
575   else if (proto == GPGME_PROTOCOL_CMS)
576     {
577       if (!ctx_cms)
578         ctx_cms = _create_new_context (proto);
579       return ctx_cms;
580     }
581   else
582     log_bug ("invalid protocol %d requested\n", proto);
583 }
584
585
586
587 /* Free context object retrieved by get_context.  */
588 static void
589 release_context (gpgme_ctx_t ctx)
590 {
591   /* Nothing to do right now.  */
592   (void)ctx;
593 }
594
595
596
597 /* Given a Base-64 encoded string object in JSON return a gpgme data
598  * object at R_DATA.  */
599 static gpg_error_t
600 data_from_base64_string (gpgme_data_t *r_data, cjson_t json)
601 {
602 #if GPGRT_VERSION_NUMBER < 0x011d00 /* 1.29 */
603   *r_data = NULL;
604   return gpg_error (GPG_ERR_NOT_SUPPORTED);
605 #else
606   gpg_error_t err;
607   size_t len;
608   char *buf = NULL;
609   gpgrt_b64state_t state = NULL;
610   gpgme_data_t data = NULL;
611
612   *r_data = NULL;
613
614   /* A quick check on the JSON.  */
615   if (!cjson_is_string (json))
616     {
617       err = gpg_error (GPG_ERR_INV_VALUE);
618       goto leave;
619     }
620
621   state = gpgrt_b64dec_start (NULL);
622   if (!state)
623     {
624       err = gpg_err_code_from_syserror ();
625       goto leave;
626     }
627
628   /* Fixme: Data duplication - we should see how to snatch the memory
629    * from the json object.  */
630   len = strlen (json->valuestring);
631   buf = xtrystrdup (json->valuestring);
632   if (!buf)
633     {
634       err = gpg_error_from_syserror ();
635       goto leave;
636     }
637
638   err = gpgrt_b64dec_proc (state, buf, len, &len);
639   if (err)
640     goto leave;
641
642   err = gpgrt_b64dec_finish (state);
643   state = NULL;
644   if (err)
645     goto leave;
646
647   err = gpgme_data_new_from_mem (&data, buf, len, 1);
648   if (err)
649     goto leave;
650   *r_data = data;
651   data = NULL;
652
653  leave:
654   xfree (data);
655   xfree (buf);
656   gpgrt_b64dec_finish (state);
657   return err;
658 #endif
659 }
660
661
662 /* Create a keylist pattern array from a json keys object
663  * in the request. Returns either a malloced NULL terminated
664  * string array which can be used as patterns for
665  * op_keylist_ext or NULL. */
666 static char **
667 create_keylist_patterns (cjson_t request)
668 {
669   char *keystring;
670   char *p;
671   char *tmp;
672   char **ret;
673   int cnt = 1;
674   int i = 0;
675
676   if (get_keys (request, &keystring))
677     return NULL;
678
679   for (p = keystring; p; p++)
680     if (*p == '\n')
681       cnt++;
682
683   ret = (char **) xmalloc (cnt * sizeof (char *));
684
685   for (p = keystring, tmp = keystring; *p; p++)
686     {
687       if (*p != '\n')
688         continue;
689       *p = '\0';
690       ret[i++] = xstrdup (tmp);
691       tmp = p + 1;
692     }
693   /* The last key is not newline delimted. */
694   ret[i++] = *tmp ? xstrdup (tmp) : NULL;
695   ret[i] = NULL;
696
697   xfree (keystring);
698   return ret;
699 }
700
701
702 /* Create sigsum json array */
703 static cjson_t
704 sigsum_to_json (gpgme_sigsum_t summary)
705 {
706   cjson_t result = xjson_CreateArray ();
707
708   if ( (summary & GPGME_SIGSUM_VALID      ))
709     cJSON_AddItemToArray (result,
710         cJSON_CreateString ("valid"));
711   if ( (summary & GPGME_SIGSUM_GREEN      ))
712     cJSON_AddItemToArray (result,
713         cJSON_CreateString ("green"));
714   if ( (summary & GPGME_SIGSUM_RED        ))
715     cJSON_AddItemToArray (result,
716         cJSON_CreateString ("red"));
717   if ( (summary & GPGME_SIGSUM_KEY_REVOKED))
718     cJSON_AddItemToArray (result,
719         cJSON_CreateString ("revoked"));
720   if ( (summary & GPGME_SIGSUM_KEY_EXPIRED))
721     cJSON_AddItemToArray (result,
722         cJSON_CreateString ("key-expired"));
723   if ( (summary & GPGME_SIGSUM_SIG_EXPIRED))
724     cJSON_AddItemToArray (result,
725         cJSON_CreateString ("sig-expired"));
726   if ( (summary & GPGME_SIGSUM_KEY_MISSING))
727     cJSON_AddItemToArray (result,
728         cJSON_CreateString ("key-missing"));
729   if ( (summary & GPGME_SIGSUM_CRL_MISSING))
730     cJSON_AddItemToArray (result,
731         cJSON_CreateString ("crl-missing"));
732   if ( (summary & GPGME_SIGSUM_CRL_TOO_OLD))
733     cJSON_AddItemToArray (result,
734         cJSON_CreateString ("crl-too-old"));
735   if ( (summary & GPGME_SIGSUM_BAD_POLICY ))
736     cJSON_AddItemToArray (result,
737         cJSON_CreateString ("bad-policy"));
738   if ( (summary & GPGME_SIGSUM_SYS_ERROR  ))
739     cJSON_AddItemToArray (result,
740         cJSON_CreateString ("sys-error"));
741
742   return result;
743 }
744
745
746 /* Helper for summary formatting */
747 static const char *
748 validity_to_string (gpgme_validity_t val)
749 {
750   switch (val)
751     {
752     case GPGME_VALIDITY_UNDEFINED:return "undefined";
753     case GPGME_VALIDITY_NEVER:    return "never";
754     case GPGME_VALIDITY_MARGINAL: return "marginal";
755     case GPGME_VALIDITY_FULL:     return "full";
756     case GPGME_VALIDITY_ULTIMATE: return "ultimate";
757     case GPGME_VALIDITY_UNKNOWN:
758     default:                      return "unknown";
759     }
760 }
761
762 static const char *
763 protocol_to_string (gpgme_protocol_t proto)
764 {
765   switch (proto)
766     {
767     case GPGME_PROTOCOL_OpenPGP: return "OpenPGP";
768     case GPGME_PROTOCOL_CMS:     return "CMS";
769     case GPGME_PROTOCOL_GPGCONF: return "gpgconf";
770     case GPGME_PROTOCOL_ASSUAN:  return "assuan";
771     case GPGME_PROTOCOL_G13:     return "g13";
772     case GPGME_PROTOCOL_UISERVER:return "uiserver";
773     case GPGME_PROTOCOL_SPAWN:   return "spawn";
774     default:
775                                  return "unknown";
776     }
777 }
778
779 /* Create a sig_notation json object */
780 static cjson_t
781 sig_notation_to_json (gpgme_sig_notation_t not)
782 {
783   cjson_t result = xjson_CreateObject ();
784   xjson_AddBoolToObject (result, "human_readable", not->human_readable);
785   xjson_AddBoolToObject (result, "critical", not->critical);
786
787   xjson_AddStringToObject0 (result, "name", not->name);
788   xjson_AddStringToObject0 (result, "value", not->value);
789
790   xjson_AddNumberToObject (result, "flags", not->flags);
791
792   return result;
793 }
794
795 /* Create a key_sig json object */
796 static cjson_t
797 key_sig_to_json (gpgme_key_sig_t sig)
798 {
799   cjson_t result = xjson_CreateObject ();
800
801   xjson_AddBoolToObject (result, "revoked", sig->revoked);
802   xjson_AddBoolToObject (result, "expired", sig->expired);
803   xjson_AddBoolToObject (result, "invalid", sig->invalid);
804   xjson_AddBoolToObject (result, "exportable", sig->exportable);
805
806   xjson_AddStringToObject0 (result, "pubkey_algo_name",
807                             gpgme_pubkey_algo_name (sig->pubkey_algo));
808   xjson_AddStringToObject0 (result, "keyid", sig->keyid);
809   xjson_AddStringToObject0 (result, "status", gpgme_strerror (sig->status));
810   xjson_AddStringToObject0 (result, "name", sig->name);
811   xjson_AddStringToObject0 (result, "email", sig->email);
812   xjson_AddStringToObject0 (result, "comment", sig->comment);
813
814   xjson_AddNumberToObject (result, "pubkey_algo", sig->pubkey_algo);
815   xjson_AddNumberToObject (result, "timestamp", sig->timestamp);
816   xjson_AddNumberToObject (result, "expires", sig->expires);
817   xjson_AddNumberToObject (result, "status_code", sig->status);
818   xjson_AddNumberToObject (result, "sig_class", sig->sig_class);
819
820   if (sig->notations)
821     {
822       gpgme_sig_notation_t not;
823       cjson_t array = xjson_CreateArray ();
824       for (not = sig->notations; not; not = not->next)
825         cJSON_AddItemToArray (array, sig_notation_to_json (not));
826       xjson_AddItemToObject (result, "notations", array);
827     }
828
829   return result;
830 }
831
832 /* Create a tofu info object */
833 static cjson_t
834 tofu_to_json (gpgme_tofu_info_t tofu)
835 {
836   cjson_t result = xjson_CreateObject ();
837
838   xjson_AddStringToObject0 (result, "description", tofu->description);
839
840   xjson_AddNumberToObject (result, "validity", tofu->validity);
841   xjson_AddNumberToObject (result, "policy", tofu->policy);
842   xjson_AddNumberToObject (result, "signcount", tofu->signcount);
843   xjson_AddNumberToObject (result, "encrcount", tofu->encrcount);
844   xjson_AddNumberToObject (result, "signfirst", tofu->signfirst);
845   xjson_AddNumberToObject (result, "signlast", tofu->signlast);
846   xjson_AddNumberToObject (result, "encrfirst", tofu->encrfirst);
847   xjson_AddNumberToObject (result, "encrlast", tofu->encrlast);
848
849   return result;
850 }
851
852 /* Create a userid json object */
853 static cjson_t
854 uid_to_json (gpgme_user_id_t uid)
855 {
856   cjson_t result = xjson_CreateObject ();
857
858   xjson_AddBoolToObject (result, "revoked", uid->revoked);
859   xjson_AddBoolToObject (result, "invalid", uid->invalid);
860
861   xjson_AddStringToObject0 (result, "validity",
862                             validity_to_string (uid->validity));
863   xjson_AddStringToObject0 (result, "uid", uid->uid);
864   xjson_AddStringToObject0 (result, "name", uid->name);
865   xjson_AddStringToObject0 (result, "email", uid->email);
866   xjson_AddStringToObject0 (result, "comment", uid->comment);
867   xjson_AddStringToObject0 (result, "address", uid->address);
868
869   xjson_AddNumberToObject (result, "origin", uid->origin);
870   xjson_AddNumberToObject (result, "last_update", uid->last_update);
871
872   /* Key sigs */
873   if (uid->signatures)
874     {
875       cjson_t sig_array = xjson_CreateArray ();
876       gpgme_key_sig_t sig;
877
878       for (sig = uid->signatures; sig; sig = sig->next)
879         cJSON_AddItemToArray (sig_array, key_sig_to_json (sig));
880
881       xjson_AddItemToObject (result, "signatures", sig_array);
882     }
883
884   /* TOFU info */
885   if (uid->tofu)
886     {
887       gpgme_tofu_info_t tofu;
888       cjson_t array = xjson_CreateArray ();
889       for (tofu = uid->tofu; tofu; tofu = tofu->next)
890         cJSON_AddItemToArray (array, tofu_to_json (tofu));
891       xjson_AddItemToObject (result, "tofu", array);
892     }
893
894   return result;
895 }
896
897 /* Create a subkey json object */
898 static cjson_t
899 subkey_to_json (gpgme_subkey_t sub)
900 {
901   cjson_t result = xjson_CreateObject ();
902
903   xjson_AddBoolToObject (result, "revoked", sub->revoked);
904   xjson_AddBoolToObject (result, "expired", sub->expired);
905   xjson_AddBoolToObject (result, "disabled", sub->disabled);
906   xjson_AddBoolToObject (result, "invalid", sub->invalid);
907   xjson_AddBoolToObject (result, "can_encrypt", sub->can_encrypt);
908   xjson_AddBoolToObject (result, "can_sign", sub->can_sign);
909   xjson_AddBoolToObject (result, "can_certify", sub->can_certify);
910   xjson_AddBoolToObject (result, "can_authenticate", sub->can_authenticate);
911   xjson_AddBoolToObject (result, "secret", sub->secret);
912   xjson_AddBoolToObject (result, "is_qualified", sub->is_qualified);
913   xjson_AddBoolToObject (result, "is_cardkey", sub->is_cardkey);
914   xjson_AddBoolToObject (result, "is_de_vs", sub->is_de_vs);
915
916   xjson_AddStringToObject0 (result, "pubkey_algo_name",
917                             gpgme_pubkey_algo_name (sub->pubkey_algo));
918   xjson_AddStringToObject0 (result, "pubkey_algo_string",
919                             gpgme_pubkey_algo_string (sub));
920   xjson_AddStringToObject0 (result, "keyid", sub->keyid);
921   xjson_AddStringToObject0 (result, "card_number", sub->card_number);
922   xjson_AddStringToObject0 (result, "curve", sub->curve);
923   xjson_AddStringToObject0 (result, "keygrip", sub->keygrip);
924
925   xjson_AddNumberToObject (result, "pubkey_algo", sub->pubkey_algo);
926   xjson_AddNumberToObject (result, "length", sub->length);
927   xjson_AddNumberToObject (result, "timestamp", sub->timestamp);
928   xjson_AddNumberToObject (result, "expires", sub->expires);
929
930   return result;
931 }
932
933 /* Create a key json object */
934 static cjson_t
935 key_to_json (gpgme_key_t key)
936 {
937   cjson_t result = xjson_CreateObject ();
938
939   xjson_AddBoolToObject (result, "revoked", key->revoked);
940   xjson_AddBoolToObject (result, "expired", key->expired);
941   xjson_AddBoolToObject (result, "disabled", key->disabled);
942   xjson_AddBoolToObject (result, "invalid", key->invalid);
943   xjson_AddBoolToObject (result, "can_encrypt", key->can_encrypt);
944   xjson_AddBoolToObject (result, "can_sign", key->can_sign);
945   xjson_AddBoolToObject (result, "can_certify", key->can_certify);
946   xjson_AddBoolToObject (result, "can_authenticate", key->can_authenticate);
947   xjson_AddBoolToObject (result, "secret", key->secret);
948   xjson_AddBoolToObject (result, "is_qualified", key->is_qualified);
949
950   xjson_AddStringToObject0 (result, "protocol",
951                             protocol_to_string (key->protocol));
952   xjson_AddStringToObject0 (result, "issuer_serial", key->issuer_serial);
953   xjson_AddStringToObject0 (result, "issuer_name", key->issuer_name);
954   xjson_AddStringToObject0 (result, "fingerprint", key->fpr);
955   xjson_AddStringToObject0 (result, "chain_id", key->chain_id);
956   xjson_AddStringToObject0 (result, "owner_trust",
957                             validity_to_string (key->owner_trust));
958
959   xjson_AddNumberToObject (result, "origin", key->origin);
960   xjson_AddNumberToObject (result, "last_update", key->last_update);
961
962   /* Add subkeys */
963   if (key->subkeys)
964     {
965       cjson_t subkey_array = xjson_CreateArray ();
966       gpgme_subkey_t sub;
967       for (sub = key->subkeys; sub; sub = sub->next)
968         cJSON_AddItemToArray (subkey_array, subkey_to_json (sub));
969
970       xjson_AddItemToObject (result, "subkeys", subkey_array);
971     }
972
973   /* User Ids */
974   if (key->uids)
975     {
976       cjson_t uid_array = xjson_CreateArray ();
977       gpgme_user_id_t uid;
978       for (uid = key->uids; uid; uid = uid->next)
979         cJSON_AddItemToArray (uid_array, uid_to_json (uid));
980
981       xjson_AddItemToObject (result, "userids", uid_array);
982     }
983
984   return result;
985 }
986
987 /* Create a signature json object */
988 static cjson_t
989 signature_to_json (gpgme_signature_t sig)
990 {
991   cjson_t result = xjson_CreateObject ();
992
993   xjson_AddStringToObject0 (result, "status",
994                             gpgme_strerror (sig->status));
995
996   xjson_AddStringToObject0 (result, "validity",
997                             validity_to_string (sig->validity));
998   xjson_AddStringToObject0 (result, "fingerprint", sig->fpr);
999
1000   xjson_AddItemToObject (result, "summary", sigsum_to_json (sig->summary));
1001
1002   xjson_AddNumberToObject (result, "created", sig->timestamp);
1003   xjson_AddNumberToObject (result, "expired", sig->exp_timestamp);
1004   xjson_AddNumberToObject (result, "code", sig->status);
1005
1006   return result;
1007 }
1008
1009 /* Create a JSON object from a gpgme_verify result */
1010 static cjson_t
1011 verify_result_to_json (gpgme_verify_result_t verify_result)
1012 {
1013   cjson_t response = xjson_CreateObject ();
1014
1015   if (verify_result->signatures)
1016     {
1017       cjson_t array = xjson_CreateArray ();
1018       gpgme_signature_t sig;
1019
1020       for (sig = verify_result->signatures; sig; sig = sig->next)
1021         cJSON_AddItemToArray (array, signature_to_json (sig));
1022       xjson_AddItemToObject (response, "signatures", array);
1023     }
1024
1025   return response;
1026 }
1027
1028 /* Create a JSON object from an engine_info */
1029 static cjson_t
1030 engine_info_to_json (gpgme_engine_info_t info)
1031 {
1032   cjson_t result = xjson_CreateObject ();
1033
1034   xjson_AddStringToObject0 (result, "protocol",
1035                             protocol_to_string (info->protocol));
1036   xjson_AddStringToObject0 (result, "fname", info->file_name);
1037   xjson_AddStringToObject0 (result, "version", info->version);
1038   xjson_AddStringToObject0 (result, "req_version", info->req_version);
1039   xjson_AddStringToObject0 (result, "homedir", info->home_dir ?
1040                                                 info->home_dir :
1041                                                 "default");
1042   return result;
1043 }
1044 /* Create a JSON object from an import_status */
1045 static cjson_t
1046 import_status_to_json (gpgme_import_status_t sts)
1047 {
1048   cjson_t result = xjson_CreateObject ();
1049
1050   xjson_AddStringToObject0 (result, "fingerprint", sts->fpr);
1051   xjson_AddStringToObject0 (result, "error_string",
1052                             gpgme_strerror (sts->result));
1053
1054   xjson_AddNumberToObject (result, "status", sts->status);
1055
1056   return result;
1057 }
1058
1059 /* Create a JSON object from an import result */
1060 static cjson_t
1061 import_result_to_json (gpgme_import_result_t imp)
1062 {
1063   cjson_t result = xjson_CreateObject ();
1064
1065   xjson_AddNumberToObject (result, "considered", imp->considered);
1066   xjson_AddNumberToObject (result, "no_user_id", imp->no_user_id);
1067   xjson_AddNumberToObject (result, "imported", imp->imported);
1068   xjson_AddNumberToObject (result, "imported_rsa", imp->imported_rsa);
1069   xjson_AddNumberToObject (result, "unchanged", imp->unchanged);
1070   xjson_AddNumberToObject (result, "new_user_ids", imp->new_user_ids);
1071   xjson_AddNumberToObject (result, "new_sub_keys", imp->new_sub_keys);
1072   xjson_AddNumberToObject (result, "new_signatures", imp->new_signatures);
1073   xjson_AddNumberToObject (result, "new_revocations", imp->new_revocations);
1074   xjson_AddNumberToObject (result, "secret_read", imp->secret_read);
1075   xjson_AddNumberToObject (result, "secret_imported", imp->secret_imported);
1076   xjson_AddNumberToObject (result, "secret_unchanged", imp->secret_unchanged);
1077   xjson_AddNumberToObject (result, "skipped_new_keys", imp->skipped_new_keys);
1078   xjson_AddNumberToObject (result, "not_imported", imp->not_imported);
1079   xjson_AddNumberToObject (result, "skipped_v3_keys", imp->skipped_v3_keys);
1080
1081
1082   if (imp->imports)
1083     {
1084       cjson_t array = xjson_CreateArray ();
1085       gpgme_import_status_t status;
1086
1087       for (status = imp->imports; status; status = status->next)
1088         cJSON_AddItemToArray (array, import_status_to_json (status));
1089       xjson_AddItemToObject (result, "imports", array);
1090     }
1091
1092   return result;
1093 }
1094
1095 /* Create a gpgme_data from json string data named "name"
1096  * in the request. Takes the base64 option into account.
1097  *
1098  * Adds an error to the "result" on error. */
1099 static gpg_error_t
1100 get_string_data (cjson_t request, cjson_t result, const char *name,
1101                  gpgme_data_t *r_data)
1102 {
1103   gpgme_error_t err;
1104   int opt_base64;
1105   cjson_t j_data;
1106
1107   if ((err = get_boolean_flag (request, "base64", 0, &opt_base64)))
1108     return err;
1109
1110   /* Get the data.  Note that INPUT is a shallow data object with the
1111    * storage hold in REQUEST.  */
1112   j_data = cJSON_GetObjectItem (request, name);
1113   if (!j_data)
1114     {
1115       return gpg_error (GPG_ERR_NO_DATA);
1116     }
1117   if (!cjson_is_string (j_data))
1118     {
1119       return gpg_error (GPG_ERR_INV_VALUE);
1120     }
1121   if (opt_base64)
1122     {
1123       err = data_from_base64_string (r_data, j_data);
1124       if (err)
1125         {
1126           gpg_error_object (result, err,
1127                             "Error decoding Base-64 encoded '%s': %s",
1128                             name, gpg_strerror (err));
1129           return err;
1130         }
1131     }
1132   else
1133     {
1134       err = gpgme_data_new_from_mem (r_data, j_data->valuestring,
1135                                      strlen (j_data->valuestring), 0);
1136       if (err)
1137         {
1138           gpg_error_object (result, err, "Error getting '%s': %s",
1139                             name, gpg_strerror (err));
1140           return err;
1141         }
1142     }
1143   return 0;
1144 }
1145
1146 \f
1147 /*
1148  * Implementation of the commands.
1149  */
1150
1151
1152 /* Create a "data" object and the "type", "base64" and "more" flags
1153  * from DATA and append them to RESULT.  Ownership of DATA is
1154  * transferred to this function.  TYPE must be a fixed string.
1155  * CHUNKSIZE is the chunksize requested from the caller.  If BASE64 is
1156  * -1 the need for base64 encoding is determined by the content of
1157  * DATA, all other values are taken as true or false.  Note that
1158  * op_getmore has similar code but works on PENDING_DATA which is set
1159  * here.  */
1160 static gpg_error_t
1161 make_data_object (cjson_t result, gpgme_data_t data, size_t chunksize,
1162                   const char *type, int base64)
1163 {
1164   gpg_error_t err;
1165   char *buffer;
1166   const char *s;
1167   size_t buflen, n;
1168   int c;
1169
1170   if (!base64 || base64 == -1) /* Make sure that we really have a string.  */
1171     gpgme_data_write (data, "", 1);
1172
1173   buffer = gpgme_data_release_and_get_mem (data, &buflen);
1174   data = NULL;
1175   if (!buffer)
1176     {
1177       err = gpg_error_from_syserror ();
1178       goto leave;
1179     }
1180
1181   if (base64 == -1)
1182     {
1183       base64 = 0;
1184       if (!buflen)
1185         log_fatal ("Appended Nul byte got lost\n");
1186       /* Figure out if there is any Nul octet in the buffer.  In that
1187        * case we need to Base-64 the buffer.  Due to problems with the
1188        * browser's Javascript we use Base-64 also in case an UTF-8
1189        * character is in the buffer.  This is because the chunking may
1190        * split an UTF-8 characters and JS can't handle this.  */
1191       for (s=buffer, n=0; n < buflen -1; s++, n++)
1192         if (!*s || (*s & 0x80))
1193           {
1194             buflen--; /* Adjust for the extra nul byte.  */
1195             base64 = 1;
1196             break;
1197           }
1198     }
1199
1200   /* Adjust the chunksize if we need to do base64 conversion.  */
1201   if (base64)
1202     chunksize = (chunksize / 4) * 3;
1203
1204   xjson_AddStringToObject (result, "type", type);
1205   xjson_AddBoolToObject (result, "base64", base64);
1206
1207   if (buflen > chunksize)
1208     {
1209       xjson_AddBoolToObject (result, "more", 1);
1210
1211       c = buffer[chunksize];
1212       buffer[chunksize] = 0;
1213       if (base64)
1214         err = add_base64_to_object (result, "data", buffer, chunksize);
1215       else
1216         err = cjson_AddStringToObject (result, "data", buffer);
1217       buffer[chunksize] = c;
1218       if (err)
1219         goto leave;
1220
1221       pending_data.buffer = buffer;
1222       buffer = NULL;
1223       pending_data.length = buflen;
1224       pending_data.written = chunksize;
1225       pending_data.type = type;
1226       pending_data.base64 = base64;
1227     }
1228   else
1229     {
1230       if (base64)
1231         err = add_base64_to_object (result, "data", buffer, buflen);
1232       else
1233         err = cjson_AddStringToObject (result, "data", buffer);
1234     }
1235
1236  leave:
1237   gpgme_free (buffer);
1238   return err;
1239 }
1240
1241
1242 \f
1243 static const char hlp_encrypt[] =
1244   "op:     \"encrypt\"\n"
1245   "keys:   Array of strings with the fingerprints or user-ids\n"
1246   "        of the keys to encrypt the data.  For a single key\n"
1247   "        a String may be used instead of an array.\n"
1248   "data:   Input data. \n"
1249   "\n"
1250   "Optional parameters:\n"
1251   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
1252   "chunksize:     Max number of bytes in the resulting \"data\".\n"
1253   "\n"
1254   "Optional boolean flags (default is false):\n"
1255   "base64:        Input data is base64 encoded.\n"
1256   "mime:          Indicate that data is a MIME object.\n"
1257   "armor:         Request output in armored format.\n"
1258   "always-trust:  Request --always-trust option.\n"
1259   "no-encrypt-to: Do not use a default recipient.\n"
1260   "no-compress:   Do not compress the plaintext first.\n"
1261   "throw-keyids:  Request the --throw-keyids option.\n"
1262   "want-address:  Require that the keys include a mail address.\n"
1263   "wrap:          Assume the input is an OpenPGP message.\n"
1264   "\n"
1265   "Response on success:\n"
1266   "type:   \"ciphertext\"\n"
1267   "data:   Unless armor mode is used a Base64 encoded binary\n"
1268   "        ciphertext.  In armor mode a string with an armored\n"
1269   "        OpenPGP or a PEM message.\n"
1270   "base64: Boolean indicating whether data is base64 encoded.\n"
1271   "more:   Optional boolean indicating that \"getmore\" is required.";
1272 static gpg_error_t
1273 op_encrypt (cjson_t request, cjson_t result)
1274 {
1275   gpg_error_t err;
1276   gpgme_ctx_t ctx = NULL;
1277   gpgme_protocol_t protocol;
1278   size_t chunksize;
1279   int opt_mime;
1280   char *keystring = NULL;
1281   gpgme_data_t input = NULL;
1282   gpgme_data_t output = NULL;
1283   int abool;
1284   gpgme_encrypt_flags_t encrypt_flags = 0;
1285
1286   if ((err = get_protocol (request, &protocol)))
1287     goto leave;
1288   ctx = get_context (protocol);
1289   if ((err = get_chunksize (request, &chunksize)))
1290     goto leave;
1291
1292   if ((err = get_boolean_flag (request, "mime", 0, &opt_mime)))
1293     goto leave;
1294
1295   if ((err = get_boolean_flag (request, "armor", 0, &abool)))
1296     goto leave;
1297   gpgme_set_armor (ctx, abool);
1298   if ((err = get_boolean_flag (request, "always-trust", 0, &abool)))
1299     goto leave;
1300   if (abool)
1301     encrypt_flags |= GPGME_ENCRYPT_ALWAYS_TRUST;
1302   if ((err = get_boolean_flag (request, "no-encrypt-to", 0,&abool)))
1303     goto leave;
1304   if (abool)
1305     encrypt_flags |= GPGME_ENCRYPT_NO_ENCRYPT_TO;
1306   if ((err = get_boolean_flag (request, "no-compress", 0, &abool)))
1307     goto leave;
1308   if (abool)
1309     encrypt_flags |= GPGME_ENCRYPT_NO_COMPRESS;
1310   if ((err = get_boolean_flag (request, "throw-keyids", 0, &abool)))
1311     goto leave;
1312   if (abool)
1313     encrypt_flags |= GPGME_ENCRYPT_THROW_KEYIDS;
1314   if ((err = get_boolean_flag (request, "wrap", 0, &abool)))
1315     goto leave;
1316   if (abool)
1317     encrypt_flags |= GPGME_ENCRYPT_WRAP;
1318   if ((err = get_boolean_flag (request, "want-address", 0, &abool)))
1319     goto leave;
1320   if (abool)
1321     encrypt_flags |= GPGME_ENCRYPT_WANT_ADDRESS;
1322
1323
1324   /* Get the keys.  */
1325   err = get_keys (request, &keystring);
1326   if (err)
1327     {
1328       /* Provide a custom error response.  */
1329       gpg_error_object (result, err, "Error getting keys: %s",
1330                         gpg_strerror (err));
1331       goto leave;
1332     }
1333
1334   if ((err = get_string_data (request, result, "data", &input)))
1335       goto leave;
1336
1337   if (opt_mime)
1338     gpgme_data_set_encoding (input, GPGME_DATA_ENCODING_MIME);
1339
1340
1341   /* Create an output data object.  */
1342   err = gpgme_data_new (&output);
1343   if (err)
1344     {
1345       gpg_error_object (result, err, "Error creating output data object: %s",
1346                         gpg_strerror (err));
1347       goto leave;
1348     }
1349
1350   /* Encrypt.  */
1351   err = gpgme_op_encrypt_ext (ctx, NULL, keystring, encrypt_flags,
1352                               input, output);
1353   /* encrypt_result = gpgme_op_encrypt_result (ctx); */
1354   if (err)
1355     {
1356       gpg_error_object (result, err, "Encryption failed: %s",
1357                         gpg_strerror (err));
1358       goto leave;
1359     }
1360   gpgme_data_release (input);
1361   input = NULL;
1362
1363   /* We need to base64 if armoring has not been requested.  */
1364   err = make_data_object (result, output, chunksize,
1365                           "ciphertext", !gpgme_get_armor (ctx));
1366   output = NULL;
1367
1368  leave:
1369   xfree (keystring);
1370   release_context (ctx);
1371   gpgme_data_release (input);
1372   gpgme_data_release (output);
1373   return err;
1374 }
1375
1376
1377 \f
1378 static const char hlp_decrypt[] =
1379   "op:     \"decrypt\"\n"
1380   "data:   The encrypted data.\n"
1381   "\n"
1382   "Optional parameters:\n"
1383   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
1384   "chunksize:     Max number of bytes in the resulting \"data\".\n"
1385   "\n"
1386   "Optional boolean flags (default is false):\n"
1387   "base64:        Input data is base64 encoded.\n"
1388   "\n"
1389   "Response on success:\n"
1390   "type:   \"plaintext\"\n"
1391   "data:   The decrypted data.  This may be base64 encoded.\n"
1392   "base64: Boolean indicating whether data is base64 encoded.\n"
1393   "mime:   A Boolean indicating whether the data is a MIME object.\n"
1394   "info:   An object with optional signature information.\n"
1395   "  Array values:\n"
1396   "   signatures\n"
1397   "    String values:\n"
1398   "     status: The status of the signature.\n"
1399   "     fingerprint: The fingerprint of the signing key.\n"
1400   "     validity: The validity as string.\n"
1401   "    Number values:\n"
1402   "     code: The status as a number.\n"
1403   "    Array values:\n"
1404   "     summary: A string array of the sig summary.\n"
1405   "more:   Optional boolean indicating that \"getmore\" is required.";
1406 static gpg_error_t
1407 op_decrypt (cjson_t request, cjson_t result)
1408 {
1409   gpg_error_t err;
1410   gpgme_ctx_t ctx = NULL;
1411   gpgme_protocol_t protocol;
1412   size_t chunksize;
1413   gpgme_data_t input = NULL;
1414   gpgme_data_t output = NULL;
1415   gpgme_decrypt_result_t decrypt_result;
1416   gpgme_verify_result_t verify_result;
1417
1418   if ((err = get_protocol (request, &protocol)))
1419     goto leave;
1420   ctx = get_context (protocol);
1421   if ((err = get_chunksize (request, &chunksize)))
1422     goto leave;
1423
1424   if ((err = get_string_data (request, result, "data", &input)))
1425       goto leave;
1426
1427   /* Create an output data object.  */
1428   err = gpgme_data_new (&output);
1429   if (err)
1430     {
1431       gpg_error_object (result, err,
1432                         "Error creating output data object: %s",
1433                         gpg_strerror (err));
1434       goto leave;
1435     }
1436
1437   /* Decrypt.  */
1438   err = gpgme_op_decrypt_ext (ctx, GPGME_DECRYPT_VERIFY,
1439                               input, output);
1440   decrypt_result = gpgme_op_decrypt_result (ctx);
1441   if (err)
1442     {
1443       gpg_error_object (result, err, "Decryption failed: %s",
1444                         gpg_strerror (err));
1445       goto leave;
1446     }
1447   gpgme_data_release (input);
1448   input = NULL;
1449
1450   if (decrypt_result->is_mime)
1451     xjson_AddBoolToObject (result, "mime", 1);
1452
1453   verify_result = gpgme_op_verify_result (ctx);
1454   if (verify_result && verify_result->signatures)
1455     {
1456       xjson_AddItemToObject (result, "info",
1457                              verify_result_to_json (verify_result));
1458     }
1459
1460   err = make_data_object (result, output, chunksize, "plaintext", -1);
1461   output = NULL;
1462
1463   if (err)
1464     {
1465       gpg_error_object (result, err, "Plaintext output failed: %s",
1466                         gpg_strerror (err));
1467       goto leave;
1468     }
1469
1470  leave:
1471   release_context (ctx);
1472   gpgme_data_release (input);
1473   gpgme_data_release (output);
1474   return err;
1475 }
1476
1477
1478 \f
1479 static const char hlp_sign[] =
1480   "op:     \"sign\"\n"
1481   "keys:   Array of strings with the fingerprints of the signing key.\n"
1482   "        For a single key a String may be used instead of an array.\n"
1483   "data:   Input data. \n"
1484   "\n"
1485   "Optional parameters:\n"
1486   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
1487   "chunksize:     Max number of bytes in the resulting \"data\".\n"
1488   "sender:        The mail address of the sender.\n"
1489   "mode:          A string with the signing mode can be:\n"
1490   "               detached (default)\n"
1491   "               opaque\n"
1492   "               clearsign\n"
1493   "\n"
1494   "Optional boolean flags (default is false):\n"
1495   "base64:        Input data is base64 encoded.\n"
1496   "armor:         Request output in armored format.\n"
1497   "\n"
1498   "Response on success:\n"
1499   "type:   \"signature\"\n"
1500   "data:   Unless armor mode is used a Base64 encoded binary\n"
1501   "        signature.  In armor mode a string with an armored\n"
1502   "        OpenPGP or a PEM message.\n"
1503   "base64: Boolean indicating whether data is base64 encoded.\n"
1504   "more:   Optional boolean indicating that \"getmore\" is required.";
1505 static gpg_error_t
1506 op_sign (cjson_t request, cjson_t result)
1507 {
1508   gpg_error_t err;
1509   gpgme_ctx_t ctx = NULL;
1510   gpgme_protocol_t protocol;
1511   size_t chunksize;
1512   char **patterns = NULL;
1513   gpgme_data_t input = NULL;
1514   gpgme_data_t output = NULL;
1515   int abool;
1516   cjson_t j_tmp;
1517   gpgme_sig_mode_t mode = GPGME_SIG_MODE_DETACH;
1518   gpgme_ctx_t keylist_ctx = NULL;
1519   gpgme_key_t key = NULL;
1520
1521   if ((err = get_protocol (request, &protocol)))
1522     goto leave;
1523   ctx = get_context (protocol);
1524   if ((err = get_chunksize (request, &chunksize)))
1525     goto leave;
1526
1527   if ((err = get_boolean_flag (request, "armor", 0, &abool)))
1528     goto leave;
1529   gpgme_set_armor (ctx, abool);
1530
1531   j_tmp = cJSON_GetObjectItem (request, "mode");
1532   if (j_tmp && cjson_is_string (j_tmp))
1533     {
1534       if (!strcmp (j_tmp->valuestring, "opaque"))
1535         {
1536           mode = GPGME_SIG_MODE_NORMAL;
1537         }
1538       else if (!strcmp (j_tmp->valuestring, "clearsign"))
1539         {
1540           mode = GPGME_SIG_MODE_CLEAR;
1541         }
1542     }
1543
1544   j_tmp = cJSON_GetObjectItem (request, "sender");
1545   if (j_tmp && cjson_is_string (j_tmp))
1546     {
1547       gpgme_set_sender (ctx, j_tmp->valuestring);
1548     }
1549
1550   patterns = create_keylist_patterns (request);
1551   if (!patterns)
1552     {
1553       gpg_error_object (result, err, "Error getting keys: %s",
1554                         gpg_strerror (gpg_error (GPG_ERR_NO_KEY)));
1555       goto leave;
1556     }
1557
1558   /* Do a keylisting and add the keys */
1559   if ((err = gpgme_new (&keylist_ctx)))
1560     goto leave;
1561   gpgme_set_protocol (keylist_ctx, protocol);
1562   gpgme_set_keylist_mode (keylist_ctx, GPGME_KEYLIST_MODE_LOCAL);
1563
1564   err = gpgme_op_keylist_ext_start (ctx, (const char **) patterns, 1, 0);
1565   if (err)
1566     {
1567       gpg_error_object (result, err, "Error listing keys: %s",
1568                         gpg_strerror (err));
1569       goto leave;
1570     }
1571   while (!(err = gpgme_op_keylist_next (ctx, &key)))
1572     {
1573       if ((err = gpgme_signers_add (ctx, key)))
1574         {
1575           gpg_error_object (result, err, "Error adding signer: %s",
1576                             gpg_strerror (err));
1577           goto leave;
1578         }
1579       gpgme_key_unref (key);
1580     }
1581
1582   if ((err = get_string_data (request, result, "data", &input)))
1583       goto leave;
1584
1585   /* Create an output data object.  */
1586   err = gpgme_data_new (&output);
1587   if (err)
1588     {
1589       gpg_error_object (result, err, "Error creating output data object: %s",
1590                         gpg_strerror (err));
1591       goto leave;
1592     }
1593
1594   /* Sign. */
1595   err = gpgme_op_sign (ctx, input, output, mode);
1596   if (err)
1597     {
1598       gpg_error_object (result, err, "Signing failed: %s",
1599                         gpg_strerror (err));
1600       goto leave;
1601     }
1602
1603   gpgme_data_release (input);
1604   input = NULL;
1605
1606   /* We need to base64 if armoring has not been requested.  */
1607   err = make_data_object (result, output, chunksize,
1608                           "signature", !gpgme_get_armor (ctx));
1609   output = NULL;
1610
1611  leave:
1612   xfree_array (patterns);
1613   release_context (ctx);
1614   release_context (keylist_ctx);
1615   gpgme_data_release (input);
1616   gpgme_data_release (output);
1617   return err;
1618 }
1619 \f
1620 static const char hlp_verify[] =
1621   "op:     \"verify\"\n"
1622   "data:   The data to verify.\n"
1623   "\n"
1624   "Optional parameters:\n"
1625   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
1626   "chunksize:     Max number of bytes in the resulting \"data\".\n"
1627   "signature:     A detached signature. If missing opaque is assumed.\n"
1628   "\n"
1629   "Optional boolean flags (default is false):\n"
1630   "base64:        Input data is base64 encoded.\n"
1631   "\n"
1632   "Response on success:\n"
1633   "type:   \"plaintext\"\n"
1634   "data:   The verified data.  This may be base64 encoded.\n"
1635   "base64: Boolean indicating whether data is base64 encoded.\n"
1636   "info:   An object with signature information.\n"
1637   "  Array values:\n"
1638   "   signatures\n"
1639   "    String values:\n"
1640   "     status: The status of the signature.\n"
1641   "     fingerprint: The fingerprint of the signing key.\n"
1642   "     validity: The validity as string.\n"
1643   "    Number values:\n"
1644   "     code: The status as a number.\n"
1645   "    Array values:\n"
1646   "     summary: A string array of the sig summary.\n"
1647   "more:   Optional boolean indicating that \"getmore\" is required.";
1648 static gpg_error_t
1649 op_verify (cjson_t request, cjson_t result)
1650 {
1651   gpg_error_t err;
1652   gpgme_ctx_t ctx = NULL;
1653   gpgme_protocol_t protocol;
1654   size_t chunksize;
1655   gpgme_data_t input = NULL;
1656   gpgme_data_t signature = NULL;
1657   gpgme_data_t output = NULL;
1658   gpgme_verify_result_t verify_result;
1659
1660   if ((err = get_protocol (request, &protocol)))
1661     goto leave;
1662   ctx = get_context (protocol);
1663   if ((err = get_chunksize (request, &chunksize)))
1664     goto leave;
1665
1666   if ((err = get_string_data (request, result, "data", &input)))
1667     goto leave;
1668
1669   err = get_string_data (request, result, "signature", &signature);
1670   /* Signature data is optional otherwise we expect opaque or clearsigned. */
1671   if (err && err != gpg_error (GPG_ERR_NO_DATA))
1672     goto leave;
1673
1674   /* Create an output data object.  */
1675   err = gpgme_data_new (&output);
1676   if (err)
1677     {
1678       gpg_error_object (result, err, "Error creating output data object: %s",
1679                         gpg_strerror (err));
1680       goto leave;
1681     }
1682
1683   /* Verify.  */
1684   if (signature)
1685     {
1686       err = gpgme_op_verify (ctx, signature, input, output);
1687     }
1688   else
1689     {
1690       err = gpgme_op_verify (ctx, input, 0, output);
1691     }
1692   if (err)
1693     {
1694       gpg_error_object (result, err, "Verify failed: %s", gpg_strerror (err));
1695       goto leave;
1696     }
1697   gpgme_data_release (input);
1698   input = NULL;
1699   gpgme_data_release (signature);
1700   signature = NULL;
1701
1702   verify_result = gpgme_op_verify_result (ctx);
1703   if (verify_result && verify_result->signatures)
1704     {
1705       xjson_AddItemToObject (result, "info",
1706                              verify_result_to_json (verify_result));
1707     }
1708
1709   err = make_data_object (result, output, chunksize, "plaintext", -1);
1710   output = NULL;
1711
1712   if (err)
1713     {
1714       gpg_error_object (result, err, "Plaintext output failed: %s",
1715                         gpg_strerror (err));
1716       goto leave;
1717     }
1718
1719  leave:
1720   release_context (ctx);
1721   gpgme_data_release (input);
1722   gpgme_data_release (output);
1723   gpgme_data_release (signature);
1724   return err;
1725 }
1726 \f
1727 static const char hlp_version[] =
1728   "op:     \"version\"\n"
1729   "\n"
1730   "Response on success:\n"
1731   "gpgme:  The GPGME Version.\n"
1732   "info:   dump of engine info. containing:\n"
1733   "        protocol: The protocol.\n"
1734   "        fname:    The file name.\n"
1735   "        version:  The version.\n"
1736   "        req_ver:  The required version.\n"
1737   "        homedir:  The homedir of the engine or \"default\".\n";
1738 static gpg_error_t
1739 op_version (cjson_t request, cjson_t result)
1740 {
1741   gpg_error_t err = 0;
1742   gpgme_engine_info_t ei = NULL;
1743   cjson_t infos = xjson_CreateArray ();
1744
1745   if (!cJSON_AddStringToObject (result, "gpgme", gpgme_check_version (NULL)))
1746     {
1747       cJSON_Delete (infos);
1748       return gpg_error_from_syserror ();
1749     }
1750
1751   if ((err = gpgme_get_engine_info (&ei)))
1752     {
1753       cJSON_Delete (infos);
1754       return err;
1755     }
1756
1757   for (; ei; ei = ei->next)
1758     cJSON_AddItemToArray (infos, engine_info_to_json (ei));
1759
1760   if (!cJSON_AddItemToObject (result, "info", infos))
1761     {
1762       err = gpg_error_from_syserror ();
1763       cJSON_Delete (infos);
1764       return err;
1765     }
1766
1767   return 0;
1768 }
1769 \f
1770 static const char hlp_keylist[] =
1771   "op:     \"keylist\"\n"
1772   "\n"
1773   "Optional parameters:\n"
1774   "keys:          Array of strings or fingerprints to lookup\n"
1775   "               For a single key a String may be used instead of an array.\n"
1776   "               default lists all keys.\n"
1777   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
1778   "chunksize:     Max number of bytes in the resulting \"data\".\n"
1779   "\n"
1780   "Optional boolean flags (default is false):\n"
1781   "secret:        List secret keys.\n"
1782   "extern:        Add KEYLIST_MODE_EXTERN.\n"
1783   "local:         Add KEYLIST_MODE_LOCAL. (default mode).\n"
1784   "sigs:          Add KEYLIST_MODE_SIGS.\n"
1785   "notations:     Add KEYLIST_MODE_SIG_NOTATIONS.\n"
1786   "tofu:          Add KEYLIST_MODE_WITH_TOFU.\n"
1787   "ephemeral:     Add KEYLIST_MODE_EPHEMERAL.\n"
1788   "validate:      Add KEYLIST_MODE_VALIDATE.\n"
1789   "\n"
1790   "Response on success:\n"
1791   "keys:   Array of keys.\n"
1792   "  Boolean values:\n"
1793   "   revoked\n"
1794   "   expired\n"
1795   "   disabled\n"
1796   "   invalid\n"
1797   "   can_encrypt\n"
1798   "   can_sign\n"
1799   "   can_certify\n"
1800   "   can_authenticate\n"
1801   "   secret\n"
1802   "   is_qualified\n"
1803   "  String values:\n"
1804   "   protocol\n"
1805   "   issuer_serial (CMS Only)\n"
1806   "   issuer_name (CMS Only)\n"
1807   "   chain_id (CMS Only)\n"
1808   "   owner_trust (OpenPGP only)\n"
1809   "   fingerprint\n"
1810   "  Number values:\n"
1811   "   last_update\n"
1812   "   origin\n"
1813   "  Array values:\n"
1814   "   subkeys\n"
1815   "    Boolean values:\n"
1816   "     revoked\n"
1817   "     expired\n"
1818   "     disabled\n"
1819   "     invalid\n"
1820   "     can_encrypt\n"
1821   "     can_sign\n"
1822   "     can_certify\n"
1823   "     can_authenticate\n"
1824   "     secret\n"
1825   "     is_qualified\n"
1826   "     is_cardkey\n"
1827   "     is_de_vs\n"
1828   "    String values:\n"
1829   "     pubkey_algo_name\n"
1830   "     pubkey_algo_string\n"
1831   "     keyid\n"
1832   "     card_number\n"
1833   "     curve\n"
1834   "     keygrip\n"
1835   "    Number values:\n"
1836   "     pubkey_algo\n"
1837   "     length\n"
1838   "     timestamp\n"
1839   "     expires\n"
1840   "   userids\n"
1841   "    Boolean values:\n"
1842   "     revoked\n"
1843   "     invalid\n"
1844   "    String values:\n"
1845   "     validity\n"
1846   "     uid\n"
1847   "     name\n"
1848   "     email\n"
1849   "     comment\n"
1850   "     address\n"
1851   "    Number values:\n"
1852   "     origin\n"
1853   "     last_update\n"
1854   "    Array values:\n"
1855   "     signatures\n"
1856   "      Boolean values:\n"
1857   "       revoked\n"
1858   "       expired\n"
1859   "       invalid\n"
1860   "       exportable\n"
1861   "      String values:\n"
1862   "       pubkey_algo_name\n"
1863   "       keyid\n"
1864   "       status\n"
1865   "       uid\n"
1866   "       name\n"
1867   "       email\n"
1868   "       comment\n"
1869   "      Number values:\n"
1870   "       pubkey_algo\n"
1871   "       timestamp\n"
1872   "       expires\n"
1873   "       status_code\n"
1874   "       sig_class\n"
1875   "      Array values:\n"
1876   "       notations\n"
1877   "        Boolean values:\n"
1878   "         human_readable\n"
1879   "         critical\n"
1880   "        String values:\n"
1881   "         name\n"
1882   "         value\n"
1883   "        Number values:\n"
1884   "         flags\n"
1885   "     tofu\n"
1886   "      String values:\n"
1887   "       description\n"
1888   "      Number values:\n"
1889   "       validity\n"
1890   "       policy\n"
1891   "       signcount\n"
1892   "       encrcount\n"
1893   "       signfirst\n"
1894   "       signlast\n"
1895   "       encrfirst\n"
1896   "       encrlast\n"
1897   "more:   Optional boolean indicating that \"getmore\" is required.\n"
1898   "        (not implemented)";
1899 static gpg_error_t
1900 op_keylist (cjson_t request, cjson_t result)
1901 {
1902   gpg_error_t err;
1903   gpgme_ctx_t ctx = NULL;
1904   gpgme_protocol_t protocol;
1905   size_t chunksize;
1906   char **patterns = NULL;
1907   int abool;
1908   gpgme_keylist_mode_t mode = 0;
1909   gpgme_key_t key = NULL;
1910   cjson_t keyarray = xjson_CreateArray ();
1911
1912   if ((err = get_protocol (request, &protocol)))
1913     goto leave;
1914   ctx = get_context (protocol);
1915   if ((err = get_chunksize (request, &chunksize)))
1916     goto leave;
1917
1918   /* Handle the various keylist mode bools. */
1919   if ((err = get_boolean_flag (request, "secret", 0, &abool)))
1920     goto leave;
1921   if (abool)
1922     mode |= GPGME_KEYLIST_MODE_WITH_SECRET;
1923
1924   if ((err = get_boolean_flag (request, "extern", 0, &abool)))
1925     goto leave;
1926   if (abool)
1927     mode |= GPGME_KEYLIST_MODE_EXTERN;
1928
1929   if ((err = get_boolean_flag (request, "local", 0, &abool)))
1930     goto leave;
1931   if (abool)
1932     mode |= GPGME_KEYLIST_MODE_LOCAL;
1933
1934   if ((err = get_boolean_flag (request, "sigs", 0, &abool)))
1935     goto leave;
1936   if (abool)
1937     mode |= GPGME_KEYLIST_MODE_SIGS;
1938
1939   if ((err = get_boolean_flag (request, "notations", 0, &abool)))
1940     goto leave;
1941   if (abool)
1942     mode |= GPGME_KEYLIST_MODE_SIG_NOTATIONS;
1943
1944   if ((err = get_boolean_flag (request, "tofu", 0, &abool)))
1945     goto leave;
1946   if (abool)
1947     mode |= GPGME_KEYLIST_MODE_WITH_TOFU;
1948
1949   if ((err = get_boolean_flag (request, "ephemeral", 0, &abool)))
1950     goto leave;
1951   if (abool)
1952     mode |= GPGME_KEYLIST_MODE_EPHEMERAL;
1953
1954   if ((err = get_boolean_flag (request, "validate", 0, &abool)))
1955     goto leave;
1956   if (abool)
1957     mode |= GPGME_KEYLIST_MODE_VALIDATE;
1958
1959   if (!mode)
1960     {
1961       /* default to local */
1962       mode = GPGME_KEYLIST_MODE_LOCAL;
1963     }
1964
1965   /* Get the keys.  */
1966   patterns = create_keylist_patterns (request);
1967
1968   /* Do a keylisting and add the keys */
1969   if ((err = gpgme_new (&ctx)))
1970     goto leave;
1971   gpgme_set_protocol (ctx, protocol);
1972   gpgme_set_keylist_mode (ctx, mode);
1973
1974   err = gpgme_op_keylist_ext_start (ctx, (const char **) patterns,
1975                                     (mode & GPGME_KEYLIST_MODE_WITH_SECRET),
1976                                     0);
1977   if (err)
1978     {
1979       gpg_error_object (result, err, "Error listing keys: %s",
1980                         gpg_strerror (err));
1981       goto leave;
1982     }
1983
1984   while (!(err = gpgme_op_keylist_next (ctx, &key)))
1985     {
1986       cJSON_AddItemToArray (keyarray, key_to_json (key));
1987       gpgme_key_unref (key);
1988     }
1989   err = 0;
1990
1991   if (!cJSON_AddItemToObject (result, "keys", keyarray))
1992     {
1993       err = gpg_error_from_syserror ();
1994       goto leave;
1995     }
1996
1997  leave:
1998   xfree_array (patterns);
1999   if (err)
2000     {
2001       cJSON_Delete (keyarray);
2002     }
2003   return err;
2004 }
2005 \f
2006 static const char hlp_import[] =
2007   "op:     \"import\"\n"
2008   "data:   The data to import.\n"
2009   "\n"
2010   "Optional parameters:\n"
2011   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
2012   "\n"
2013   "Optional boolean flags (default is false):\n"
2014   "base64:        Input data is base64 encoded.\n"
2015   "\n"
2016   "Response on success:\n"
2017   "result: The import result.\n"
2018   "  Number values:\n"
2019   "   considered\n"
2020   "   no_user_id\n"
2021   "   imported\n"
2022   "   imported_rsa\n"
2023   "   unchanged\n"
2024   "   new_user_ids\n"
2025   "   new_sub_keys\n"
2026   "   new_signatures\n"
2027   "   new_revocations\n"
2028   "   secret_read\n"
2029   "   secret_imported\n"
2030   "   secret_unchanged\n"
2031   "   skipped_new_keys\n"
2032   "   not_imported\n"
2033   "   skipped_v3_keys\n"
2034   "  Array values:\n"
2035   "   imports: List of keys for which an import was attempted\n"
2036   "    String values:\n"
2037   "     fingerprint\n"
2038   "     error_string\n"
2039   "    Number values:\n"
2040   "     error_code\n"
2041   "     status\n";
2042 static gpg_error_t
2043 op_import (cjson_t request, cjson_t result)
2044 {
2045   gpg_error_t err;
2046   gpgme_ctx_t ctx = NULL;
2047   gpgme_data_t input = NULL;
2048   gpgme_import_result_t import_result;
2049   gpgme_protocol_t protocol;
2050
2051   if ((err = get_protocol (request, &protocol)))
2052     goto leave;
2053   ctx = get_context (protocol);
2054
2055   if ((err = get_string_data (request, result, "data", &input)))
2056       goto leave;
2057
2058   /* Import.  */
2059   err = gpgme_op_import (ctx, input);
2060   import_result = gpgme_op_import_result (ctx);
2061   if (err)
2062     {
2063       gpg_error_object (result, err, "Import failed: %s",
2064                         gpg_strerror (err));
2065       goto leave;
2066     }
2067   gpgme_data_release (input);
2068   input = NULL;
2069
2070   xjson_AddItemToObject (result, "result",
2071                          import_result_to_json (import_result));
2072
2073  leave:
2074   release_context (ctx);
2075   gpgme_data_release (input);
2076   return err;
2077 }
2078 \f
2079 static const char hlp_getmore[] =
2080   "op:     \"getmore\"\n"
2081   "\n"
2082   "Optional parameters:\n"
2083   "chunksize:  Max number of bytes in the \"data\" object.\n"
2084   "\n"
2085   "Response on success:\n"
2086   "type:       Type of the pending data\n"
2087   "data:       The next chunk of data\n"
2088   "base64:     Boolean indicating whether data is base64 encoded\n"
2089   "more:       Optional boolean requesting another \"getmore\".";
2090 static gpg_error_t
2091 op_getmore (cjson_t request, cjson_t result)
2092 {
2093   gpg_error_t err;
2094   int c;
2095   size_t n;
2096   size_t chunksize;
2097
2098   if ((err = get_chunksize (request, &chunksize)))
2099     goto leave;
2100
2101   /* Adjust the chunksize if we need to do base64 conversion.  */
2102   if (pending_data.base64)
2103     chunksize = (chunksize / 4) * 3;
2104
2105   /* Do we have anything pending?  */
2106   if (!pending_data.buffer)
2107     {
2108       err = gpg_error (GPG_ERR_NO_DATA);
2109       gpg_error_object (result, err, "Operation not possible: %s",
2110                         gpg_strerror (err));
2111       goto leave;
2112     }
2113
2114   xjson_AddStringToObject (result, "type", pending_data.type);
2115   xjson_AddBoolToObject (result, "base64", pending_data.base64);
2116
2117   if (pending_data.written >= pending_data.length)
2118     {
2119       /* EOF reached.  This should not happen but we return an empty
2120        * string once in case of client errors.  */
2121       gpgme_free (pending_data.buffer);
2122       pending_data.buffer = NULL;
2123       xjson_AddBoolToObject (result, "more", 0);
2124       err = cjson_AddStringToObject (result, "data", "");
2125     }
2126   else
2127     {
2128       n = pending_data.length - pending_data.written;
2129       if (n > chunksize)
2130         {
2131           n = chunksize;
2132           xjson_AddBoolToObject (result, "more", 1);
2133         }
2134       else
2135         xjson_AddBoolToObject (result, "more", 0);
2136
2137       c = pending_data.buffer[pending_data.written + n];
2138       pending_data.buffer[pending_data.written + n] = 0;
2139       if (pending_data.base64)
2140         err = add_base64_to_object (result, "data",
2141                                     (pending_data.buffer
2142                                      + pending_data.written), n);
2143       else
2144         err = cjson_AddStringToObject (result, "data",
2145                                        (pending_data.buffer
2146                                         + pending_data.written));
2147       pending_data.buffer[pending_data.written + n] = c;
2148       if (!err)
2149         {
2150           pending_data.written += n;
2151           if (pending_data.written >= pending_data.length)
2152             {
2153               gpgme_free (pending_data.buffer);
2154               pending_data.buffer = NULL;
2155             }
2156         }
2157     }
2158
2159  leave:
2160   return err;
2161 }
2162
2163
2164 \f
2165 static const char hlp_help[] =
2166   "The tool expects a JSON object with the request and responds with\n"
2167   "another JSON object.  Even on error a JSON object is returned.  The\n"
2168   "property \"op\" is mandatory and its string value selects the\n"
2169   "operation; if the property \"help\" with the value \"true\" exists, the\n"
2170   "operation is not performned but a string with the documentation\n"
2171   "returned.  To list all operations it is allowed to leave out \"op\" in\n"
2172   "help mode.  Supported values for \"op\" are:\n\n"
2173   "  encrypt     Encrypt data.\n"
2174   "  decrypt     Decrypt data.\n"
2175   "  import      Import data.\n"
2176   "  keylist     List keys.\n"
2177   "  sign        Sign data.\n"
2178   "  verify      Verify data.\n"
2179   "  version     Get engine information.\n"
2180   "  getmore     Retrieve remaining data.\n"
2181   "  help        Help overview.";
2182 static gpg_error_t
2183 op_help (cjson_t request, cjson_t result)
2184 {
2185   cjson_t j_tmp;
2186   char *buffer = NULL;
2187   const char *msg;
2188
2189   j_tmp = cJSON_GetObjectItem (request, "interactive_help");
2190   if (opt_interactive && j_tmp && cjson_is_string (j_tmp))
2191     msg = buffer = xstrconcat (hlp_help, "\n", j_tmp->valuestring, NULL);
2192   else
2193     msg = hlp_help;
2194
2195   xjson_AddStringToObject (result, "type", "help");
2196   xjson_AddStringToObject (result, "msg", msg);
2197
2198   xfree (buffer);
2199   return 0;
2200 }
2201
2202
2203 \f
2204 /*
2205  * Dispatcher
2206  */
2207
2208 /* Process a request and return the response.  The response is a newly
2209  * allocated string or NULL in case of an error.  */
2210 static char *
2211 process_request (const char *request)
2212 {
2213   static struct {
2214     const char *op;
2215     gpg_error_t (*handler)(cjson_t request, cjson_t result);
2216     const char * const helpstr;
2217   } optbl[] = {
2218     { "encrypt", op_encrypt, hlp_encrypt },
2219     { "decrypt", op_decrypt, hlp_decrypt },
2220     { "keylist", op_keylist, hlp_keylist },
2221     { "import",  op_import,  hlp_import },
2222     { "sign",    op_sign,    hlp_sign },
2223     { "verify",  op_verify,  hlp_verify },
2224     { "version", op_version, hlp_version },
2225     { "getmore", op_getmore, hlp_getmore },
2226     { "help",    op_help,    hlp_help },
2227     { NULL }
2228   };
2229   size_t erroff;
2230   cjson_t json;
2231   cjson_t j_tmp, j_op;
2232   cjson_t response;
2233   int helpmode;
2234   const char *op;
2235   char *res;
2236   int idx;
2237
2238   response = xjson_CreateObject ();
2239
2240   json = cJSON_Parse (request, &erroff);
2241   if (!json)
2242     {
2243       log_string (GPGRT_LOGLVL_INFO, request);
2244       log_info ("invalid JSON object at offset %zu\n", erroff);
2245       error_object (response, "invalid JSON object at offset %zu\n", erroff);
2246       goto leave;
2247     }
2248
2249   j_tmp = cJSON_GetObjectItem (json, "help");
2250   helpmode = (j_tmp && cjson_is_true (j_tmp));
2251
2252   j_op = cJSON_GetObjectItem (json, "op");
2253   if (!j_op || !cjson_is_string (j_op))
2254     {
2255       if (!helpmode)
2256         {
2257           error_object (response, "Property \"op\" missing");
2258           goto leave;
2259         }
2260       op = "help";  /* Help summary.  */
2261     }
2262   else
2263     op = j_op->valuestring;
2264
2265   for (idx=0; optbl[idx].op; idx++)
2266     if (!strcmp (op, optbl[idx].op))
2267       break;
2268   if (optbl[idx].op)
2269     {
2270       if (helpmode && strcmp (op, "help"))
2271         {
2272           xjson_AddStringToObject (response, "type", "help");
2273           xjson_AddStringToObject (response, "op", op);
2274           xjson_AddStringToObject (response, "msg", optbl[idx].helpstr);
2275         }
2276       else
2277         {
2278           gpg_error_t err;
2279
2280           /* If this is not the "getmore" command and we have any
2281            * pending data release that data.  */
2282           if (pending_data.buffer && optbl[idx].handler != op_getmore)
2283             {
2284               gpgme_free (pending_data.buffer);
2285               pending_data.buffer = NULL;
2286             }
2287
2288           err = optbl[idx].handler (json, response);
2289           if (err)
2290             {
2291               if (!(j_tmp = cJSON_GetObjectItem (response, "type"))
2292                   || !cjson_is_string (j_tmp)
2293                   || strcmp (j_tmp->valuestring, "error"))
2294                 {
2295                   /* No error type response - provide a generic one.  */
2296                   gpg_error_object (response, err, "Operation failed: %s",
2297                                     gpg_strerror (err));
2298                 }
2299
2300               xjson_AddStringToObject (response, "op", op);
2301             }
2302         }
2303     }
2304   else  /* Operation not supported.  */
2305     {
2306       error_object (response, "Unknown operation '%s'", op);
2307       xjson_AddStringToObject (response, "op", op);
2308     }
2309
2310  leave:
2311   cJSON_Delete (json);
2312   if (opt_interactive)
2313     res = cJSON_Print (response);
2314   else
2315     res = cJSON_PrintUnformatted (response);
2316   if (!res)
2317     log_error ("Printing JSON data failed\n");
2318   cJSON_Delete (response);
2319   return res;
2320 }
2321
2322
2323 \f
2324 /*
2325  *  Driver code
2326  */
2327
2328 static char *
2329 get_file (const char *fname)
2330 {
2331   gpg_error_t err;
2332   estream_t fp;
2333   struct stat st;
2334   char *buf;
2335   size_t buflen;
2336
2337   fp = es_fopen (fname, "r");
2338   if (!fp)
2339     {
2340       err = gpg_error_from_syserror ();
2341       log_error ("can't open '%s': %s\n", fname, gpg_strerror (err));
2342       return NULL;
2343     }
2344
2345   if (fstat (es_fileno(fp), &st))
2346     {
2347       err = gpg_error_from_syserror ();
2348       log_error ("can't stat '%s': %s\n", fname, gpg_strerror (err));
2349       es_fclose (fp);
2350       return NULL;
2351     }
2352
2353   buflen = st.st_size;
2354   buf = xmalloc (buflen+1);
2355   if (es_fread (buf, buflen, 1, fp) != 1)
2356     {
2357       err = gpg_error_from_syserror ();
2358       log_error ("error reading '%s': %s\n", fname, gpg_strerror (err));
2359       es_fclose (fp);
2360       xfree (buf);
2361       return NULL;
2362     }
2363   buf[buflen] = 0;
2364   es_fclose (fp);
2365
2366   return buf;
2367 }
2368
2369
2370 /* Return a malloced line or NULL on EOF.  Terminate on read
2371  * error.  */
2372 static char *
2373 get_line (void)
2374 {
2375   char *line = NULL;
2376   size_t linesize = 0;
2377   gpg_error_t err;
2378   size_t maxlength = 2048;
2379   int n;
2380   const char *s;
2381   char *p;
2382
2383  again:
2384   n = es_read_line (es_stdin, &line, &linesize, &maxlength);
2385   if (n < 0)
2386     {
2387       err = gpg_error_from_syserror ();
2388       log_error ("error reading line: %s\n", gpg_strerror (err));
2389       exit (1);
2390     }
2391   if (!n)
2392     {
2393       xfree (line);
2394       line = NULL;
2395       return NULL;  /* EOF */
2396     }
2397   if (!maxlength)
2398     {
2399       log_info ("line too long - skipped\n");
2400       goto again;
2401     }
2402   if (memchr (line, 0, n))
2403     log_info ("warning: line shortened due to embedded Nul character\n");
2404
2405   if (line[n-1] == '\n')
2406     line[n-1] = 0;
2407
2408   /* Trim leading spaces.  */
2409   for (s=line; spacep (s); s++)
2410     ;
2411   if (s != line)
2412     {
2413       for (p=line; *s;)
2414         *p++ = *s++;
2415       *p = 0;
2416       n = p - line;
2417     }
2418
2419   return line;
2420 }
2421
2422
2423 /* Process meta commands used with the standard REPL.  */
2424 static char *
2425 process_meta_commands (const char *request)
2426 {
2427   char *result = NULL;
2428
2429   while (spacep (request))
2430     request++;
2431
2432   if (!strncmp (request, "help", 4) && (spacep (request+4) || !request[4]))
2433     {
2434       if (request[4])
2435         {
2436           char *buf = xstrconcat ("{ \"help\":true, \"op\":\"", request+5,
2437                                   "\" }", NULL);
2438           result = process_request (buf);
2439           xfree (buf);
2440         }
2441       else
2442         result = process_request ("{ \"op\": \"help\","
2443                                   " \"interactive_help\": "
2444                                   "\"\\nMeta commands:\\n"
2445                                   "  ,read FNAME Process data from FILE\\n"
2446                                   "  ,help CMD   Print help for a command\\n"
2447                                   "  ,quit       Terminate process\""
2448                                   "}");
2449     }
2450   else if (!strncmp (request, "quit", 4) && (spacep (request+4) || !request[4]))
2451     exit (0);
2452   else if (!strncmp (request, "read", 4) && (spacep (request+4) || !request[4]))
2453     {
2454       if (!request[4])
2455         log_info ("usage: ,read FILENAME\n");
2456       else
2457         {
2458           char *buffer = get_file (request + 5);
2459           if (buffer)
2460             {
2461               result = process_request (buffer);
2462               xfree (buffer);
2463             }
2464         }
2465     }
2466   else
2467     log_info ("invalid meta command\n");
2468
2469   return result;
2470 }
2471
2472
2473 /* If STRING has a help response, return the MSG property in a human
2474  * readable format.  */
2475 static char *
2476 get_help_msg (const char *string)
2477 {
2478   cjson_t json, j_type, j_msg;
2479   const char *msg;
2480   char *buffer = NULL;
2481   char *p;
2482
2483   json = cJSON_Parse (string, NULL);
2484   if (json)
2485     {
2486       j_type = cJSON_GetObjectItem (json, "type");
2487       if (j_type && cjson_is_string (j_type)
2488           && !strcmp (j_type->valuestring, "help"))
2489         {
2490           j_msg = cJSON_GetObjectItem (json, "msg");
2491           if (j_msg || cjson_is_string (j_msg))
2492             {
2493               msg = j_msg->valuestring;
2494               buffer = malloc (strlen (msg)+1);
2495               if (buffer)
2496                 {
2497                   for (p=buffer; *msg; msg++)
2498                     {
2499                       if (*msg == '\\' && msg[1] == '\n')
2500                         *p++ = '\n';
2501                       else
2502                         *p++ = *msg;
2503                     }
2504                   *p = 0;
2505                 }
2506             }
2507         }
2508       cJSON_Delete (json);
2509     }
2510   return buffer;
2511 }
2512
2513
2514 /* An interactive standard REPL.  */
2515 static void
2516 interactive_repl (void)
2517 {
2518   char *line = NULL;
2519   char *request = NULL;
2520   char *response = NULL;
2521   char *p;
2522   int first;
2523
2524   es_setvbuf (es_stdin, NULL, _IONBF, 0);
2525 #if GPGRT_VERSION_NUMBER >= 0x011d00 /* 1.29 */
2526   es_fprintf (es_stderr, "%s %s ready (enter \",help\" for help)\n",
2527               gpgrt_strusage (11), gpgrt_strusage (13));
2528 #endif
2529   do
2530     {
2531       es_fputs ("> ", es_stderr);
2532       es_fflush (es_stderr);
2533       es_fflush (es_stdout);
2534       xfree (line);
2535       line = get_line ();
2536       es_fflush (es_stderr);
2537       es_fflush (es_stdout);
2538
2539       first = !request;
2540       if (line && *line)
2541         {
2542           if (!request)
2543             request = xstrdup (line);
2544           else
2545             request = xstrconcat (request, "\n", line, NULL);
2546         }
2547
2548       if (!line)
2549         es_fputs ("\n", es_stderr);
2550
2551       if (!line || !*line || (first && *request == ','))
2552         {
2553           /* Process the input.  */
2554           xfree (response);
2555           response = NULL;
2556           if (request && *request == ',')
2557             {
2558               response = process_meta_commands (request+1);
2559             }
2560           else if (request)
2561             {
2562               response = process_request (request);
2563             }
2564           xfree (request);
2565           request = NULL;
2566
2567           if (response)
2568             {
2569               if (opt_interactive)
2570                 {
2571                   char *msg = get_help_msg (response);
2572                   if (msg)
2573                     {
2574                       xfree (response);
2575                       response = msg;
2576                     }
2577                 }
2578
2579               es_fputs ("===> ", es_stderr);
2580               es_fflush (es_stderr);
2581               for (p=response; *p; p++)
2582                 {
2583                   if (*p == '\n')
2584                     {
2585                       es_fflush (es_stdout);
2586                       es_fputs ("\n===> ", es_stderr);
2587                       es_fflush (es_stderr);
2588                     }
2589                   else
2590                     es_putc (*p, es_stdout);
2591                 }
2592               es_fflush (es_stdout);
2593               es_fputs ("\n", es_stderr);
2594             }
2595         }
2596     }
2597   while (line);
2598
2599   xfree (request);
2600   xfree (response);
2601   xfree (line);
2602 }
2603
2604
2605 /* Read and process a single request.  */
2606 static void
2607 read_and_process_single_request (void)
2608 {
2609   char *line = NULL;
2610   char *request = NULL;
2611   char *response = NULL;
2612   size_t n;
2613
2614   for (;;)
2615     {
2616       xfree (line);
2617       line = get_line ();
2618       if (line && *line)
2619         request = (request? xstrconcat (request, "\n", line, NULL)
2620                    /**/   : xstrdup (line));
2621       if (!line)
2622         {
2623           if (request)
2624             {
2625               xfree (response);
2626               response = process_request (request);
2627               if (response)
2628                 {
2629                   es_fputs (response, es_stdout);
2630                   if ((n = strlen (response)) && response[n-1] != '\n')
2631                     es_fputc ('\n', es_stdout);
2632                 }
2633               es_fflush (es_stdout);
2634             }
2635           break;
2636         }
2637     }
2638
2639   xfree (response);
2640   xfree (request);
2641   xfree (line);
2642 }
2643
2644
2645 /* The Native Messaging processing loop.  */
2646 static void
2647 native_messaging_repl (void)
2648 {
2649   gpg_error_t err;
2650   uint32_t nrequest, nresponse;
2651   char *request = NULL;
2652   char *response = NULL;
2653   size_t n;
2654
2655   /* Due to the length octets we need to switch the I/O stream into
2656    * binary mode.  */
2657   es_set_binary (es_stdin);
2658   es_set_binary (es_stdout);
2659   es_setbuf (es_stdin, NULL);  /* stdin needs to be unbuffered! */
2660
2661   for (;;)
2662     {
2663       /* Read length.  Note that the protocol uses native endianess.
2664        * Is it allowed to call such a thing a well thought out
2665        * protocol?  */
2666       if (es_read (es_stdin, &nrequest, sizeof nrequest, &n))
2667         {
2668           err = gpg_error_from_syserror ();
2669           log_error ("error reading request header: %s\n", gpg_strerror (err));
2670           break;
2671         }
2672       if (!n)
2673         break;  /* EOF */
2674       if (n != sizeof nrequest)
2675         {
2676           log_error ("error reading request header: short read\n");
2677           break;
2678         }
2679       if (nrequest > MAX_REQUEST_SIZE)
2680         {
2681           log_error ("error reading request: request too long (%zu MiB)\n",
2682                      (size_t)nrequest / (1024*1024));
2683           /* Fixme: Shall we read the request to the bit bucket and
2684            * return an error reponse or just return an error reponse
2685            * and terminate?  Needs some testing.  */
2686           break;
2687         }
2688
2689       /* Read request.  */
2690       request = xtrymalloc (nrequest);
2691       if (!request)
2692         {
2693           err = gpg_error_from_syserror ();
2694           log_error ("error reading request: Not enough memory for %zu MiB)\n",
2695                      (size_t)nrequest / (1024*1024));
2696           /* FIXME: See comment above.  */
2697           break;
2698         }
2699       if (es_read (es_stdin, request, nrequest, &n))
2700         {
2701           err = gpg_error_from_syserror ();
2702           log_error ("error reading request: %s\n", gpg_strerror (err));
2703           break;
2704         }
2705       if (n != nrequest)
2706         {
2707           /* That is a protocol violation.  */
2708           xfree (response);
2709           response = error_object_string ("Invalid request:"
2710                                           " short read (%zu of %zu bytes)\n",
2711                                           n, (size_t)nrequest);
2712         }
2713       else /* Process request  */
2714         {
2715           if (opt_debug)
2716             log_debug ("request='%s'\n", request);
2717           xfree (response);
2718           response = process_request (request);
2719           if (opt_debug)
2720             log_debug ("response='%s'\n", response);
2721         }
2722       nresponse = strlen (response);
2723
2724       /* Write response */
2725       if (es_write (es_stdout, &nresponse, sizeof nresponse, &n))
2726         {
2727           err = gpg_error_from_syserror ();
2728           log_error ("error writing request header: %s\n", gpg_strerror (err));
2729           break;
2730         }
2731       if (n != sizeof nrequest)
2732         {
2733           log_error ("error writing request header: short write\n");
2734           break;
2735         }
2736       if (es_write (es_stdout, response, nresponse, &n))
2737         {
2738           err = gpg_error_from_syserror ();
2739           log_error ("error writing request: %s\n", gpg_strerror (err));
2740           break;
2741         }
2742       if (n != nresponse)
2743         {
2744           log_error ("error writing request: short write\n");
2745           break;
2746         }
2747       if (es_fflush (es_stdout) || es_ferror (es_stdout))
2748         {
2749           err = gpg_error_from_syserror ();
2750           log_error ("error writing request: %s\n", gpg_strerror (err));
2751           break;
2752         }
2753     }
2754
2755   xfree (response);
2756   xfree (request);
2757 }
2758
2759
2760 \f
2761 static const char *
2762 my_strusage( int level )
2763 {
2764   const char *p;
2765
2766   switch (level)
2767     {
2768     case  9: p = "LGPL-2.1-or-later"; break;
2769     case 11: p = "gpgme-json"; break;
2770     case 13: p = PACKAGE_VERSION; break;
2771     case 14: p = "Copyright (C) 2018 g10 Code GmbH"; break;
2772     case 19: p = "Please report bugs to <" PACKAGE_BUGREPORT ">.\n"; break;
2773     case 1:
2774     case 40:
2775       p = "Usage: gpgme-json [OPTIONS]";
2776       break;
2777     case 41:
2778       p = "Native messaging based GPGME operations.\n";
2779       break;
2780     case 42:
2781       p = "1"; /* Flag print 40 as part of 41. */
2782       break;
2783     default: p = NULL; break;
2784     }
2785   return p;
2786 }
2787
2788 int
2789 main (int argc, char *argv[])
2790 {
2791 #if GPGRT_VERSION_NUMBER < 0x011d00 /* 1.29 */
2792
2793   fprintf (stderr, "WARNING: Old libgpg-error - using limited mode\n");
2794   native_messaging_repl ();
2795
2796 #else /* This is a modern libgp-error.  */
2797
2798   enum { CMD_DEFAULT     = 0,
2799          CMD_INTERACTIVE = 'i',
2800          CMD_SINGLE      = 's',
2801          CMD_LIBVERSION  = 501,
2802   } cmd = CMD_DEFAULT;
2803   enum {
2804     OPT_DEBUG = 600
2805   };
2806
2807   static gpgrt_opt_t opts[] = {
2808     ARGPARSE_c  (CMD_INTERACTIVE, "interactive", "Interactive REPL"),
2809     ARGPARSE_c  (CMD_SINGLE,      "single",      "Single request mode"),
2810     ARGPARSE_c  (CMD_LIBVERSION,  "lib-version", "Show library version"),
2811     ARGPARSE_s_n(OPT_DEBUG,       "debug",       "Flyswatter"),
2812
2813     ARGPARSE_end()
2814   };
2815   gpgrt_argparse_t pargs = { &argc, &argv};
2816
2817   gpgrt_set_strusage (my_strusage);
2818
2819 #ifdef HAVE_SETLOCALE
2820   setlocale (LC_ALL, "");
2821 #endif
2822   gpgme_check_version (NULL);
2823 #ifdef LC_CTYPE
2824   gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
2825 #endif
2826 #ifdef LC_MESSAGES
2827   gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
2828 #endif
2829
2830   while (gpgrt_argparse (NULL, &pargs, opts))
2831     {
2832       switch (pargs.r_opt)
2833         {
2834         case CMD_INTERACTIVE:
2835           opt_interactive = 1;
2836           /* Fall trough.  */
2837         case CMD_SINGLE:
2838         case CMD_LIBVERSION:
2839           cmd = pargs.r_opt;
2840           break;
2841
2842         case OPT_DEBUG: opt_debug = 1; break;
2843
2844         default:
2845           pargs.err = ARGPARSE_PRINT_WARNING;
2846           break;
2847         }
2848     }
2849   gpgrt_argparse (NULL, &pargs, NULL);
2850
2851   if (!opt_debug)
2852     {
2853       const char *s = getenv ("GPGME_JSON_DEBUG");
2854       if (s && atoi (s) > 0)
2855         opt_debug = 1;
2856     }
2857
2858   if (opt_debug)
2859     {
2860       const char *home = getenv ("HOME");
2861       char *file = xstrconcat ("socket://",
2862                                home? home:"/tmp",
2863                                "/.gnupg/S.gpgme-json.log", NULL);
2864       log_set_file (file);
2865       xfree (file);
2866     }
2867
2868   if (opt_debug)
2869     { int i;
2870       for (i=0; argv[i]; i++)
2871         log_debug ("argv[%d]='%s'\n", i, argv[i]);
2872     }
2873
2874   switch (cmd)
2875     {
2876     case CMD_DEFAULT:
2877       native_messaging_repl ();
2878       break;
2879
2880     case CMD_SINGLE:
2881       read_and_process_single_request ();
2882       break;
2883
2884     case CMD_INTERACTIVE:
2885       interactive_repl ();
2886       break;
2887
2888     case CMD_LIBVERSION:
2889       printf ("Version from header: %s (0x%06x)\n",
2890               GPGME_VERSION, GPGME_VERSION_NUMBER);
2891       printf ("Version from binary: %s\n", gpgme_check_version (NULL));
2892       printf ("Copyright blurb ...:%s\n", gpgme_check_version ("\x01\x01"));
2893       break;
2894     }
2895
2896   if (opt_debug)
2897     log_debug ("ready");
2898
2899 #endif /* This is a modern libgp-error.  */
2900   return 0;
2901 }
2902 #endif /* libgpg-error >= 1.28 */