core: Make the status-fd monitor work for all gpgsm commands.
[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) GPGRT_ATTR_PRINTF(2,0);
65 static cjson_t error_object (cjson_t json, const char *message,
66                             ...) GPGRT_ATTR_PRINTF(2,3);
67 static char *error_object_string (const char *message,
68                                   ...) GPGRT_ATTR_PRINTF(1,2);
69
70
71 /* True if interactive mode is active.  */
72 static int opt_interactive;
73 /* True is debug mode is active.  */
74 static int opt_debug;
75
76 /* Pending data to be returned by a getmore command.  */
77 static struct
78 {
79   char  *buffer;   /* Malloced data or NULL if not used.  */
80   size_t length;   /* Length of that data.  */
81   size_t written;  /* # of already written bytes from BUFFER.  */
82   const char *type;/* The "type" of the data.  */
83   int base64;      /* The "base64" flag of the data.  */
84 } pending_data;
85
86
87 /*
88  * Helper functions and macros
89  */
90
91 #define xtrymalloc(a)  gpgrt_malloc ((a))
92 #define xtrystrdup(a)  gpgrt_strdup ((a))
93 #define xmalloc(a) ({                           \
94       void *_r = gpgrt_malloc ((a));            \
95       if (!_r)                                  \
96         xoutofcore ("malloc");                  \
97       _r; })
98 #define xcalloc(a,b) ({                         \
99       void *_r = gpgrt_calloc ((a), (b));       \
100       if (!_r)                                  \
101         xoutofcore ("calloc");                  \
102       _r; })
103 #define xstrdup(a) ({                           \
104       char *_r = gpgrt_strdup ((a));            \
105       if (!_r)                                  \
106         xoutofcore ("strdup");                  \
107       _r; })
108 #define xstrconcat(a, ...) ({                           \
109       char *_r = gpgrt_strconcat ((a), __VA_ARGS__);    \
110       if (!_r)                                          \
111         xoutofcore ("strconcat");                       \
112       _r; })
113 #define xfree(a) gpgrt_free ((a))
114
115 #define spacep(p)   (*(p) == ' ' || *(p) == '\t')
116
117 #ifndef HAVE_STPCPY
118 static GPGRT_INLINE char *
119 _my_stpcpy (char *a, const char *b)
120 {
121   while (*b)
122     *a++ = *b++;
123   *a = 0;
124   return a;
125 }
126 #define stpcpy(a,b) _my_stpcpy ((a), (b))
127 #endif /*!HAVE_STPCPY*/
128
129
130
131 static void
132 xoutofcore (const char *type)
133 {
134   gpg_error_t err = gpg_error_from_syserror ();
135   log_error ("%s failed: %s\n", type, gpg_strerror (err));
136   exit (2);
137 }
138
139
140 /* Call cJSON_CreateObject but terminate in case of an error.  */
141 static cjson_t
142 xjson_CreateObject (void)
143 {
144   cjson_t json = cJSON_CreateObject ();
145   if (!json)
146     xoutofcore ("cJSON_CreateObject");
147   return json;
148 }
149
150
151 /* Wrapper around cJSON_AddStringToObject which returns an gpg-error
152  * code instead of the NULL or the new object.  */
153 static gpg_error_t
154 cjson_AddStringToObject (cjson_t object, const char *name, const char *string)
155 {
156   if (!cJSON_AddStringToObject (object, name, string))
157     return gpg_error_from_syserror ();
158   return 0;
159 }
160
161
162 /* Same as cjson_AddStringToObject but prints an error message and
163  * terminates the process.  */
164 static void
165 xjson_AddStringToObject (cjson_t object, const char *name, const char *string)
166 {
167   if (!cJSON_AddStringToObject (object, name, string))
168     xoutofcore ("cJSON_AddStringToObject");
169 }
170
171
172 /* Wrapper around cJSON_AddBoolToObject which terminates the process
173  * in case of an error.  */
174 static void
175 xjson_AddBoolToObject (cjson_t object, const char *name, int abool)
176 {
177   if (!cJSON_AddBoolToObject (object, name, abool))
178     xoutofcore ("cJSON_AddStringToObject");
179   return ;
180 }
181
182 /* This is similar to cJSON_AddStringToObject but takes (DATA,
183  * DATALEN) and adds it under NAME as a base 64 encoded string to
184  * OBJECT.  */
185 static gpg_error_t
186 add_base64_to_object (cjson_t object, const char *name,
187                       const void *data, size_t datalen)
188 {
189 #if GPGRT_VERSION_NUMBER < 0x011d00 /* 1.29 */
190   return gpg_error (GPG_ERR_NOT_SUPPORTED);
191 #else
192   gpg_err_code_t err;
193   estream_t fp = NULL;
194   gpgrt_b64state_t state = NULL;
195   cjson_t j_str = NULL;
196   void *buffer = NULL;
197
198   fp = es_fopenmem (0, "rwb");
199   if (!fp)
200     {
201       err = gpg_err_code_from_syserror ();
202       goto leave;
203     }
204   state = gpgrt_b64enc_start (fp, "");
205   if (!state)
206     {
207       err = gpg_err_code_from_syserror ();
208       goto leave;
209     }
210
211   err = gpgrt_b64enc_write (state, data, datalen);
212   if (err)
213     goto leave;
214
215   err = gpgrt_b64enc_finish (state);
216   state = NULL;
217   if (err)
218     return err;
219
220   es_fputc (0, fp);
221   if (es_fclose_snatch (fp, &buffer, NULL))
222     {
223       fp = NULL;
224       err = gpg_error_from_syserror ();
225       goto leave;
226     }
227   fp = NULL;
228
229   j_str = cJSON_CreateStringConvey (buffer);
230   if (!j_str)
231     {
232       err = gpg_error_from_syserror ();
233       goto leave;
234     }
235   buffer = NULL;
236
237   if (!cJSON_AddItemToObject (object, name, j_str))
238     {
239       err = gpg_error_from_syserror ();
240       cJSON_Delete (j_str);
241       j_str = NULL;
242       goto leave;
243     }
244   j_str = NULL;
245
246  leave:
247   xfree (buffer);
248   cJSON_Delete (j_str);
249   gpgrt_b64enc_finish (state);
250   es_fclose (fp);
251   return err;
252 #endif
253 }
254
255
256 /* Create a JSON error object.  If JSON is not NULL the error message
257  * is appended to that object.  An existing "type" item will be replaced. */
258 static cjson_t
259 error_object_v (cjson_t json, const char *message, va_list arg_ptr)
260 {
261   cjson_t response, j_tmp;
262   char *msg;
263
264   msg = gpgrt_vbsprintf (message, arg_ptr);
265   if (!msg)
266     xoutofcore ("error_object");
267
268   response = json? json : xjson_CreateObject ();
269
270   if (!(j_tmp = cJSON_GetObjectItem (response, "type")))
271     xjson_AddStringToObject (response, "type", "error");
272   else /* Replace existing "type".  */
273     {
274       j_tmp = cJSON_CreateString ("error");
275       if (!j_tmp)
276         xoutofcore ("cJSON_CreateString");
277       cJSON_ReplaceItemInObject (response, "type", j_tmp);
278      }
279   xjson_AddStringToObject (response, "msg", msg);
280
281   xfree (msg);
282   return response;
283 }
284
285
286 /* Call cJSON_Print but terminate in case of an error.  */
287 static char *
288 xjson_Print (cjson_t object)
289 {
290   char *buf;
291   buf = cJSON_Print (object);
292   if (!buf)
293     xoutofcore ("cJSON_Print");
294   return buf;
295 }
296
297
298 static cjson_t
299 error_object (cjson_t json, const char *message, ...)
300 {
301   cjson_t response;
302   va_list arg_ptr;
303
304   va_start (arg_ptr, message);
305   response = error_object_v (json, message, arg_ptr);
306   va_end (arg_ptr);
307   return response;
308 }
309
310
311 static char *
312 error_object_string (const char *message, ...)
313 {
314   cjson_t response;
315   va_list arg_ptr;
316   char *msg;
317
318   va_start (arg_ptr, message);
319   response = error_object_v (NULL, message, arg_ptr);
320   va_end (arg_ptr);
321
322   msg = xjson_Print (response);
323   cJSON_Delete (response);
324   return msg;
325 }
326
327
328 /* Get the boolean property NAME from the JSON object and store true
329  * or valse at R_VALUE.  If the name is unknown the value of DEF_VALUE
330  * is returned.  If the type of the value is not boolean,
331  * GPG_ERR_INV_VALUE is returned and R_VALUE set to DEF_VALUE.  */
332 static gpg_error_t
333 get_boolean_flag (cjson_t json, const char *name, int def_value, int *r_value)
334 {
335   cjson_t j_item;
336
337   j_item = cJSON_GetObjectItem (json, name);
338   if (!j_item)
339     *r_value = def_value;
340   else if (cjson_is_true (j_item))
341     *r_value = 1;
342   else if (cjson_is_false (j_item))
343     *r_value = 0;
344   else
345     {
346       *r_value = def_value;
347       return gpg_error (GPG_ERR_INV_VALUE);
348     }
349
350   return 0;
351 }
352
353
354 /* Get the boolean property PROTOCOL from the JSON object and store
355  * its value at R_PROTOCOL.  The default is OpenPGP.  */
356 static gpg_error_t
357 get_protocol (cjson_t json, gpgme_protocol_t *r_protocol)
358 {
359   cjson_t j_item;
360
361   *r_protocol = GPGME_PROTOCOL_OpenPGP;
362   j_item = cJSON_GetObjectItem (json, "protocol");
363   if (!j_item)
364     ;
365   else if (!cjson_is_string (j_item))
366     return gpg_error (GPG_ERR_INV_VALUE);
367   else if (!strcmp(j_item->valuestring, "openpgp"))
368     ;
369   else if (!strcmp(j_item->valuestring, "cms"))
370     *r_protocol = GPGME_PROTOCOL_CMS;
371   else
372     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
373
374   return 0;
375 }
376
377
378 /* Get the chunksize from JSON and store it at R_CHUNKSIZE.  */
379 static gpg_error_t
380 get_chunksize (cjson_t json, size_t *r_chunksize)
381 {
382   cjson_t j_item;
383
384   *r_chunksize = DEF_REPLY_CHUNK_SIZE;
385   j_item = cJSON_GetObjectItem (json, "chunksize");
386   if (!j_item)
387     ;
388   else if (!cjson_is_number (j_item))
389     return gpg_error (GPG_ERR_INV_VALUE);
390   else if ((size_t)j_item->valueint < MIN_REPLY_CHUNK_SIZE)
391     *r_chunksize = MIN_REPLY_CHUNK_SIZE;
392   else if ((size_t)j_item->valueint > MAX_REPLY_CHUNK_SIZE)
393     *r_chunksize = MAX_REPLY_CHUNK_SIZE;
394   else
395     *r_chunksize = (size_t)j_item->valueint;
396
397   return 0;
398 }
399
400
401 /* Extract the keys from the "keys" array in the JSON object.  On
402  * success a string with the keys identifiers is stored at R_KEYS.
403  * The keys in that string are LF delimited.  On failure an error code
404  * is returned.  */
405 static gpg_error_t
406 get_keys (cjson_t json, char **r_keystring)
407 {
408   cjson_t j_keys, j_item;
409   int i, nkeys;
410   char *p;
411   size_t length;
412
413   *r_keystring = NULL;
414
415   j_keys = cJSON_GetObjectItem (json, "keys");
416   if (!j_keys)
417     return gpg_error (GPG_ERR_NO_KEY);
418   if (!cjson_is_array (j_keys) && !cjson_is_string (j_keys))
419     return gpg_error (GPG_ERR_INV_VALUE);
420
421   /* Fixme: We should better use a membuf like thing.  */
422   length = 1; /* For the EOS.  */
423   if (cjson_is_string (j_keys))
424     {
425       nkeys = 1;
426       length += strlen (j_keys->valuestring);
427       if (strchr (j_keys->valuestring, '\n'))
428         return gpg_error (GPG_ERR_INV_USER_ID);
429     }
430   else
431     {
432       nkeys = cJSON_GetArraySize (j_keys);
433       if (!nkeys)
434         return gpg_error (GPG_ERR_NO_KEY);
435       for (i=0; i < nkeys; i++)
436         {
437           j_item = cJSON_GetArrayItem (j_keys, i);
438           if (!j_item || !cjson_is_string (j_item))
439             return gpg_error (GPG_ERR_INV_VALUE);
440           if (i)
441             length++; /* Space for delimiter. */
442           length += strlen (j_item->valuestring);
443           if (strchr (j_item->valuestring, '\n'))
444             return gpg_error (GPG_ERR_INV_USER_ID);
445         }
446     }
447
448   p = *r_keystring = xtrymalloc (length);
449   if (!p)
450     return gpg_error_from_syserror ();
451
452   if (cjson_is_string (j_keys))
453     {
454       strcpy (p, j_keys->valuestring);
455     }
456   else
457     {
458       for (i=0; i < nkeys; i++)
459         {
460           j_item = cJSON_GetArrayItem (j_keys, i);
461           if (i)
462             *p++ = '\n'; /* Add delimiter.  */
463           p = stpcpy (p, j_item->valuestring);
464         }
465     }
466   return 0;
467 }
468
469
470
471 \f
472 /*
473  *  GPGME support functions.
474  */
475
476 /* Helper for get_context.  */
477 static gpgme_ctx_t
478 _create_new_context (gpgme_protocol_t proto)
479 {
480   gpg_error_t err;
481   gpgme_ctx_t ctx;
482
483   err = gpgme_new (&ctx);
484   if (err)
485     log_fatal ("error creating GPGME context: %s\n", gpg_strerror (err));
486   gpgme_set_protocol (ctx, proto);
487   gpgme_set_ctx_flag (ctx, "request-origin", "browser");
488   return ctx;
489 }
490
491
492 /* Return a context object for protocol PROTO.  This is currently a
493  * statuically allocated context initialized for PROTO.  Termnates
494  * process on failure.  */
495 static gpgme_ctx_t
496 get_context (gpgme_protocol_t proto)
497 {
498   static gpgme_ctx_t ctx_openpgp, ctx_cms;
499
500   if (proto == GPGME_PROTOCOL_OpenPGP)
501     {
502       if (!ctx_openpgp)
503         ctx_openpgp = _create_new_context (proto);
504       return ctx_openpgp;
505     }
506   else if (proto == GPGME_PROTOCOL_CMS)
507     {
508       if (!ctx_cms)
509         ctx_cms = _create_new_context (proto);
510       return ctx_cms;
511     }
512   else
513     log_bug ("invalid protocol %d requested\n", proto);
514 }
515
516
517
518 /* Free context object retrieved by get_context.  */
519 static void
520 release_context (gpgme_ctx_t ctx)
521 {
522   /* Nothing to do right now.  */
523   (void)ctx;
524 }
525
526
527
528 /* Given a Base-64 encoded string object in JSON return a gpgme data
529  * object at R_DATA.  */
530 static gpg_error_t
531 data_from_base64_string (gpgme_data_t *r_data, cjson_t json)
532 {
533 #if GPGRT_VERSION_NUMBER < 0x011d00 /* 1.29 */
534   *r_data = NULL;
535   return gpg_error (GPG_ERR_NOT_SUPPORTED);
536 #else
537   gpg_error_t err;
538   size_t len;
539   char *buf = NULL;
540   gpgrt_b64state_t state = NULL;
541   gpgme_data_t data = NULL;
542
543   *r_data = NULL;
544
545   /* A quick check on the JSON.  */
546   if (!cjson_is_string (json))
547     {
548       err = gpg_error (GPG_ERR_INV_VALUE);
549       goto leave;
550     }
551
552   state = gpgrt_b64dec_start (NULL);
553   if (!state)
554     {
555       err = gpg_err_code_from_syserror ();
556       goto leave;
557     }
558
559   /* Fixme: Data duplication - we should see how to snatch the memory
560    * from the json object.  */
561   len = strlen (json->valuestring);
562   buf = xtrystrdup (json->valuestring);
563   if (!buf)
564     {
565       err = gpg_error_from_syserror ();
566       goto leave;
567     }
568
569   err = gpgrt_b64dec_proc (state, buf, len, &len);
570   if (err)
571     goto leave;
572
573   err = gpgrt_b64dec_finish (state);
574   state = NULL;
575   if (err)
576     goto leave;
577
578   err = gpgme_data_new_from_mem (&data, buf, len, 1);
579   if (err)
580     goto leave;
581   *r_data = data;
582   data = NULL;
583
584  leave:
585   xfree (data);
586   xfree (buf);
587   gpgrt_b64dec_finish (state);
588   return err;
589 #endif
590 }
591
592
593 \f
594 /*
595  * Implementation of the commands.
596  */
597
598
599 /* Create a "data" object and the "type", "base64" and "more" flags
600  * from DATA and append them to RESULT.  Ownership if DATA is
601  * transferred to this function.  TYPE must be a fixed string.
602  * CHUNKSIZE is the chunksize requested from the caller.  If BASE64 is
603  * -1 the need for base64 encoding is determined by the content of
604  * DATA, all other values are take as rtue or false.  Note that
605  * op_getmore has similar code but works on PENDING_DATA which is set
606  * here.  */
607 static gpg_error_t
608 make_data_object (cjson_t result, gpgme_data_t data, size_t chunksize,
609                   const char *type, int base64)
610 {
611   gpg_error_t err;
612   char *buffer;
613   size_t buflen;
614   int c;
615
616   if (!base64 || base64 == -1) /* Make sure that we really have a string.  */
617     gpgme_data_write (data, "", 1);
618
619   buffer = gpgme_data_release_and_get_mem (data, &buflen);
620   data = NULL;
621   if (!buffer)
622     {
623       err = gpg_error_from_syserror ();
624       goto leave;
625     }
626
627   if (base64 == -1)
628     {
629       base64 = 0;
630       if (!buflen)
631         log_fatal ("Appended Nul byte got lost\n");
632       if (memchr (buffer, 0, buflen-1))
633         {
634           buflen--; /* Adjust for the extra nul byte.  */
635           base64 = 1;
636         }
637       /* Fixme: We might want to do more advanced heuristics than to
638        * only look for a Nul.  */
639     }
640
641   /* Adjust the chunksize if we need to do base64 conversion.  */
642   if (base64)
643     chunksize = (chunksize / 4) * 3;
644
645   xjson_AddStringToObject (result, "type", type);
646   xjson_AddBoolToObject (result, "base64", base64);
647
648   if (buflen > chunksize)
649     {
650       xjson_AddBoolToObject (result, "more", 1);
651
652       c = buffer[chunksize];
653       buffer[chunksize] = 0;
654       if (base64)
655         err = add_base64_to_object (result, "data", buffer, chunksize);
656       else
657         err = cjson_AddStringToObject (result, "data", buffer);
658       buffer[chunksize] = c;
659       if (err)
660         goto leave;
661
662       pending_data.buffer = buffer;
663       buffer = NULL;
664       pending_data.length = buflen;
665       pending_data.written = chunksize;
666       pending_data.type = type;
667       pending_data.base64 = base64;
668     }
669   else
670     {
671       if (base64)
672         err = add_base64_to_object (result, "data", buffer, buflen);
673       else
674         err = cjson_AddStringToObject (result, "data", buffer);
675     }
676
677  leave:
678   gpgme_free (buffer);
679   return err;
680 }
681
682
683 \f
684 static const char hlp_encrypt[] =
685   "op:     \"encrypt\"\n"
686   "keys:   Array of strings with the fingerprints or user-ids\n"
687   "        of the keys to encrypt the data.  For a single key\n"
688   "        a String may be used instead of an array.\n"
689   "data:   Input data. \n"
690   "\n"
691   "Optional parameters:\n"
692   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
693   "chunksize:     Max number of bytes in the resulting \"data\".\n"
694   "\n"
695   "Optional boolean flags (default is false):\n"
696   "base64:        Input data is base64 encoded.\n"
697   "mime:          Indicate that data is a MIME object.\n"
698   "armor:         Request output in armored format.\n"
699   "always-trust:  Request --always-trust option.\n"
700   "no-encrypt-to: Do not use a default recipient.\n"
701   "no-compress:   Do not compress the plaintext first.\n"
702   "throw-keyids:  Request the --throw-keyids option.\n"
703   "want-address:  Require that the keys include a mail address.\n"
704   "wrap:          Assume the input is an OpenPGP message.\n"
705   "\n"
706   "Response on success:\n"
707   "type:   \"ciphertext\"\n"
708   "data:   Unless armor mode is used a Base64 encoded binary\n"
709   "        ciphertext.  In armor mode a string with an armored\n"
710   "        OpenPGP or a PEM message.\n"
711   "base64: Boolean indicating whether data is base64 encoded.\n"
712   "more:   Optional boolean indicating that \"getmore\" is required.";
713 static gpg_error_t
714 op_encrypt (cjson_t request, cjson_t result)
715 {
716   gpg_error_t err;
717   gpgme_ctx_t ctx = NULL;
718   gpgme_protocol_t protocol;
719   size_t chunksize;
720   int opt_base64;
721   int opt_mime;
722   char *keystring = NULL;
723   cjson_t j_input;
724   gpgme_data_t input = NULL;
725   gpgme_data_t output = NULL;
726   int abool;
727   gpgme_encrypt_flags_t encrypt_flags = 0;
728
729   if ((err = get_protocol (request, &protocol)))
730     goto leave;
731   ctx = get_context (protocol);
732   if ((err = get_chunksize (request, &chunksize)))
733     goto leave;
734
735   if ((err = get_boolean_flag (request, "base64", 0, &opt_base64)))
736     goto leave;
737   if ((err = get_boolean_flag (request, "mime", 0, &opt_mime)))
738     goto leave;
739
740   if ((err = get_boolean_flag (request, "armor", 0, &abool)))
741     goto leave;
742   gpgme_set_armor (ctx, abool);
743   if ((err = get_boolean_flag (request, "always-trust", 0, &abool)))
744     goto leave;
745   if (abool)
746     encrypt_flags |= GPGME_ENCRYPT_ALWAYS_TRUST;
747   if ((err = get_boolean_flag (request, "no-encrypt-to", 0,&abool)))
748     goto leave;
749   if (abool)
750     encrypt_flags |= GPGME_ENCRYPT_NO_ENCRYPT_TO;
751   if ((err = get_boolean_flag (request, "no-compress", 0, &abool)))
752     goto leave;
753   if (abool)
754     encrypt_flags |= GPGME_ENCRYPT_NO_COMPRESS;
755   if ((err = get_boolean_flag (request, "throw-keyids", 0, &abool)))
756     goto leave;
757   if (abool)
758     encrypt_flags |= GPGME_ENCRYPT_THROW_KEYIDS;
759   if ((err = get_boolean_flag (request, "wrap", 0, &abool)))
760     goto leave;
761   if (abool)
762     encrypt_flags |= GPGME_ENCRYPT_WRAP;
763   if ((err = get_boolean_flag (request, "want-address", 0, &abool)))
764     goto leave;
765   if (abool)
766     encrypt_flags |= GPGME_ENCRYPT_WANT_ADDRESS;
767
768
769   /* Get the keys.  */
770   err = get_keys (request, &keystring);
771   if (err)
772     {
773       /* Provide a custom error response.  */
774       error_object (result, "Error getting keys: %s", gpg_strerror (err));
775       goto leave;
776     }
777
778   /* Get the data.  Note that INPUT is a shallow data object with the
779    * storage hold in REQUEST.  */
780   j_input = cJSON_GetObjectItem (request, "data");
781   if (!j_input)
782     {
783       err = gpg_error (GPG_ERR_NO_DATA);
784       goto leave;
785     }
786   if (!cjson_is_string (j_input))
787     {
788       err = gpg_error (GPG_ERR_INV_VALUE);
789       goto leave;
790     }
791   if (opt_base64)
792     {
793       err = data_from_base64_string (&input, j_input);
794       if (err)
795         {
796           error_object (result, "Error decoding Base-64 encoded 'data': %s",
797                         gpg_strerror (err));
798           goto leave;
799         }
800     }
801   else
802     {
803       err = gpgme_data_new_from_mem (&input, j_input->valuestring,
804                                      strlen (j_input->valuestring), 0);
805       if (err)
806         {
807           error_object (result, "Error getting 'data': %s", gpg_strerror (err));
808           goto leave;
809         }
810     }
811   if (opt_mime)
812     gpgme_data_set_encoding (input, GPGME_DATA_ENCODING_MIME);
813
814
815   /* Create an output data object.  */
816   err = gpgme_data_new (&output);
817   if (err)
818     {
819       error_object (result, "Error creating output data object: %s",
820                     gpg_strerror (err));
821       goto leave;
822     }
823
824   /* Encrypt.  */
825   err = gpgme_op_encrypt_ext (ctx, NULL, keystring, encrypt_flags,
826                               input, output);
827   /* encrypt_result = gpgme_op_encrypt_result (ctx); */
828   if (err)
829     {
830       error_object (result, "Encryption failed: %s", gpg_strerror (err));
831       goto leave;
832     }
833   gpgme_data_release (input);
834   input = NULL;
835
836   /* We need to base64 if armoring has not been requested.  */
837   err = make_data_object (result, output, chunksize,
838                           "ciphertext", !gpgme_get_armor (ctx));
839   output = NULL;
840
841  leave:
842   xfree (keystring);
843   release_context (ctx);
844   gpgme_data_release (input);
845   gpgme_data_release (output);
846   return err;
847 }
848
849
850 \f
851 static const char hlp_decrypt[] =
852   "op:     \"decrypt\"\n"
853   "data:   The encrypted data.\n"
854   "\n"
855   "Optional parameters:\n"
856   "protocol:      Either \"openpgp\" (default) or \"cms\".\n"
857   "chunksize:     Max number of bytes in the resulting \"data\".\n"
858   "\n"
859   "Optional boolean flags (default is false):\n"
860   "base64:        Input data is base64 encoded.\n"
861   "\n"
862   "Response on success:\n"
863   "type:   \"plaintext\"\n"
864   "data:   The decrypted data.  This may be base64 encoded.\n"
865   "base64: Boolean indicating whether data is base64 encoded.\n"
866   "mime:   A Boolean indicating whether the data is a MIME object.\n"
867   "info:   An optional object with extra information.\n"
868   "more:   Optional boolean indicating that \"getmore\" is required.";
869 static gpg_error_t
870 op_decrypt (cjson_t request, cjson_t result)
871 {
872   gpg_error_t err;
873   gpgme_ctx_t ctx = NULL;
874   gpgme_protocol_t protocol;
875   size_t chunksize;
876   int opt_base64;
877   cjson_t j_input;
878   gpgme_data_t input = NULL;
879   gpgme_data_t output = NULL;
880   gpgme_decrypt_result_t decrypt_result;
881
882   if ((err = get_protocol (request, &protocol)))
883     goto leave;
884   ctx = get_context (protocol);
885   if ((err = get_chunksize (request, &chunksize)))
886     goto leave;
887
888   if ((err = get_boolean_flag (request, "base64", 0, &opt_base64)))
889     goto leave;
890
891   /* Get the data.  Note that INPUT is a shallow data object with the
892    * storage hold in REQUEST.  */
893   j_input = cJSON_GetObjectItem (request, "data");
894   if (!j_input)
895     {
896       err = gpg_error (GPG_ERR_NO_DATA);
897       goto leave;
898     }
899   if (!cjson_is_string (j_input))
900     {
901       err = gpg_error (GPG_ERR_INV_VALUE);
902       goto leave;
903     }
904   if (opt_base64)
905     {
906       err = data_from_base64_string (&input, j_input);
907       if (err)
908         {
909           error_object (result, "Error decoding Base-64 encoded 'data': %s",
910                         gpg_strerror (err));
911           goto leave;
912         }
913     }
914   else
915     {
916       err = gpgme_data_new_from_mem (&input, j_input->valuestring,
917                                      strlen (j_input->valuestring), 0);
918       if (err)
919         {
920           error_object (result, "Error getting 'data': %s", gpg_strerror (err));
921           goto leave;
922         }
923     }
924
925   /* Create an output data object.  */
926   err = gpgme_data_new (&output);
927   if (err)
928     {
929       error_object (result, "Error creating output data object: %s",
930                     gpg_strerror (err));
931       goto leave;
932     }
933
934   /* Decrypt.  */
935   err = gpgme_op_decrypt_ext (ctx, GPGME_DECRYPT_VERIFY,
936                               input, output);
937   decrypt_result = gpgme_op_decrypt_result (ctx);
938   if (err)
939     {
940       error_object (result, "Decryption failed: %s", gpg_strerror (err));
941       goto leave;
942     }
943   gpgme_data_release (input);
944   input = NULL;
945
946   if (decrypt_result->is_mime)
947     xjson_AddBoolToObject (result, "mime", 1);
948
949   err = make_data_object (result, output, chunksize, "plaintext", -1);
950   output = NULL;
951
952  leave:
953   release_context (ctx);
954   gpgme_data_release (input);
955   gpgme_data_release (output);
956   return err;
957 }
958
959
960 \f
961 static const char hlp_getmore[] =
962   "op:     \"getmore\"\n"
963   "\n"
964   "Optional parameters:\n"
965   "chunksize:  Max number of bytes in the \"data\" object.\n"
966   "\n"
967   "Response on success:\n"
968   "type:       Type of the pending data\n"
969   "data:       The next chunk of data\n"
970   "base64:     Boolean indicating whether data is base64 encoded\n"
971   "more:       Optional boolean requesting another \"getmore\".";
972 static gpg_error_t
973 op_getmore (cjson_t request, cjson_t result)
974 {
975   gpg_error_t err;
976   int c;
977   size_t n;
978   size_t chunksize;
979
980   if ((err = get_chunksize (request, &chunksize)))
981     goto leave;
982
983   /* Adjust the chunksize if we need to do base64 conversion.  */
984   if (pending_data.base64)
985     chunksize = (chunksize / 4) * 3;
986
987   /* Do we have anything pending?  */
988   if (!pending_data.buffer)
989     {
990       err = gpg_error (GPG_ERR_NO_DATA);
991       error_object (result, "Operation not possible: %s", gpg_strerror (err));
992       goto leave;
993     }
994
995   xjson_AddStringToObject (result, "type", pending_data.type);
996   xjson_AddBoolToObject (result, "base64", pending_data.base64);
997
998   if (pending_data.written >= pending_data.length)
999     {
1000       /* EOF reached.  This should not happen but we return an empty
1001        * string once in case of client errors.  */
1002       gpgme_free (pending_data.buffer);
1003       pending_data.buffer = NULL;
1004       xjson_AddBoolToObject (result, "more", 0);
1005       err = cjson_AddStringToObject (result, "data", "");
1006     }
1007   else
1008     {
1009       n = pending_data.length - pending_data.written;
1010       if (n > chunksize)
1011         {
1012           n = chunksize;
1013           xjson_AddBoolToObject (result, "more", 1);
1014         }
1015       else
1016         xjson_AddBoolToObject (result, "more", 0);
1017
1018       c = pending_data.buffer[pending_data.written + n];
1019       pending_data.buffer[pending_data.written + n] = 0;
1020       if (pending_data.base64)
1021         err = add_base64_to_object (result, "data",
1022                                     (pending_data.buffer
1023                                      + pending_data.written), n);
1024       else
1025         err = cjson_AddStringToObject (result, "data",
1026                                        (pending_data.buffer
1027                                         + pending_data.written));
1028       pending_data.buffer[pending_data.written + n] = c;
1029       if (!err)
1030         {
1031           pending_data.written += n;
1032           if (pending_data.written >= pending_data.length)
1033             {
1034               gpgme_free (pending_data.buffer);
1035               pending_data.buffer = NULL;
1036             }
1037         }
1038     }
1039
1040  leave:
1041   return err;
1042 }
1043
1044
1045 \f
1046 static const char hlp_help[] =
1047   "The tool expects a JSON object with the request and responds with\n"
1048   "another JSON object.  Even on error a JSON object is returned.  The\n"
1049   "property \"op\" is mandatory and its string value selects the\n"
1050   "operation; if the property \"help\" with the value \"true\" exists, the\n"
1051   "operation is not performned but a string with the documentation\n"
1052   "returned.  To list all operations it is allowed to leave out \"op\" in\n"
1053   "help mode.  Supported values for \"op\" are:\n\n"
1054   "  encrypt     Encrypt data.\n"
1055   "  getmore     Retrieve remaining data.\n"
1056   "  help        Help overview.";
1057 static gpg_error_t
1058 op_help (cjson_t request, cjson_t result)
1059 {
1060   cjson_t j_tmp;
1061   char *buffer = NULL;
1062   const char *msg;
1063
1064   j_tmp = cJSON_GetObjectItem (request, "interactive_help");
1065   if (opt_interactive && j_tmp && cjson_is_string (j_tmp))
1066     msg = buffer = xstrconcat (hlp_help, "\n", j_tmp->valuestring, NULL);
1067   else
1068     msg = hlp_help;
1069
1070   xjson_AddStringToObject (result, "type", "help");
1071   xjson_AddStringToObject (result, "msg", msg);
1072
1073   xfree (buffer);
1074   return 0;
1075 }
1076
1077
1078 \f
1079 /*
1080  * Dispatcher
1081  */
1082
1083 /* Process a request and return the response.  The response is a newly
1084  * allocated string or NULL in case of an error.  */
1085 static char *
1086 process_request (const char *request)
1087 {
1088   static struct {
1089     const char *op;
1090     gpg_error_t (*handler)(cjson_t request, cjson_t result);
1091     const char * const helpstr;
1092   } optbl[] = {
1093     { "encrypt", op_encrypt, hlp_encrypt },
1094     { "decrypt", op_decrypt, hlp_decrypt },
1095     { "getmore", op_getmore, hlp_getmore },
1096     { "help",    op_help,    hlp_help },
1097     { NULL }
1098   };
1099   size_t erroff;
1100   cjson_t json;
1101   cjson_t j_tmp, j_op;
1102   cjson_t response;
1103   int helpmode;
1104   const char *op;
1105   char *res;
1106   int idx;
1107
1108   response = xjson_CreateObject ();
1109
1110   json = cJSON_Parse (request, &erroff);
1111   if (!json)
1112     {
1113       log_string (GPGRT_LOGLVL_INFO, request);
1114       log_info ("invalid JSON object at offset %zu\n", erroff);
1115       error_object (response, "invalid JSON object at offset %zu\n", erroff);
1116       goto leave;
1117     }
1118
1119   j_tmp = cJSON_GetObjectItem (json, "help");
1120   helpmode = (j_tmp && cjson_is_true (j_tmp));
1121
1122   j_op = cJSON_GetObjectItem (json, "op");
1123   if (!j_op || !cjson_is_string (j_op))
1124     {
1125       if (!helpmode)
1126         {
1127           error_object (response, "Property \"op\" missing");
1128           goto leave;
1129         }
1130       op = "help";  /* Help summary.  */
1131     }
1132   else
1133     op = j_op->valuestring;
1134
1135   for (idx=0; optbl[idx].op; idx++)
1136     if (!strcmp (op, optbl[idx].op))
1137       break;
1138   if (optbl[idx].op)
1139     {
1140       if (helpmode && strcmp (op, "help"))
1141         {
1142           xjson_AddStringToObject (response, "type", "help");
1143           xjson_AddStringToObject (response, "op", op);
1144           xjson_AddStringToObject (response, "msg", optbl[idx].helpstr);
1145         }
1146       else
1147         {
1148           gpg_error_t err;
1149
1150           /* If this is not the "getmore" command and we have any
1151            * pending data release that data.  */
1152           if (pending_data.buffer && optbl[idx].handler != op_getmore)
1153             {
1154               gpgme_free (pending_data.buffer);
1155               pending_data.buffer = NULL;
1156             }
1157
1158           err = optbl[idx].handler (json, response);
1159           if (err)
1160             {
1161               if (!(j_tmp = cJSON_GetObjectItem (response, "type"))
1162                   || !cjson_is_string (j_tmp)
1163                   || strcmp (j_tmp->valuestring, "error"))
1164                 {
1165                   /* No error type response - provide a generic one.  */
1166                   error_object (response, "Operation failed: %s",
1167                                 gpg_strerror (err));
1168                 }
1169
1170               xjson_AddStringToObject (response, "op", op);
1171             }
1172         }
1173     }
1174   else  /* Operation not supported.  */
1175     {
1176       error_object (response, "Unknown operation '%s'", op);
1177       xjson_AddStringToObject (response, "op", op);
1178     }
1179
1180  leave:
1181   cJSON_Delete (json);
1182   if (opt_interactive)
1183     res = cJSON_Print (response);
1184   else
1185     res = cJSON_PrintUnformatted (response);
1186   if (!res)
1187     log_error ("Printing JSON data failed\n");
1188   cJSON_Delete (response);
1189   return res;
1190 }
1191
1192
1193 \f
1194 /*
1195  *  Driver code
1196  */
1197
1198 static char *
1199 get_file (const char *fname)
1200 {
1201   gpg_error_t err;
1202   estream_t fp;
1203   struct stat st;
1204   char *buf;
1205   size_t buflen;
1206
1207   fp = es_fopen (fname, "r");
1208   if (!fp)
1209     {
1210       err = gpg_error_from_syserror ();
1211       log_error ("can't open '%s': %s\n", fname, gpg_strerror (err));
1212       return NULL;
1213     }
1214
1215   if (fstat (es_fileno(fp), &st))
1216     {
1217       err = gpg_error_from_syserror ();
1218       log_error ("can't stat '%s': %s\n", fname, gpg_strerror (err));
1219       es_fclose (fp);
1220       return NULL;
1221     }
1222
1223   buflen = st.st_size;
1224   buf = xmalloc (buflen+1);
1225   if (es_fread (buf, buflen, 1, fp) != 1)
1226     {
1227       err = gpg_error_from_syserror ();
1228       log_error ("error reading '%s': %s\n", fname, gpg_strerror (err));
1229       es_fclose (fp);
1230       xfree (buf);
1231       return NULL;
1232     }
1233   buf[buflen] = 0;
1234   es_fclose (fp);
1235
1236   return buf;
1237 }
1238
1239
1240 /* Return a malloced line or NULL on EOF.  Terminate on read
1241  * error.  */
1242 static char *
1243 get_line (void)
1244 {
1245   char *line = NULL;
1246   size_t linesize = 0;
1247   gpg_error_t err;
1248   size_t maxlength = 2048;
1249   int n;
1250   const char *s;
1251   char *p;
1252
1253  again:
1254   n = es_read_line (es_stdin, &line, &linesize, &maxlength);
1255   if (n < 0)
1256     {
1257       err = gpg_error_from_syserror ();
1258       log_error ("error reading line: %s\n", gpg_strerror (err));
1259       exit (1);
1260     }
1261   if (!n)
1262     {
1263       xfree (line);
1264       line = NULL;
1265       return NULL;  /* EOF */
1266     }
1267   if (!maxlength)
1268     {
1269       log_info ("line too long - skipped\n");
1270       goto again;
1271     }
1272   if (memchr (line, 0, n))
1273     log_info ("warning: line shortened due to embedded Nul character\n");
1274
1275   if (line[n-1] == '\n')
1276     line[n-1] = 0;
1277
1278   /* Trim leading spaces.  */
1279   for (s=line; spacep (s); s++)
1280     ;
1281   if (s != line)
1282     {
1283       for (p=line; *s;)
1284         *p++ = *s++;
1285       *p = 0;
1286       n = p - line;
1287     }
1288
1289   return line;
1290 }
1291
1292
1293 /* Process meta commands used with the standard REPL.  */
1294 static char *
1295 process_meta_commands (const char *request)
1296 {
1297   char *result = NULL;
1298
1299   while (spacep (request))
1300     request++;
1301
1302   if (!strncmp (request, "help", 4) && (spacep (request+4) || !request[4]))
1303     {
1304       if (request[4])
1305         {
1306           char *buf = xstrconcat ("{ \"help\":true, \"op\":\"", request+5,
1307                                   "\" }", NULL);
1308           result = process_request (buf);
1309           xfree (buf);
1310         }
1311       else
1312         result = process_request ("{ \"op\": \"help\","
1313                                   " \"interactive_help\": "
1314                                   "\"\\nMeta commands:\\n"
1315                                   "  ,read FNAME Process data from FILE\\n"
1316                                   "  ,help CMD   Print help for a command\\n"
1317                                   "  ,quit       Terminate process\""
1318                                   "}");
1319     }
1320   else if (!strncmp (request, "quit", 4) && (spacep (request+4) || !request[4]))
1321     exit (0);
1322   else if (!strncmp (request, "read", 4) && (spacep (request+4) || !request[4]))
1323     {
1324       if (!request[4])
1325         log_info ("usage: ,read FILENAME\n");
1326       else
1327         {
1328           char *buffer = get_file (request + 5);
1329           if (buffer)
1330             {
1331               result = process_request (buffer);
1332               xfree (buffer);
1333             }
1334         }
1335     }
1336   else
1337     log_info ("invalid meta command\n");
1338
1339   return result;
1340 }
1341
1342
1343 /* If STRING has a help response, return the MSG property in a human
1344  * readable format.  */
1345 static char *
1346 get_help_msg (const char *string)
1347 {
1348   cjson_t json, j_type, j_msg;
1349   const char *msg;
1350   char *buffer = NULL;
1351   char *p;
1352
1353   json = cJSON_Parse (string, NULL);
1354   if (json)
1355     {
1356       j_type = cJSON_GetObjectItem (json, "type");
1357       if (j_type && cjson_is_string (j_type)
1358           && !strcmp (j_type->valuestring, "help"))
1359         {
1360           j_msg = cJSON_GetObjectItem (json, "msg");
1361           if (j_msg || cjson_is_string (j_msg))
1362             {
1363               msg = j_msg->valuestring;
1364               buffer = malloc (strlen (msg)+1);
1365               if (buffer)
1366                 {
1367                   for (p=buffer; *msg; msg++)
1368                     {
1369                       if (*msg == '\\' && msg[1] == '\n')
1370                         *p++ = '\n';
1371                       else
1372                         *p++ = *msg;
1373                     }
1374                   *p = 0;
1375                 }
1376             }
1377         }
1378       cJSON_Delete (json);
1379     }
1380   return buffer;
1381 }
1382
1383
1384 /* An interactive standard REPL.  */
1385 static void
1386 interactive_repl (void)
1387 {
1388   char *line = NULL;
1389   char *request = NULL;
1390   char *response = NULL;
1391   char *p;
1392   int first;
1393
1394   es_setvbuf (es_stdin, NULL, _IONBF, 0);
1395 #if GPGRT_VERSION_NUMBER >= 0x011d00 /* 1.29 */
1396   es_fprintf (es_stderr, "%s %s ready (enter \",help\" for help)\n",
1397               gpgrt_strusage (11), gpgrt_strusage (13));
1398 #endif
1399   do
1400     {
1401       es_fputs ("> ", es_stderr);
1402       es_fflush (es_stderr);
1403       es_fflush (es_stdout);
1404       xfree (line);
1405       line = get_line ();
1406       es_fflush (es_stderr);
1407       es_fflush (es_stdout);
1408
1409       first = !request;
1410       if (line && *line)
1411         {
1412           if (!request)
1413             request = xstrdup (line);
1414           else
1415             request = xstrconcat (request, "\n", line, NULL);
1416         }
1417
1418       if (!line)
1419         es_fputs ("\n", es_stderr);
1420
1421       if (!line || !*line || (first && *request == ','))
1422         {
1423           /* Process the input.  */
1424           xfree (response);
1425           response = NULL;
1426           if (request && *request == ',')
1427             {
1428               response = process_meta_commands (request+1);
1429             }
1430           else if (request)
1431             {
1432               response = process_request (request);
1433             }
1434           xfree (request);
1435           request = NULL;
1436
1437           if (response)
1438             {
1439               if (opt_interactive)
1440                 {
1441                   char *msg = get_help_msg (response);
1442                   if (msg)
1443                     {
1444                       xfree (response);
1445                       response = msg;
1446                     }
1447                 }
1448
1449               es_fputs ("===> ", es_stderr);
1450               es_fflush (es_stderr);
1451               for (p=response; *p; p++)
1452                 {
1453                   if (*p == '\n')
1454                     {
1455                       es_fflush (es_stdout);
1456                       es_fputs ("\n===> ", es_stderr);
1457                       es_fflush (es_stderr);
1458                     }
1459                   else
1460                     es_putc (*p, es_stdout);
1461                 }
1462               es_fflush (es_stdout);
1463               es_fputs ("\n", es_stderr);
1464             }
1465         }
1466     }
1467   while (line);
1468
1469   xfree (request);
1470   xfree (response);
1471   xfree (line);
1472 }
1473
1474
1475 /* Read and process a single request.  */
1476 static void
1477 read_and_process_single_request (void)
1478 {
1479   char *line = NULL;
1480   char *request = NULL;
1481   char *response = NULL;
1482   size_t n;
1483
1484   for (;;)
1485     {
1486       xfree (line);
1487       line = get_line ();
1488       if (line && *line)
1489         request = (request? xstrconcat (request, "\n", line, NULL)
1490                    /**/   : xstrdup (line));
1491       if (!line)
1492         {
1493           if (request)
1494             {
1495               xfree (response);
1496               response = process_request (request);
1497               if (response)
1498                 {
1499                   es_fputs (response, es_stdout);
1500                   if ((n = strlen (response)) && response[n-1] != '\n')
1501                     es_fputc ('\n', es_stdout);
1502                 }
1503               es_fflush (es_stdout);
1504             }
1505           break;
1506         }
1507     }
1508
1509   xfree (response);
1510   xfree (request);
1511   xfree (line);
1512 }
1513
1514
1515 /* The Native Messaging processing loop.  */
1516 static void
1517 native_messaging_repl (void)
1518 {
1519   gpg_error_t err;
1520   uint32_t nrequest, nresponse;
1521   char *request = NULL;
1522   char *response = NULL;
1523   size_t n;
1524
1525   /* Due to the length octets we need to switch the I/O stream into
1526    * binary mode.  */
1527   es_set_binary (es_stdin);
1528   es_set_binary (es_stdout);
1529   es_setbuf (es_stdin, NULL);  /* stdin needs to be unbuffered! */
1530
1531   for (;;)
1532     {
1533       /* Read length.  Note that the protocol uses native endianess.
1534        * Is it allowed to call such a thing a well thought out
1535        * protocol?  */
1536       if (es_read (es_stdin, &nrequest, sizeof nrequest, &n))
1537         {
1538           err = gpg_error_from_syserror ();
1539           log_error ("error reading request header: %s\n", gpg_strerror (err));
1540           break;
1541         }
1542       if (!n)
1543         break;  /* EOF */
1544       if (n != sizeof nrequest)
1545         {
1546           log_error ("error reading request header: short read\n");
1547           break;
1548         }
1549       if (nrequest > MAX_REQUEST_SIZE)
1550         {
1551           log_error ("error reading request: request too long (%zu MiB)\n",
1552                      (size_t)nrequest / (1024*1024));
1553           /* Fixme: Shall we read the request to the bit bucket and
1554            * return an error reponse or just return an error reponse
1555            * and terminate?  Needs some testing.  */
1556           break;
1557         }
1558
1559       /* Read request.  */
1560       request = xtrymalloc (nrequest);
1561       if (!request)
1562         {
1563           err = gpg_error_from_syserror ();
1564           log_error ("error reading request: Not enough memory for %zu MiB)\n",
1565                      (size_t)nrequest / (1024*1024));
1566           /* FIXME: See comment above.  */
1567           break;
1568         }
1569       if (es_read (es_stdin, request, nrequest, &n))
1570         {
1571           err = gpg_error_from_syserror ();
1572           log_error ("error reading request: %s\n", gpg_strerror (err));
1573           break;
1574         }
1575       if (n != nrequest)
1576         {
1577           /* That is a protocol violation.  */
1578           xfree (response);
1579           response = error_object_string ("Invalid request:"
1580                                           " short read (%zu of %zu bytes)\n",
1581                                           n, (size_t)nrequest);
1582         }
1583       else /* Process request  */
1584         {
1585           if (opt_debug)
1586             log_debug ("request='%s'\n", request);
1587           xfree (response);
1588           response = process_request (request);
1589           if (opt_debug)
1590             log_debug ("response='%s'\n", response);
1591         }
1592       nresponse = strlen (response);
1593
1594       /* Write response */
1595       if (es_write (es_stdout, &nresponse, sizeof nresponse, &n))
1596         {
1597           err = gpg_error_from_syserror ();
1598           log_error ("error writing request header: %s\n", gpg_strerror (err));
1599           break;
1600         }
1601       if (n != sizeof nrequest)
1602         {
1603           log_error ("error writing request header: short write\n");
1604           break;
1605         }
1606       if (es_write (es_stdout, response, nresponse, &n))
1607         {
1608           err = gpg_error_from_syserror ();
1609           log_error ("error writing request: %s\n", gpg_strerror (err));
1610           break;
1611         }
1612       if (n != nresponse)
1613         {
1614           log_error ("error writing request: short write\n");
1615           break;
1616         }
1617       if (es_fflush (es_stdout) || es_ferror (es_stdout))
1618         {
1619           err = gpg_error_from_syserror ();
1620           log_error ("error writing request: %s\n", gpg_strerror (err));
1621           break;
1622         }
1623     }
1624
1625   xfree (response);
1626   xfree (request);
1627 }
1628
1629
1630 \f
1631 static const char *
1632 my_strusage( int level )
1633 {
1634   const char *p;
1635
1636   switch (level)
1637     {
1638     case  9: p = "LGPL-2.1-or-later"; break;
1639     case 11: p = "gpgme-json"; break;
1640     case 13: p = PACKAGE_VERSION; break;
1641     case 14: p = "Copyright (C) 2018 g10 Code GmbH"; break;
1642     case 19: p = "Please report bugs to <" PACKAGE_BUGREPORT ">.\n"; break;
1643     case 1:
1644     case 40:
1645       p = "Usage: gpgme-json [OPTIONS]";
1646       break;
1647     case 41:
1648       p = "Native messaging based GPGME operations.\n";
1649       break;
1650     case 42:
1651       p = "1"; /* Flag print 40 as part of 41. */
1652       break;
1653     default: p = NULL; break;
1654     }
1655   return p;
1656 }
1657
1658 int
1659 main (int argc, char *argv[])
1660 {
1661 #if GPGRT_VERSION_NUMBER < 0x011d00 /* 1.29 */
1662
1663   fprintf (stderr, "WARNING: Old libgpg-error - using limited mode\n");
1664   native_messaging_repl ();
1665
1666 #else /* This is a modern libgp-error.  */
1667
1668   enum { CMD_DEFAULT     = 0,
1669          CMD_INTERACTIVE = 'i',
1670          CMD_SINGLE      = 's',
1671          CMD_LIBVERSION  = 501,
1672   } cmd = CMD_DEFAULT;
1673   enum {
1674     OPT_DEBUG = 600
1675   };
1676
1677   static gpgrt_opt_t opts[] = {
1678     ARGPARSE_c  (CMD_INTERACTIVE, "interactive", "Interactive REPL"),
1679     ARGPARSE_c  (CMD_SINGLE,      "single",      "Single request mode"),
1680     ARGPARSE_c  (CMD_LIBVERSION,  "lib-version", "Show library version"),
1681     ARGPARSE_s_n(OPT_DEBUG,       "debug",       "Flyswatter"),
1682
1683     ARGPARSE_end()
1684   };
1685   gpgrt_argparse_t pargs = { &argc, &argv};
1686
1687   gpgrt_set_strusage (my_strusage);
1688
1689 #ifdef HAVE_SETLOCALE
1690   setlocale (LC_ALL, "");
1691 #endif
1692   gpgme_check_version (NULL);
1693 #ifdef LC_CTYPE
1694   gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
1695 #endif
1696 #ifdef LC_MESSAGES
1697   gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
1698 #endif
1699
1700   while (gpgrt_argparse (NULL, &pargs, opts))
1701     {
1702       switch (pargs.r_opt)
1703         {
1704         case CMD_INTERACTIVE:
1705           opt_interactive = 1;
1706           /* Fall trough.  */
1707         case CMD_SINGLE:
1708         case CMD_LIBVERSION:
1709           cmd = pargs.r_opt;
1710           break;
1711
1712         case OPT_DEBUG: opt_debug = 1; break;
1713
1714         default:
1715           pargs.err = ARGPARSE_PRINT_WARNING;
1716           break;
1717         }
1718     }
1719   gpgrt_argparse (NULL, &pargs, NULL);
1720
1721   if (!opt_debug)
1722     {
1723       const char *s = getenv ("GPGME_JSON_DEBUG");
1724       if (s && atoi (s) > 0)
1725         opt_debug = 1;
1726     }
1727
1728   if (opt_debug)
1729     {
1730       const char *home = getenv ("HOME");
1731       char *file = xstrconcat ("socket://",
1732                                home? home:"/tmp",
1733                                "/.gnupg/S.gpgme-json.log", NULL);
1734       log_set_file (file);
1735       xfree (file);
1736     }
1737
1738   if (opt_debug)
1739     { int i;
1740       for (i=0; argv[i]; i++)
1741         log_debug ("argv[%d]='%s'\n", i, argv[i]);
1742     }
1743
1744   switch (cmd)
1745     {
1746     case CMD_DEFAULT:
1747       native_messaging_repl ();
1748       break;
1749
1750     case CMD_SINGLE:
1751       read_and_process_single_request ();
1752       break;
1753
1754     case CMD_INTERACTIVE:
1755       interactive_repl ();
1756       break;
1757
1758     case CMD_LIBVERSION:
1759       printf ("Version from header: %s (0x%06x)\n",
1760               GPGME_VERSION, GPGME_VERSION_NUMBER);
1761       printf ("Version from binary: %s\n", gpgme_check_version (NULL));
1762       printf ("Copyright blurb ...:%s\n", gpgme_check_version ("\x01\x01"));
1763       break;
1764     }
1765
1766   if (opt_debug)
1767     log_debug ("ready");
1768
1769 #endif /* This is a modern libgp-error.  */
1770   return 0;
1771 }
1772 #endif /* libgpg-error >= 1.28 */