json: Implement op_export
[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   gpgme_set_keylist_mode (ctx, mode);
1970
1971   err = gpgme_op_keylist_ext_start (ctx, (const char **) patterns,
1972                                     (mode & GPGME_KEYLIST_MODE_WITH_SECRET),
1973                                     0);
1974   if (err)
1975     {
1976       gpg_error_object (result, err, "Error listing keys: %s",
1977                         gpg_strerror (err));
1978       goto leave;
1979     }
1980
1981   while (!(err = gpgme_op_keylist_next (ctx, &key)))
1982     {
1983       cJSON_AddItemToArray (keyarray, key_to_json (key));
1984       gpgme_key_unref (key);
1985     }
1986   err = 0;
1987
1988   if (!cJSON_AddItemToObject (result, "keys", keyarray))
1989     {
1990       err = gpg_error_from_syserror ();
1991       goto leave;
1992     }
1993
1994  leave:
1995   xfree_array (patterns);
1996   if (err)
1997     {
1998       cJSON_Delete (keyarray);
1999     }
2000   return err;
2001 }
2002 \f
2003 static const char hlp_import[] =
2004   "op:     \"import\"\n"
2005   "data:   The data to import.\n"
2006   "\n"
2007   "Optional parameters:\n"
2008   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
2009   "\n"
2010   "Optional boolean flags (default is false):\n"
2011   "base64:        Input data is base64 encoded.\n"
2012   "\n"
2013   "Response on success:\n"
2014   "result: The import result.\n"
2015   "  Number values:\n"
2016   "   considered\n"
2017   "   no_user_id\n"
2018   "   imported\n"
2019   "   imported_rsa\n"
2020   "   unchanged\n"
2021   "   new_user_ids\n"
2022   "   new_sub_keys\n"
2023   "   new_signatures\n"
2024   "   new_revocations\n"
2025   "   secret_read\n"
2026   "   secret_imported\n"
2027   "   secret_unchanged\n"
2028   "   skipped_new_keys\n"
2029   "   not_imported\n"
2030   "   skipped_v3_keys\n"
2031   "  Array values:\n"
2032   "   imports: List of keys for which an import was attempted\n"
2033   "    String values:\n"
2034   "     fingerprint\n"
2035   "     error_string\n"
2036   "    Number values:\n"
2037   "     error_code\n"
2038   "     status\n";
2039 static gpg_error_t
2040 op_import (cjson_t request, cjson_t result)
2041 {
2042   gpg_error_t err;
2043   gpgme_ctx_t ctx = NULL;
2044   gpgme_data_t input = NULL;
2045   gpgme_import_result_t import_result;
2046   gpgme_protocol_t protocol;
2047
2048   if ((err = get_protocol (request, &protocol)))
2049     goto leave;
2050   ctx = get_context (protocol);
2051
2052   if ((err = get_string_data (request, result, "data", &input)))
2053       goto leave;
2054
2055   /* Import.  */
2056   err = gpgme_op_import (ctx, input);
2057   import_result = gpgme_op_import_result (ctx);
2058   if (err)
2059     {
2060       gpg_error_object (result, err, "Import failed: %s",
2061                         gpg_strerror (err));
2062       goto leave;
2063     }
2064   gpgme_data_release (input);
2065   input = NULL;
2066
2067   xjson_AddItemToObject (result, "result",
2068                          import_result_to_json (import_result));
2069
2070  leave:
2071   release_context (ctx);
2072   gpgme_data_release (input);
2073   return err;
2074 }
2075
2076
2077 static const char hlp_export[] =
2078   "op:     \"export\"\n"
2079   "\n"
2080   "Optional parameters:\n"
2081   "keys:          Array of strings or fingerprints to lookup\n"
2082   "               For a single key a String may be used instead of an array.\n"
2083   "               default exports all keys.\n"
2084   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
2085   "chunksize:     Max number of bytes in the resulting \"data\".\n"
2086   "\n"
2087   "Optional boolean flags (default is false):\n"
2088   "armor:         Request output in armored format.\n"
2089   "extern:        Add EXPORT_MODE_EXTERN.\n"
2090   "minimal:       Add EXPORT_MODE_MINIMAL.\n"
2091   "secret:        Add EXPORT_MODE_SECRET. (not implemented)\n"
2092   "raw:           Add EXPORT_MODE_RAW.\n"
2093   "pkcs12:        Add EXPORT_MODE_PKCS12.\n"
2094   "\n"
2095   "Response on success:\n"
2096   "type:   \"keys\"\n"
2097   "data:   Unless armor mode is used a Base64 encoded binary.\n"
2098   "        In armor mode a string with an armored\n"
2099   "        OpenPGP or a PEM / PKCS12 key.\n"
2100   "base64: Boolean indicating whether data is base64 encoded.\n"
2101   "more:   Optional boolean indicating that \"getmore\" is required.";
2102 static gpg_error_t
2103 op_export (cjson_t request, cjson_t result)
2104 {
2105   gpg_error_t err;
2106   gpgme_ctx_t ctx = NULL;
2107   gpgme_protocol_t protocol;
2108   size_t chunksize;
2109   char **patterns = NULL;
2110   int abool;
2111   gpgme_export_mode_t mode = 0;
2112   gpgme_data_t output = NULL;
2113
2114   if ((err = get_protocol (request, &protocol)))
2115     goto leave;
2116   ctx = get_context (protocol);
2117   if ((err = get_chunksize (request, &chunksize)))
2118     goto leave;
2119
2120   if ((err = get_boolean_flag (request, "armor", 0, &abool)))
2121     goto leave;
2122   gpgme_set_armor (ctx, abool);
2123
2124   /* Handle the various export mode bools. */
2125   if ((err = get_boolean_flag (request, "secret", 0, &abool)))
2126     goto leave;
2127   if (abool)
2128     mode |= GPGME_EXPORT_MODE_SECRET;
2129
2130   if ((err = get_boolean_flag (request, "extern", 0, &abool)))
2131     goto leave;
2132   if (abool)
2133     mode |= GPGME_EXPORT_MODE_EXTERN;
2134
2135   if ((err = get_boolean_flag (request, "minimal", 0, &abool)))
2136     goto leave;
2137   if (abool)
2138     mode |= GPGME_EXPORT_MODE_MINIMAL;
2139
2140   if ((err = get_boolean_flag (request, "raw", 0, &abool)))
2141     goto leave;
2142   if (abool)
2143     mode |= GPGME_EXPORT_MODE_RAW;
2144
2145   if ((err = get_boolean_flag (request, "pkcs12", 0, &abool)))
2146     goto leave;
2147   if (abool)
2148     mode |= GPGME_EXPORT_MODE_PKCS12;
2149
2150   /* Get the export patterns.  */
2151   patterns = create_keylist_patterns (request);
2152
2153   /* Create an output data object.  */
2154   err = gpgme_data_new (&output);
2155   if (err)
2156     {
2157       gpg_error_object (result, err, "Error creating output data object: %s",
2158                         gpg_strerror (err));
2159       goto leave;
2160     }
2161
2162   err = gpgme_op_export_ext (ctx, (const char **) patterns,
2163                              mode, output);
2164   if (err)
2165     {
2166       gpg_error_object (result, err, "Error exporting keys: %s",
2167                         gpg_strerror (err));
2168       goto leave;
2169     }
2170
2171   /* We need to base64 if armoring has not been requested.  */
2172   err = make_data_object (result, output, chunksize,
2173                           "keys", !gpgme_get_armor (ctx));
2174   output = NULL;
2175
2176 leave:
2177   xfree_array (patterns);
2178   release_context (ctx);
2179   gpgme_data_release (output);
2180
2181   return err;
2182 }
2183 \f
2184 static const char hlp_getmore[] =
2185   "op:     \"getmore\"\n"
2186   "\n"
2187   "Optional parameters:\n"
2188   "chunksize:  Max number of bytes in the \"data\" object.\n"
2189   "\n"
2190   "Response on success:\n"
2191   "type:       Type of the pending data\n"
2192   "data:       The next chunk of data\n"
2193   "base64:     Boolean indicating whether data is base64 encoded\n"
2194   "more:       Optional boolean requesting another \"getmore\".";
2195 static gpg_error_t
2196 op_getmore (cjson_t request, cjson_t result)
2197 {
2198   gpg_error_t err;
2199   int c;
2200   size_t n;
2201   size_t chunksize;
2202
2203   if ((err = get_chunksize (request, &chunksize)))
2204     goto leave;
2205
2206   /* Adjust the chunksize if we need to do base64 conversion.  */
2207   if (pending_data.base64)
2208     chunksize = (chunksize / 4) * 3;
2209
2210   /* Do we have anything pending?  */
2211   if (!pending_data.buffer)
2212     {
2213       err = gpg_error (GPG_ERR_NO_DATA);
2214       gpg_error_object (result, err, "Operation not possible: %s",
2215                         gpg_strerror (err));
2216       goto leave;
2217     }
2218
2219   xjson_AddStringToObject (result, "type", pending_data.type);
2220   xjson_AddBoolToObject (result, "base64", pending_data.base64);
2221
2222   if (pending_data.written >= pending_data.length)
2223     {
2224       /* EOF reached.  This should not happen but we return an empty
2225        * string once in case of client errors.  */
2226       gpgme_free (pending_data.buffer);
2227       pending_data.buffer = NULL;
2228       xjson_AddBoolToObject (result, "more", 0);
2229       err = cjson_AddStringToObject (result, "data", "");
2230     }
2231   else
2232     {
2233       n = pending_data.length - pending_data.written;
2234       if (n > chunksize)
2235         {
2236           n = chunksize;
2237           xjson_AddBoolToObject (result, "more", 1);
2238         }
2239       else
2240         xjson_AddBoolToObject (result, "more", 0);
2241
2242       c = pending_data.buffer[pending_data.written + n];
2243       pending_data.buffer[pending_data.written + n] = 0;
2244       if (pending_data.base64)
2245         err = add_base64_to_object (result, "data",
2246                                     (pending_data.buffer
2247                                      + pending_data.written), n);
2248       else
2249         err = cjson_AddStringToObject (result, "data",
2250                                        (pending_data.buffer
2251                                         + pending_data.written));
2252       pending_data.buffer[pending_data.written + n] = c;
2253       if (!err)
2254         {
2255           pending_data.written += n;
2256           if (pending_data.written >= pending_data.length)
2257             {
2258               gpgme_free (pending_data.buffer);
2259               pending_data.buffer = NULL;
2260             }
2261         }
2262     }
2263
2264  leave:
2265   return err;
2266 }
2267
2268
2269 \f
2270 static const char hlp_help[] =
2271   "The tool expects a JSON object with the request and responds with\n"
2272   "another JSON object.  Even on error a JSON object is returned.  The\n"
2273   "property \"op\" is mandatory and its string value selects the\n"
2274   "operation; if the property \"help\" with the value \"true\" exists, the\n"
2275   "operation is not performned but a string with the documentation\n"
2276   "returned.  To list all operations it is allowed to leave out \"op\" in\n"
2277   "help mode.  Supported values for \"op\" are:\n\n"
2278   "  decrypt     Decrypt data.\n"
2279   "  encrypt     Encrypt data.\n"
2280   "  export      Export keys.\n"
2281   "  import      Import data.\n"
2282   "  keylist     List keys.\n"
2283   "  sign        Sign data.\n"
2284   "  verify      Verify data.\n"
2285   "  version     Get engine information.\n"
2286   "  getmore     Retrieve remaining data.\n"
2287   "  help        Help overview.";
2288 static gpg_error_t
2289 op_help (cjson_t request, cjson_t result)
2290 {
2291   cjson_t j_tmp;
2292   char *buffer = NULL;
2293   const char *msg;
2294
2295   j_tmp = cJSON_GetObjectItem (request, "interactive_help");
2296   if (opt_interactive && j_tmp && cjson_is_string (j_tmp))
2297     msg = buffer = xstrconcat (hlp_help, "\n", j_tmp->valuestring, NULL);
2298   else
2299     msg = hlp_help;
2300
2301   xjson_AddStringToObject (result, "type", "help");
2302   xjson_AddStringToObject (result, "msg", msg);
2303
2304   xfree (buffer);
2305   return 0;
2306 }
2307
2308
2309 \f
2310 /*
2311  * Dispatcher
2312  */
2313
2314 /* Process a request and return the response.  The response is a newly
2315  * allocated string or NULL in case of an error.  */
2316 static char *
2317 process_request (const char *request)
2318 {
2319   static struct {
2320     const char *op;
2321     gpg_error_t (*handler)(cjson_t request, cjson_t result);
2322     const char * const helpstr;
2323   } optbl[] = {
2324     { "encrypt", op_encrypt, hlp_encrypt },
2325     { "export",  op_export,  hlp_export },
2326     { "decrypt", op_decrypt, hlp_decrypt },
2327     { "keylist", op_keylist, hlp_keylist },
2328     { "import",  op_import,  hlp_import },
2329     { "sign",    op_sign,    hlp_sign },
2330     { "verify",  op_verify,  hlp_verify },
2331     { "version", op_version, hlp_version },
2332     { "getmore", op_getmore, hlp_getmore },
2333     { "help",    op_help,    hlp_help },
2334     { NULL }
2335   };
2336   size_t erroff;
2337   cjson_t json;
2338   cjson_t j_tmp, j_op;
2339   cjson_t response;
2340   int helpmode;
2341   const char *op;
2342   char *res;
2343   int idx;
2344
2345   response = xjson_CreateObject ();
2346
2347   json = cJSON_Parse (request, &erroff);
2348   if (!json)
2349     {
2350       log_string (GPGRT_LOGLVL_INFO, request);
2351       log_info ("invalid JSON object at offset %zu\n", erroff);
2352       error_object (response, "invalid JSON object at offset %zu\n", erroff);
2353       goto leave;
2354     }
2355
2356   j_tmp = cJSON_GetObjectItem (json, "help");
2357   helpmode = (j_tmp && cjson_is_true (j_tmp));
2358
2359   j_op = cJSON_GetObjectItem (json, "op");
2360   if (!j_op || !cjson_is_string (j_op))
2361     {
2362       if (!helpmode)
2363         {
2364           error_object (response, "Property \"op\" missing");
2365           goto leave;
2366         }
2367       op = "help";  /* Help summary.  */
2368     }
2369   else
2370     op = j_op->valuestring;
2371
2372   for (idx=0; optbl[idx].op; idx++)
2373     if (!strcmp (op, optbl[idx].op))
2374       break;
2375   if (optbl[idx].op)
2376     {
2377       if (helpmode && strcmp (op, "help"))
2378         {
2379           xjson_AddStringToObject (response, "type", "help");
2380           xjson_AddStringToObject (response, "op", op);
2381           xjson_AddStringToObject (response, "msg", optbl[idx].helpstr);
2382         }
2383       else
2384         {
2385           gpg_error_t err;
2386
2387           /* If this is not the "getmore" command and we have any
2388            * pending data release that data.  */
2389           if (pending_data.buffer && optbl[idx].handler != op_getmore)
2390             {
2391               gpgme_free (pending_data.buffer);
2392               pending_data.buffer = NULL;
2393             }
2394
2395           err = optbl[idx].handler (json, response);
2396           if (err)
2397             {
2398               if (!(j_tmp = cJSON_GetObjectItem (response, "type"))
2399                   || !cjson_is_string (j_tmp)
2400                   || strcmp (j_tmp->valuestring, "error"))
2401                 {
2402                   /* No error type response - provide a generic one.  */
2403                   gpg_error_object (response, err, "Operation failed: %s",
2404                                     gpg_strerror (err));
2405                 }
2406
2407               xjson_AddStringToObject (response, "op", op);
2408             }
2409         }
2410     }
2411   else  /* Operation not supported.  */
2412     {
2413       error_object (response, "Unknown operation '%s'", op);
2414       xjson_AddStringToObject (response, "op", op);
2415     }
2416
2417  leave:
2418   cJSON_Delete (json);
2419   if (opt_interactive)
2420     res = cJSON_Print (response);
2421   else
2422     res = cJSON_PrintUnformatted (response);
2423   if (!res)
2424     log_error ("Printing JSON data failed\n");
2425   cJSON_Delete (response);
2426   return res;
2427 }
2428
2429
2430 \f
2431 /*
2432  *  Driver code
2433  */
2434
2435 static char *
2436 get_file (const char *fname)
2437 {
2438   gpg_error_t err;
2439   estream_t fp;
2440   struct stat st;
2441   char *buf;
2442   size_t buflen;
2443
2444   fp = es_fopen (fname, "r");
2445   if (!fp)
2446     {
2447       err = gpg_error_from_syserror ();
2448       log_error ("can't open '%s': %s\n", fname, gpg_strerror (err));
2449       return NULL;
2450     }
2451
2452   if (fstat (es_fileno(fp), &st))
2453     {
2454       err = gpg_error_from_syserror ();
2455       log_error ("can't stat '%s': %s\n", fname, gpg_strerror (err));
2456       es_fclose (fp);
2457       return NULL;
2458     }
2459
2460   buflen = st.st_size;
2461   buf = xmalloc (buflen+1);
2462   if (es_fread (buf, buflen, 1, fp) != 1)
2463     {
2464       err = gpg_error_from_syserror ();
2465       log_error ("error reading '%s': %s\n", fname, gpg_strerror (err));
2466       es_fclose (fp);
2467       xfree (buf);
2468       return NULL;
2469     }
2470   buf[buflen] = 0;
2471   es_fclose (fp);
2472
2473   return buf;
2474 }
2475
2476
2477 /* Return a malloced line or NULL on EOF.  Terminate on read
2478  * error.  */
2479 static char *
2480 get_line (void)
2481 {
2482   char *line = NULL;
2483   size_t linesize = 0;
2484   gpg_error_t err;
2485   size_t maxlength = 2048;
2486   int n;
2487   const char *s;
2488   char *p;
2489
2490  again:
2491   n = es_read_line (es_stdin, &line, &linesize, &maxlength);
2492   if (n < 0)
2493     {
2494       err = gpg_error_from_syserror ();
2495       log_error ("error reading line: %s\n", gpg_strerror (err));
2496       exit (1);
2497     }
2498   if (!n)
2499     {
2500       xfree (line);
2501       line = NULL;
2502       return NULL;  /* EOF */
2503     }
2504   if (!maxlength)
2505     {
2506       log_info ("line too long - skipped\n");
2507       goto again;
2508     }
2509   if (memchr (line, 0, n))
2510     log_info ("warning: line shortened due to embedded Nul character\n");
2511
2512   if (line[n-1] == '\n')
2513     line[n-1] = 0;
2514
2515   /* Trim leading spaces.  */
2516   for (s=line; spacep (s); s++)
2517     ;
2518   if (s != line)
2519     {
2520       for (p=line; *s;)
2521         *p++ = *s++;
2522       *p = 0;
2523       n = p - line;
2524     }
2525
2526   return line;
2527 }
2528
2529
2530 /* Process meta commands used with the standard REPL.  */
2531 static char *
2532 process_meta_commands (const char *request)
2533 {
2534   char *result = NULL;
2535
2536   while (spacep (request))
2537     request++;
2538
2539   if (!strncmp (request, "help", 4) && (spacep (request+4) || !request[4]))
2540     {
2541       if (request[4])
2542         {
2543           char *buf = xstrconcat ("{ \"help\":true, \"op\":\"", request+5,
2544                                   "\" }", NULL);
2545           result = process_request (buf);
2546           xfree (buf);
2547         }
2548       else
2549         result = process_request ("{ \"op\": \"help\","
2550                                   " \"interactive_help\": "
2551                                   "\"\\nMeta commands:\\n"
2552                                   "  ,read FNAME Process data from FILE\\n"
2553                                   "  ,help CMD   Print help for a command\\n"
2554                                   "  ,quit       Terminate process\""
2555                                   "}");
2556     }
2557   else if (!strncmp (request, "quit", 4) && (spacep (request+4) || !request[4]))
2558     exit (0);
2559   else if (!strncmp (request, "read", 4) && (spacep (request+4) || !request[4]))
2560     {
2561       if (!request[4])
2562         log_info ("usage: ,read FILENAME\n");
2563       else
2564         {
2565           char *buffer = get_file (request + 5);
2566           if (buffer)
2567             {
2568               result = process_request (buffer);
2569               xfree (buffer);
2570             }
2571         }
2572     }
2573   else
2574     log_info ("invalid meta command\n");
2575
2576   return result;
2577 }
2578
2579
2580 /* If STRING has a help response, return the MSG property in a human
2581  * readable format.  */
2582 static char *
2583 get_help_msg (const char *string)
2584 {
2585   cjson_t json, j_type, j_msg;
2586   const char *msg;
2587   char *buffer = NULL;
2588   char *p;
2589
2590   json = cJSON_Parse (string, NULL);
2591   if (json)
2592     {
2593       j_type = cJSON_GetObjectItem (json, "type");
2594       if (j_type && cjson_is_string (j_type)
2595           && !strcmp (j_type->valuestring, "help"))
2596         {
2597           j_msg = cJSON_GetObjectItem (json, "msg");
2598           if (j_msg || cjson_is_string (j_msg))
2599             {
2600               msg = j_msg->valuestring;
2601               buffer = malloc (strlen (msg)+1);
2602               if (buffer)
2603                 {
2604                   for (p=buffer; *msg; msg++)
2605                     {
2606                       if (*msg == '\\' && msg[1] == '\n')
2607                         *p++ = '\n';
2608                       else
2609                         *p++ = *msg;
2610                     }
2611                   *p = 0;
2612                 }
2613             }
2614         }
2615       cJSON_Delete (json);
2616     }
2617   return buffer;
2618 }
2619
2620
2621 /* An interactive standard REPL.  */
2622 static void
2623 interactive_repl (void)
2624 {
2625   char *line = NULL;
2626   char *request = NULL;
2627   char *response = NULL;
2628   char *p;
2629   int first;
2630
2631   es_setvbuf (es_stdin, NULL, _IONBF, 0);
2632 #if GPGRT_VERSION_NUMBER >= 0x011d00 /* 1.29 */
2633   es_fprintf (es_stderr, "%s %s ready (enter \",help\" for help)\n",
2634               gpgrt_strusage (11), gpgrt_strusage (13));
2635 #endif
2636   do
2637     {
2638       es_fputs ("> ", es_stderr);
2639       es_fflush (es_stderr);
2640       es_fflush (es_stdout);
2641       xfree (line);
2642       line = get_line ();
2643       es_fflush (es_stderr);
2644       es_fflush (es_stdout);
2645
2646       first = !request;
2647       if (line && *line)
2648         {
2649           if (!request)
2650             request = xstrdup (line);
2651           else
2652             request = xstrconcat (request, "\n", line, NULL);
2653         }
2654
2655       if (!line)
2656         es_fputs ("\n", es_stderr);
2657
2658       if (!line || !*line || (first && *request == ','))
2659         {
2660           /* Process the input.  */
2661           xfree (response);
2662           response = NULL;
2663           if (request && *request == ',')
2664             {
2665               response = process_meta_commands (request+1);
2666             }
2667           else if (request)
2668             {
2669               response = process_request (request);
2670             }
2671           xfree (request);
2672           request = NULL;
2673
2674           if (response)
2675             {
2676               if (opt_interactive)
2677                 {
2678                   char *msg = get_help_msg (response);
2679                   if (msg)
2680                     {
2681                       xfree (response);
2682                       response = msg;
2683                     }
2684                 }
2685
2686               es_fputs ("===> ", es_stderr);
2687               es_fflush (es_stderr);
2688               for (p=response; *p; p++)
2689                 {
2690                   if (*p == '\n')
2691                     {
2692                       es_fflush (es_stdout);
2693                       es_fputs ("\n===> ", es_stderr);
2694                       es_fflush (es_stderr);
2695                     }
2696                   else
2697                     es_putc (*p, es_stdout);
2698                 }
2699               es_fflush (es_stdout);
2700               es_fputs ("\n", es_stderr);
2701             }
2702         }
2703     }
2704   while (line);
2705
2706   xfree (request);
2707   xfree (response);
2708   xfree (line);
2709 }
2710
2711
2712 /* Read and process a single request.  */
2713 static void
2714 read_and_process_single_request (void)
2715 {
2716   char *line = NULL;
2717   char *request = NULL;
2718   char *response = NULL;
2719   size_t n;
2720
2721   for (;;)
2722     {
2723       xfree (line);
2724       line = get_line ();
2725       if (line && *line)
2726         request = (request? xstrconcat (request, "\n", line, NULL)
2727                    /**/   : xstrdup (line));
2728       if (!line)
2729         {
2730           if (request)
2731             {
2732               xfree (response);
2733               response = process_request (request);
2734               if (response)
2735                 {
2736                   es_fputs (response, es_stdout);
2737                   if ((n = strlen (response)) && response[n-1] != '\n')
2738                     es_fputc ('\n', es_stdout);
2739                 }
2740               es_fflush (es_stdout);
2741             }
2742           break;
2743         }
2744     }
2745
2746   xfree (response);
2747   xfree (request);
2748   xfree (line);
2749 }
2750
2751
2752 /* The Native Messaging processing loop.  */
2753 static void
2754 native_messaging_repl (void)
2755 {
2756   gpg_error_t err;
2757   uint32_t nrequest, nresponse;
2758   char *request = NULL;
2759   char *response = NULL;
2760   size_t n;
2761
2762   /* Due to the length octets we need to switch the I/O stream into
2763    * binary mode.  */
2764   es_set_binary (es_stdin);
2765   es_set_binary (es_stdout);
2766   es_setbuf (es_stdin, NULL);  /* stdin needs to be unbuffered! */
2767
2768   for (;;)
2769     {
2770       /* Read length.  Note that the protocol uses native endianess.
2771        * Is it allowed to call such a thing a well thought out
2772        * protocol?  */
2773       if (es_read (es_stdin, &nrequest, sizeof nrequest, &n))
2774         {
2775           err = gpg_error_from_syserror ();
2776           log_error ("error reading request header: %s\n", gpg_strerror (err));
2777           break;
2778         }
2779       if (!n)
2780         break;  /* EOF */
2781       if (n != sizeof nrequest)
2782         {
2783           log_error ("error reading request header: short read\n");
2784           break;
2785         }
2786       if (nrequest > MAX_REQUEST_SIZE)
2787         {
2788           log_error ("error reading request: request too long (%zu MiB)\n",
2789                      (size_t)nrequest / (1024*1024));
2790           /* Fixme: Shall we read the request to the bit bucket and
2791            * return an error reponse or just return an error reponse
2792            * and terminate?  Needs some testing.  */
2793           break;
2794         }
2795
2796       /* Read request.  */
2797       request = xtrymalloc (nrequest);
2798       if (!request)
2799         {
2800           err = gpg_error_from_syserror ();
2801           log_error ("error reading request: Not enough memory for %zu MiB)\n",
2802                      (size_t)nrequest / (1024*1024));
2803           /* FIXME: See comment above.  */
2804           break;
2805         }
2806       if (es_read (es_stdin, request, nrequest, &n))
2807         {
2808           err = gpg_error_from_syserror ();
2809           log_error ("error reading request: %s\n", gpg_strerror (err));
2810           break;
2811         }
2812       if (n != nrequest)
2813         {
2814           /* That is a protocol violation.  */
2815           xfree (response);
2816           response = error_object_string ("Invalid request:"
2817                                           " short read (%zu of %zu bytes)\n",
2818                                           n, (size_t)nrequest);
2819         }
2820       else /* Process request  */
2821         {
2822           if (opt_debug)
2823             log_debug ("request='%s'\n", request);
2824           xfree (response);
2825           response = process_request (request);
2826           if (opt_debug)
2827             log_debug ("response='%s'\n", response);
2828         }
2829       nresponse = strlen (response);
2830
2831       /* Write response */
2832       if (es_write (es_stdout, &nresponse, sizeof nresponse, &n))
2833         {
2834           err = gpg_error_from_syserror ();
2835           log_error ("error writing request header: %s\n", gpg_strerror (err));
2836           break;
2837         }
2838       if (n != sizeof nrequest)
2839         {
2840           log_error ("error writing request header: short write\n");
2841           break;
2842         }
2843       if (es_write (es_stdout, response, nresponse, &n))
2844         {
2845           err = gpg_error_from_syserror ();
2846           log_error ("error writing request: %s\n", gpg_strerror (err));
2847           break;
2848         }
2849       if (n != nresponse)
2850         {
2851           log_error ("error writing request: short write\n");
2852           break;
2853         }
2854       if (es_fflush (es_stdout) || es_ferror (es_stdout))
2855         {
2856           err = gpg_error_from_syserror ();
2857           log_error ("error writing request: %s\n", gpg_strerror (err));
2858           break;
2859         }
2860     }
2861
2862   xfree (response);
2863   xfree (request);
2864 }
2865
2866
2867 \f
2868 static const char *
2869 my_strusage( int level )
2870 {
2871   const char *p;
2872
2873   switch (level)
2874     {
2875     case  9: p = "LGPL-2.1-or-later"; break;
2876     case 11: p = "gpgme-json"; break;
2877     case 13: p = PACKAGE_VERSION; break;
2878     case 14: p = "Copyright (C) 2018 g10 Code GmbH"; break;
2879     case 19: p = "Please report bugs to <" PACKAGE_BUGREPORT ">.\n"; break;
2880     case 1:
2881     case 40:
2882       p = "Usage: gpgme-json [OPTIONS]";
2883       break;
2884     case 41:
2885       p = "Native messaging based GPGME operations.\n";
2886       break;
2887     case 42:
2888       p = "1"; /* Flag print 40 as part of 41. */
2889       break;
2890     default: p = NULL; break;
2891     }
2892   return p;
2893 }
2894
2895 int
2896 main (int argc, char *argv[])
2897 {
2898 #if GPGRT_VERSION_NUMBER < 0x011d00 /* 1.29 */
2899
2900   fprintf (stderr, "WARNING: Old libgpg-error - using limited mode\n");
2901   native_messaging_repl ();
2902
2903 #else /* This is a modern libgp-error.  */
2904
2905   enum { CMD_DEFAULT     = 0,
2906          CMD_INTERACTIVE = 'i',
2907          CMD_SINGLE      = 's',
2908          CMD_LIBVERSION  = 501,
2909   } cmd = CMD_DEFAULT;
2910   enum {
2911     OPT_DEBUG = 600
2912   };
2913
2914   static gpgrt_opt_t opts[] = {
2915     ARGPARSE_c  (CMD_INTERACTIVE, "interactive", "Interactive REPL"),
2916     ARGPARSE_c  (CMD_SINGLE,      "single",      "Single request mode"),
2917     ARGPARSE_c  (CMD_LIBVERSION,  "lib-version", "Show library version"),
2918     ARGPARSE_s_n(OPT_DEBUG,       "debug",       "Flyswatter"),
2919
2920     ARGPARSE_end()
2921   };
2922   gpgrt_argparse_t pargs = { &argc, &argv};
2923
2924   gpgrt_set_strusage (my_strusage);
2925
2926 #ifdef HAVE_SETLOCALE
2927   setlocale (LC_ALL, "");
2928 #endif
2929   gpgme_check_version (NULL);
2930 #ifdef LC_CTYPE
2931   gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
2932 #endif
2933 #ifdef LC_MESSAGES
2934   gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
2935 #endif
2936
2937   while (gpgrt_argparse (NULL, &pargs, opts))
2938     {
2939       switch (pargs.r_opt)
2940         {
2941         case CMD_INTERACTIVE:
2942           opt_interactive = 1;
2943           /* Fall trough.  */
2944         case CMD_SINGLE:
2945         case CMD_LIBVERSION:
2946           cmd = pargs.r_opt;
2947           break;
2948
2949         case OPT_DEBUG: opt_debug = 1; break;
2950
2951         default:
2952           pargs.err = ARGPARSE_PRINT_WARNING;
2953           break;
2954         }
2955     }
2956   gpgrt_argparse (NULL, &pargs, NULL);
2957
2958   if (!opt_debug)
2959     {
2960       const char *s = getenv ("GPGME_JSON_DEBUG");
2961       if (s && atoi (s) > 0)
2962         opt_debug = 1;
2963     }
2964
2965   if (opt_debug)
2966     {
2967       const char *home = getenv ("HOME");
2968       char *file = xstrconcat ("socket://",
2969                                home? home:"/tmp",
2970                                "/.gnupg/S.gpgme-json.log", NULL);
2971       log_set_file (file);
2972       xfree (file);
2973     }
2974
2975   if (opt_debug)
2976     { int i;
2977       for (i=0; argv[i]; i++)
2978         log_debug ("argv[%d]='%s'\n", i, argv[i]);
2979     }
2980
2981   switch (cmd)
2982     {
2983     case CMD_DEFAULT:
2984       native_messaging_repl ();
2985       break;
2986
2987     case CMD_SINGLE:
2988       read_and_process_single_request ();
2989       break;
2990
2991     case CMD_INTERACTIVE:
2992       interactive_repl ();
2993       break;
2994
2995     case CMD_LIBVERSION:
2996       printf ("Version from header: %s (0x%06x)\n",
2997               GPGME_VERSION, GPGME_VERSION_NUMBER);
2998       printf ("Version from binary: %s\n", gpgme_check_version (NULL));
2999       printf ("Copyright blurb ...:%s\n", gpgme_check_version ("\x01\x01"));
3000       break;
3001     }
3002
3003   if (opt_debug)
3004     log_debug ("ready");
3005
3006 #endif /* This is a modern libgp-error.  */
3007   return 0;
3008 }
3009 #endif /* libgpg-error >= 1.28 */