dirmngr: Improve assuan error comment for cmd keyserver.
[gnupg.git] / g13 / sh-cmd.c
1 /* sh-cmd.c - The Assuan server for g13-syshelp
2  * Copyright (C) 2015 Werner Koch
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <stdarg.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "g13-syshelp.h"
29 #include <assuan.h>
30 #include "../common/i18n.h"
31 #include "keyblob.h"
32
33
34 /* Local data for this server module.  A pointer to this is stored in
35    the CTRL object of each connection.  */
36 struct server_local_s
37 {
38   /* The Assuan context we are working on.  */
39   assuan_context_t assuan_ctx;
40
41   /* The malloced name of the device.  */
42   char *devicename;
43
44   /* A stream open for read of the device set by the DEVICE command or
45      NULL if no DEVICE command has been used.  */
46   estream_t devicefp;
47 };
48
49
50
51 \f
52 /* Local prototypes.  */
53
54
55
56 \f
57 /*
58    Helper functions.
59  */
60
61 /* Set an error and a description.  */
62 #define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
63 #define set_error_fail_cmd() set_error (GPG_ERR_NOT_INITIALIZED, \
64                                         "not called via userv or unknown user")
65
66
67 /* Skip over options.  Blanks after the options are also removed.  */
68 static char *
69 skip_options (const char *line)
70 {
71   while (spacep (line))
72     line++;
73   while ( *line == '-' && line[1] == '-' )
74     {
75       while (*line && !spacep (line))
76         line++;
77       while (spacep (line))
78         line++;
79     }
80   return (char*)line;
81 }
82
83
84 /* Check whether the option NAME appears in LINE.  */
85 /* static int */
86 /* has_option (const char *line, const char *name) */
87 /* { */
88 /*   const char *s; */
89 /*   int n = strlen (name); */
90
91 /*   s = strstr (line, name); */
92 /*   if (s && s >= skip_options (line)) */
93 /*     return 0; */
94 /*   return (s && (s == line || spacep (s-1)) && (!s[n] || spacep (s+n))); */
95 /* } */
96
97
98 /* Helper to print a message while leaving a command.  */
99 static gpg_error_t
100 leave_cmd (assuan_context_t ctx, gpg_error_t err)
101 {
102   if (err)
103     {
104       const char *name = assuan_get_command_name (ctx);
105       if (!name)
106         name = "?";
107       if (gpg_err_source (err) == GPG_ERR_SOURCE_DEFAULT)
108         log_error ("command '%s' failed: %s\n", name,
109                    gpg_strerror (err));
110       else
111         log_error ("command '%s' failed: %s <%s>\n", name,
112                    gpg_strerror (err), gpg_strsource (err));
113     }
114   return err;
115 }
116
117
118
119 \f
120 /* The handler for Assuan OPTION commands.  */
121 static gpg_error_t
122 option_handler (assuan_context_t ctx, const char *key, const char *value)
123 {
124   ctrl_t ctrl = assuan_get_pointer (ctx);
125   gpg_error_t err = 0;
126
127   (void)ctrl;
128   (void)key;
129   (void)value;
130
131   if (ctrl->fail_all_cmds)
132     err = set_error_fail_cmd ();
133   else
134     err = gpg_error (GPG_ERR_UNKNOWN_OPTION);
135
136   return err;
137 }
138
139
140 /* The handler for an Assuan RESET command.  */
141 static gpg_error_t
142 reset_notify (assuan_context_t ctx, char *line)
143 {
144   ctrl_t ctrl = assuan_get_pointer (ctx);
145
146   (void)line;
147
148   xfree (ctrl->server_local->devicename);
149   ctrl->server_local->devicename = NULL;
150   es_fclose (ctrl->server_local->devicefp);
151   ctrl->server_local->devicefp = NULL;
152   ctrl->devti = NULL;
153
154   assuan_close_input_fd (ctx);
155   assuan_close_output_fd (ctx);
156   return 0;
157 }
158
159
160 static const char hlp_finddevice[] =
161   "FINDDEVICE <name>\n"
162   "\n"
163   "Find the device matching NAME.  NAME be any identifier from\n"
164   "g13tab permissible for the user.  The corresponding block\n"
165   "device is returned using a status line.";
166 static gpg_error_t
167 cmd_finddevice (assuan_context_t ctx, char *line)
168 {
169   ctrl_t ctrl = assuan_get_pointer (ctx);
170   gpg_error_t err = 0;
171   tab_item_t ti;
172   const char *s;
173   const char *name;
174
175   name = skip_options (line);
176
177   /* Are we allowed to use the given device?  We check several names:
178    *  1. The full block device
179    *  2. The label
180    *  3. The final part of the block device if NAME does not have a slash.
181    *  4. The mountpoint
182    */
183   for (ti=ctrl->client.tab; ti; ti = ti->next)
184     if (!strcmp (name, ti->blockdev))
185       break;
186   if (!ti)
187     {
188       for (ti=ctrl->client.tab; ti; ti = ti->next)
189         if (ti->label && !strcmp (name, ti->label))
190           break;
191     }
192   if (!ti && !strchr (name, '/'))
193     {
194       for (ti=ctrl->client.tab; ti; ti = ti->next)
195         {
196           s = strrchr (ti->blockdev, '/');
197           if (s && s[1] && !strcmp (name, s+1))
198             break;
199         }
200     }
201   if (!ti)
202     {
203       for (ti=ctrl->client.tab; ti; ti = ti->next)
204         if (ti->mountpoint && !strcmp (name, ti->mountpoint))
205           break;
206     }
207
208   if (!ti)
209     {
210       err = set_error (GPG_ERR_NOT_FOUND, "device not configured for user");
211       goto leave;
212     }
213
214   /* Check whether we have permissions to open the device.  */
215   {
216     estream_t fp = es_fopen (ti->blockdev, "rb");
217     if (!fp)
218       {
219         err = gpg_error_from_syserror ();
220         log_error ("error opening '%s': %s\n",
221                    ti->blockdev, gpg_strerror (err));
222         goto leave;
223       }
224     es_fclose (fp);
225   }
226
227   err = g13_status (ctrl, STATUS_BLOCKDEV, ti->blockdev, NULL);
228   if (err)
229     return err;
230
231  leave:
232   return leave_cmd (ctx, err);
233 }
234
235
236 static const char hlp_device[] =
237   "DEVICE <name>\n"
238   "\n"
239   "Set the device used by further commands.\n"
240   "A device name or a PARTUUID string may be used.\n"
241   "Access to that device (by the g13 system) is locked\n"
242   "until a new DEVICE command or end of this process\n";
243 static gpg_error_t
244 cmd_device (assuan_context_t ctx, char *line)
245 {
246   ctrl_t ctrl = assuan_get_pointer (ctx);
247   gpg_error_t err = 0;
248   tab_item_t ti;
249   estream_t fp = NULL;
250
251   line = skip_options (line);
252
253 /* # warning hardwired to /dev/sdb1 ! */
254 /*   if (strcmp (line, "/dev/sdb1")) */
255 /*     { */
256 /*       err = gpg_error (GPG_ERR_ENOENT); */
257 /*       goto leave; */
258 /*     } */
259
260   /* Always close an open device stream of this session. */
261   xfree (ctrl->server_local->devicename);
262   ctrl->server_local->devicename = NULL;
263   es_fclose (ctrl->server_local->devicefp);
264   ctrl->server_local->devicefp = NULL;
265
266   /* Are we allowed to use the given device?  */
267   for (ti=ctrl->client.tab; ti; ti = ti->next)
268     if (!strcmp (line, ti->blockdev))
269       break;
270   if (!ti)
271     {
272       err = set_error (GPG_ERR_EACCES, "device not configured for user");
273       goto leave;
274     }
275
276   ctrl->server_local->devicename = xtrystrdup (line);
277   if (!ctrl->server_local->devicename)
278     {
279       err = gpg_error_from_syserror ();
280       goto leave;
281     }
282
283
284   /* Check whether we have permissions to open the device and keep an
285      FD open.  */
286   fp = es_fopen (ctrl->server_local->devicename, "rb");
287   if (!fp)
288     {
289       err = gpg_error_from_syserror ();
290       log_error ("error opening '%s': %s\n",
291                  ctrl->server_local->devicename, gpg_strerror (err));
292       goto leave;
293     }
294
295   es_fclose (ctrl->server_local->devicefp);
296   ctrl->server_local->devicefp = fp;
297   fp = NULL;
298   ctrl->devti = ti;
299
300   /* Fixme: Take some kind of lock.  */
301
302  leave:
303   es_fclose (fp);
304   if (err)
305     {
306       xfree (ctrl->server_local->devicename);
307       ctrl->server_local->devicename = NULL;
308       ctrl->devti = NULL;
309     }
310   return leave_cmd (ctx, err);
311 }
312
313
314 static const char hlp_create[] =
315   "CREATE <type>\n"
316   "\n"
317   "Create a new encrypted partition on the current device.\n"
318   "<type> must be \"dm-crypt\" for now.";
319 static gpg_error_t
320 cmd_create (assuan_context_t ctx, char *line)
321 {
322   ctrl_t ctrl = assuan_get_pointer (ctx);
323   gpg_error_t err = 0;
324   estream_t fp = NULL;
325
326   line = skip_options (line);
327   if (strcmp (line, "dm-crypt"))
328     {
329       err = set_error (GPG_ERR_INV_ARG, "Type must be \"dm-crypt\"");
330       goto leave;
331     }
332
333   if (!ctrl->server_local->devicename
334       || !ctrl->server_local->devicefp
335       || !ctrl->devti)
336     {
337       err = set_error (GPG_ERR_ENOENT, "No device has been set");
338       goto leave;
339     }
340
341   err = sh_is_empty_partition (ctrl->server_local->devicename);
342   if (err)
343     {
344       if (gpg_err_code (err) == GPG_ERR_FALSE)
345         err = gpg_error (GPG_ERR_CONFLICT);
346       err = assuan_set_error (ctx, err, "Partition is not empty");
347       goto leave;
348     }
349
350   /* We need a writeable stream to create the container.  */
351   fp = es_fopen (ctrl->server_local->devicename, "r+b");
352   if (!fp)
353     {
354       err = gpg_error_from_syserror ();
355       log_error ("error opening '%s': %s\n",
356                  ctrl->server_local->devicename, gpg_strerror (err));
357       goto leave;
358     }
359   if (es_setvbuf (fp, NULL, _IONBF, 0))
360     {
361       err = gpg_error_from_syserror ();
362       log_error ("error setting '%s' to _IONBF: %s\n",
363                  ctrl->server_local->devicename, gpg_strerror (err));
364       goto leave;
365     }
366
367   err = sh_dmcrypt_create_container (ctrl,
368                                      ctrl->server_local->devicename,
369                                      fp);
370   if (es_fclose (fp))
371     {
372       gpg_error_t err2 = gpg_error_from_syserror ();
373       log_error ("error closing '%s': %s\n",
374                  ctrl->server_local->devicename, gpg_strerror (err2));
375       if (!err)
376         err = err2;
377     }
378   fp = NULL;
379
380  leave:
381   es_fclose (fp);
382   return leave_cmd (ctx, err);
383 }
384
385
386 static const char hlp_getkeyblob[] =
387   "GETKEYBLOB\n"
388   "\n"
389   "Return the encrypted keyblob of the current device.";
390 static gpg_error_t
391 cmd_getkeyblob (assuan_context_t ctx, char *line)
392 {
393   ctrl_t ctrl = assuan_get_pointer (ctx);
394   gpg_error_t err;
395   void *enckeyblob = NULL;
396   size_t enckeybloblen;
397
398   line = skip_options (line);
399
400   if (!ctrl->server_local->devicename
401       || !ctrl->server_local->devicefp
402       || !ctrl->devti)
403     {
404       err = set_error (GPG_ERR_ENOENT, "No device has been set");
405       goto leave;
406     }
407
408   err = sh_is_empty_partition (ctrl->server_local->devicename);
409   if (!err)
410     {
411       err = gpg_error (GPG_ERR_ENODEV);
412       assuan_set_error (ctx, err, "Partition is empty");
413       goto leave;
414     }
415   err = 0;
416
417   err = g13_keyblob_read (ctrl->server_local->devicename,
418                           &enckeyblob, &enckeybloblen);
419   if (err)
420     goto leave;
421
422   err = assuan_send_data (ctx, enckeyblob, enckeybloblen);
423   if (!err)
424     err = assuan_send_data (ctx, NULL, 0); /* Flush  */
425
426  leave:
427   xfree (enckeyblob);
428   return leave_cmd (ctx, err);
429 }
430
431
432 static const char hlp_mount[] =
433   "MOUNT <type>\n"
434   "\n"
435   "Mount an encrypted partition on the current device.\n"
436   "<type> must be \"dm-crypt\" for now.";
437 static gpg_error_t
438 cmd_mount (assuan_context_t ctx, char *line)
439 {
440   ctrl_t ctrl = assuan_get_pointer (ctx);
441   gpg_error_t err = 0;
442   unsigned char *keyblob = NULL;
443   size_t keybloblen;
444   tupledesc_t tuples = NULL;
445
446   line = skip_options (line);
447
448   if (strcmp (line, "dm-crypt"))
449     {
450       err = set_error (GPG_ERR_INV_ARG, "Type must be \"dm-crypt\"");
451       goto leave;
452     }
453
454   if (!ctrl->server_local->devicename
455       || !ctrl->server_local->devicefp
456       || !ctrl->devti)
457     {
458       err = set_error (GPG_ERR_ENOENT, "No device has been set");
459       goto leave;
460     }
461
462   err = sh_is_empty_partition (ctrl->server_local->devicename);
463   if (!err)
464     {
465       err = gpg_error (GPG_ERR_ENODEV);
466       assuan_set_error (ctx, err, "Partition is empty");
467       goto leave;
468     }
469   err = 0;
470
471   /* We expect that the client already decrypted the keyblob.
472    * Eventually we should move reading of the keyblob to here and ask
473    * the client to decrypt it.  */
474   assuan_begin_confidential (ctx);
475   err = assuan_inquire (ctx, "KEYBLOB",
476                         &keyblob, &keybloblen, 4 * 1024);
477   assuan_end_confidential (ctx);
478   if (err)
479     {
480       log_error (_("assuan_inquire failed: %s\n"), gpg_strerror (err));
481       goto leave;
482     }
483   err = create_tupledesc (&tuples, keyblob, keybloblen);
484   if (!err)
485     keyblob = NULL;
486   else
487     {
488       if (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED)
489         log_error ("unknown keyblob version received\n");
490       goto leave;
491     }
492
493   err = sh_dmcrypt_mount_container (ctrl,
494                                     ctrl->server_local->devicename,
495                                     tuples);
496
497  leave:
498   destroy_tupledesc (tuples);
499   return leave_cmd (ctx, err);
500 }
501
502
503 static const char hlp_umount[] =
504   "UMOUNT <type>\n"
505   "\n"
506   "Unmount an encrypted partition and wipe the key.\n"
507   "<type> must be \"dm-crypt\" for now.";
508 static gpg_error_t
509 cmd_umount (assuan_context_t ctx, char *line)
510 {
511   ctrl_t ctrl = assuan_get_pointer (ctx);
512   gpg_error_t err = 0;
513
514   line = skip_options (line);
515
516   if (strcmp (line, "dm-crypt"))
517     {
518       err = set_error (GPG_ERR_INV_ARG, "Type must be \"dm-crypt\"");
519       goto leave;
520     }
521
522   if (!ctrl->server_local->devicename
523       || !ctrl->server_local->devicefp
524       || !ctrl->devti)
525     {
526       err = set_error (GPG_ERR_ENOENT, "No device has been set");
527       goto leave;
528     }
529
530   err = sh_dmcrypt_umount_container (ctrl, ctrl->server_local->devicename);
531
532  leave:
533   return leave_cmd (ctx, err);
534 }
535
536
537 static const char hlp_suspend[] =
538   "SUSPEND <type>\n"
539   "\n"
540   "Suspend an encrypted partition and wipe the key.\n"
541   "<type> must be \"dm-crypt\" for now.";
542 static gpg_error_t
543 cmd_suspend (assuan_context_t ctx, char *line)
544 {
545   ctrl_t ctrl = assuan_get_pointer (ctx);
546   gpg_error_t err = 0;
547
548   line = skip_options (line);
549
550   if (strcmp (line, "dm-crypt"))
551     {
552       err = set_error (GPG_ERR_INV_ARG, "Type must be \"dm-crypt\"");
553       goto leave;
554     }
555
556   if (!ctrl->server_local->devicename
557       || !ctrl->server_local->devicefp
558       || !ctrl->devti)
559     {
560       err = set_error (GPG_ERR_ENOENT, "No device has been set");
561       goto leave;
562     }
563
564   err = sh_is_empty_partition (ctrl->server_local->devicename);
565   if (!err)
566     {
567       err = gpg_error (GPG_ERR_ENODEV);
568       assuan_set_error (ctx, err, "Partition is empty");
569       goto leave;
570     }
571   err = 0;
572
573   err = sh_dmcrypt_suspend_container (ctrl, ctrl->server_local->devicename);
574
575  leave:
576   return leave_cmd (ctx, err);
577 }
578
579
580 static const char hlp_resume[] =
581   "RESUME <type>\n"
582   "\n"
583   "Resume an encrypted partition and set the key.\n"
584   "<type> must be \"dm-crypt\" for now.";
585 static gpg_error_t
586 cmd_resume (assuan_context_t ctx, char *line)
587 {
588   ctrl_t ctrl = assuan_get_pointer (ctx);
589   gpg_error_t err = 0;
590   unsigned char *keyblob = NULL;
591   size_t keybloblen;
592   tupledesc_t tuples = NULL;
593
594   line = skip_options (line);
595
596   if (strcmp (line, "dm-crypt"))
597     {
598       err = set_error (GPG_ERR_INV_ARG, "Type must be \"dm-crypt\"");
599       goto leave;
600     }
601
602   if (!ctrl->server_local->devicename
603       || !ctrl->server_local->devicefp
604       || !ctrl->devti)
605     {
606       err = set_error (GPG_ERR_ENOENT, "No device has been set");
607       goto leave;
608     }
609
610   err = sh_is_empty_partition (ctrl->server_local->devicename);
611   if (!err)
612     {
613       err = gpg_error (GPG_ERR_ENODEV);
614       assuan_set_error (ctx, err, "Partition is empty");
615       goto leave;
616     }
617   err = 0;
618
619   /* We expect that the client already decrypted the keyblob.
620    * Eventually we should move reading of the keyblob to here and ask
621    * the client to decrypt it.  */
622   assuan_begin_confidential (ctx);
623   err = assuan_inquire (ctx, "KEYBLOB",
624                         &keyblob, &keybloblen, 4 * 1024);
625   assuan_end_confidential (ctx);
626   if (err)
627     {
628       log_error (_("assuan_inquire failed: %s\n"), gpg_strerror (err));
629       goto leave;
630     }
631   err = create_tupledesc (&tuples, keyblob, keybloblen);
632   if (!err)
633     keyblob = NULL;
634   else
635     {
636       if (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED)
637         log_error ("unknown keyblob version received\n");
638       goto leave;
639     }
640
641   err = sh_dmcrypt_resume_container (ctrl,
642                                      ctrl->server_local->devicename,
643                                      tuples);
644
645  leave:
646   destroy_tupledesc (tuples);
647   return leave_cmd (ctx, err);
648 }
649
650
651 static const char hlp_getinfo[] =
652   "GETINFO <what>\n"
653   "\n"
654   "Multipurpose function to return a variety of information.\n"
655   "Supported values for WHAT are:\n"
656   "\n"
657   "  version     - Return the version of the program.\n"
658   "  pid         - Return the process id of the server.\n"
659   "  showtab     - Show the table for the user.";
660 static gpg_error_t
661 cmd_getinfo (assuan_context_t ctx, char *line)
662 {
663   ctrl_t ctrl = assuan_get_pointer (ctx);
664   gpg_error_t err = 0;
665   char *buf;
666
667   if (!strcmp (line, "version"))
668     {
669       const char *s = PACKAGE_VERSION;
670       err = assuan_send_data (ctx, s, strlen (s));
671     }
672   else if (!strcmp (line, "pid"))
673     {
674       char numbuf[50];
675
676       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
677       err = assuan_send_data (ctx, numbuf, strlen (numbuf));
678     }
679   else if (!strncmp (line, "getsz", 5))
680     {
681       unsigned long long nblocks;
682       err = sh_blockdev_getsz (line+6, &nblocks);
683       if (!err)
684         log_debug ("getsz=%llu\n", nblocks);
685     }
686   else if (!strcmp (line, "showtab"))
687     {
688       tab_item_t ti;
689
690       for (ti=ctrl->client.tab; !err && ti; ti = ti->next)
691         {
692           buf = es_bsprintf ("%s %s%s %s %s%s\n",
693                              ctrl->client.uname,
694                              *ti->blockdev=='/'? "":"partuuid=",
695                              ti->blockdev,
696                              ti->label? ti->label : "-",
697                              ti->mountpoint? " ":"",
698                              ti->mountpoint? ti->mountpoint:"");
699           if (!buf)
700             err = gpg_error_from_syserror ();
701           else
702             {
703               err = assuan_send_data (ctx, buf, strlen (buf));
704               if (!err)
705                 err = assuan_send_data (ctx, NULL, 0); /* Flush  */
706             }
707           xfree (buf);
708         }
709     }
710   else
711     err = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
712
713   return leave_cmd (ctx, err);
714 }
715
716
717 /* This command handler is used for all commands if this process has
718    not been started as expected.  */
719 static gpg_error_t
720 fail_command (assuan_context_t ctx, char *line)
721 {
722   gpg_error_t err;
723   const char *name = assuan_get_command_name (ctx);
724
725   (void)line;
726
727   if (!name)
728     name = "?";
729
730   err = set_error_fail_cmd ();
731   log_error ("command '%s' failed: %s\n", name, gpg_strerror (err));
732   return err;
733 }
734
735
736 /* Tell the Assuan library about our commands.  */
737 static int
738 register_commands (assuan_context_t ctx, int fail_all)
739 {
740   static struct {
741     const char *name;
742     assuan_handler_t handler;
743     const char * const help;
744   } table[] =  {
745     { "FINDDEVICE",    cmd_finddevice, hlp_finddevice },
746     { "DEVICE",        cmd_device, hlp_device },
747     { "CREATE",        cmd_create, hlp_create },
748     { "GETKEYBLOB",    cmd_getkeyblob,  hlp_getkeyblob },
749     { "MOUNT",         cmd_mount,  hlp_mount  },
750     { "UMOUNT",        cmd_umount, hlp_umount  },
751     { "SUSPEND",       cmd_suspend,hlp_suspend},
752     { "RESUME",        cmd_resume, hlp_resume },
753     { "INPUT",         NULL },
754     { "OUTPUT",        NULL },
755     { "GETINFO",       cmd_getinfo, hlp_getinfo },
756     { NULL }
757   };
758   gpg_error_t err;
759   int i;
760
761   for (i=0; table[i].name; i++)
762     {
763       err = assuan_register_command (ctx, table[i].name,
764                                      fail_all ? fail_command : table[i].handler,
765                                      table[i].help);
766       if (err)
767         return err;
768     }
769   return 0;
770 }
771
772
773 /* Startup the server.  */
774 gpg_error_t
775 syshelp_server (ctrl_t ctrl)
776 {
777   gpg_error_t err;
778   assuan_fd_t filedes[2];
779   assuan_context_t ctx = NULL;
780
781   /* We use a pipe based server so that we can work from scripts.
782      assuan_init_pipe_server will automagically detect when we are
783      called with a socketpair and ignore FILEDES in this case. */
784   filedes[0] = assuan_fdopen (0);
785   filedes[1] = assuan_fdopen (1);
786   err = assuan_new (&ctx);
787   if (err)
788     {
789       log_error ("failed to allocate an Assuan context: %s\n",
790                  gpg_strerror (err));
791       goto leave;
792     }
793
794   err = assuan_init_pipe_server (ctx, filedes);
795   if (err)
796     {
797       log_error ("failed to initialize the server: %s\n", gpg_strerror (err));
798       goto leave;
799     }
800
801   err = register_commands (ctx, 0 /*FIXME:ctrl->fail_all_cmds*/);
802   if (err)
803     {
804       log_error ("failed to the register commands with Assuan: %s\n",
805                  gpg_strerror (err));
806       goto leave;
807     }
808
809   assuan_set_pointer (ctx, ctrl);
810
811   {
812     char *tmp = xtryasprintf ("G13-syshelp %s ready to serve requests "
813                               "from %lu(%s)",
814                               PACKAGE_VERSION,
815                               (unsigned long)ctrl->client.uid,
816                               ctrl->client.uname);
817     if (tmp)
818       {
819         assuan_set_hello_line (ctx, tmp);
820         xfree (tmp);
821       }
822   }
823
824   assuan_register_reset_notify (ctx, reset_notify);
825   assuan_register_option_handler (ctx, option_handler);
826
827   ctrl->server_local = xtrycalloc (1, sizeof *ctrl->server_local);
828   if (!ctrl->server_local)
829     {
830       err = gpg_error_from_syserror ();
831       goto leave;
832     }
833   ctrl->server_local->assuan_ctx = ctx;
834
835   while ( !(err = assuan_accept (ctx)) )
836     {
837       err = assuan_process (ctx);
838       if (err)
839         log_info ("Assuan processing failed: %s\n", gpg_strerror (err));
840     }
841   if (err == -1)
842     err = 0;
843   else
844     log_info ("Assuan accept problem: %s\n", gpg_strerror (err));
845
846  leave:
847   reset_notify (ctx, NULL);  /* Release all items hold by SERVER_LOCAL.  */
848   if (ctrl->server_local)
849     {
850       xfree (ctrl->server_local);
851       ctrl->server_local = NULL;
852     }
853
854   assuan_release (ctx);
855   return err;
856 }
857
858
859 gpg_error_t
860 sh_encrypt_keyblob (ctrl_t ctrl, const void *keyblob, size_t keybloblen,
861                     char **r_enckeyblob, size_t *r_enckeybloblen)
862 {
863   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
864   gpg_error_t err;
865   unsigned char *enckeyblob;
866   size_t enckeybloblen;
867
868   *r_enckeyblob = NULL;
869
870   /* Send the plaintext.  */
871   err = g13_status (ctrl, STATUS_PLAINTEXT_FOLLOWS, NULL);
872   if (err)
873     return err;
874   assuan_begin_confidential (ctx);
875   err = assuan_send_data (ctx, keyblob, keybloblen);
876   if (!err)
877     err = assuan_send_data (ctx, NULL, 0);
878   assuan_end_confidential (ctx);
879   if (!err)
880     err = assuan_write_line (ctx, "END");
881   if (err)
882     {
883       log_error (_("error sending data: %s\n"), gpg_strerror (err));
884       return err;
885     }
886
887   /* Inquire the ciphertext.  */
888   err = assuan_inquire (ctx, "ENCKEYBLOB",
889                         &enckeyblob, &enckeybloblen, 16 * 1024);
890   if (err)
891     {
892       log_error (_("assuan_inquire failed: %s\n"), gpg_strerror (err));
893       return err;
894     }
895
896   *r_enckeyblob = enckeyblob;
897   *r_enckeybloblen = enckeybloblen;
898   return 0;
899 }
900
901
902 /* Send a status line with status ID NO.  The arguments are a list of
903    strings terminated by a NULL argument.  */
904 gpg_error_t
905 g13_status (ctrl_t ctrl, int no, ...)
906 {
907   gpg_error_t err = 0;
908   va_list arg_ptr;
909   const char *text;
910
911   va_start (arg_ptr, no);
912
913   if (1)
914     {
915       assuan_context_t ctx = ctrl->server_local->assuan_ctx;
916       char buf[950], *p;
917       size_t n;
918
919       p = buf;
920       n = 0;
921       while ( (text = va_arg (arg_ptr, const char *)) )
922         {
923           if (n)
924             {
925               *p++ = ' ';
926               n++;
927             }
928           for ( ; *text && n < DIM (buf)-2; n++)
929             *p++ = *text++;
930         }
931       *p = 0;
932       err = assuan_write_status (ctx, get_status_string (no), buf);
933     }
934
935   va_end (arg_ptr);
936   return err;
937 }