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