g10: Fix another race condition for trustdb access.
[gnupg.git] / g10 / server.c
1 /* server.c - server mode for gpg
2  * Copyright (C) 2006, 2008  Free Software Foundation, Inc.
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 <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <stdarg.h>
26 #include <ctype.h>
27 #include <unistd.h>
28
29
30 #include "gpg.h"
31 #include <assuan.h>
32 #include "util.h"
33 #include "i18n.h"
34 #include "options.h"
35 #include "../common/server-help.h"
36 #include "../common/sysutils.h"
37 #include "status.h"
38
39
40 #define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
41
42
43 /* Data used to associate an Assuan context with local server data.  */
44 struct server_local_s
45 {
46   /* Our current Assuan context. */
47   assuan_context_t assuan_ctx;
48   /* File descriptor as set by the MESSAGE command. */
49   gnupg_fd_t message_fd;
50
51   /* List of prepared recipients.  */
52   pk_list_t recplist;
53
54   /* Set if pinentry notifications should be passed back to the
55      client. */
56   int allow_pinentry_notify;
57 };
58
59
60 \f
61 /* Helper to close the message fd if it is open. */
62 static void
63 close_message_fd (ctrl_t ctrl)
64 {
65   if (ctrl->server_local->message_fd != GNUPG_INVALID_FD)
66     {
67       assuan_sock_close (ctrl->server_local->message_fd);
68       ctrl->server_local->message_fd = GNUPG_INVALID_FD;
69     }
70 }
71
72 \f
73 /* Called by libassuan for Assuan options.  See the Assuan manual for
74    details. */
75 static gpg_error_t
76 option_handler (assuan_context_t ctx, const char *key, const char *value)
77 {
78   ctrl_t ctrl = assuan_get_pointer (ctx);
79
80   (void)value;
81
82   /* Fixme: Implement the tty and locale args. */
83   if (!strcmp (key, "display"))
84     {
85     }
86   else if (!strcmp (key, "ttyname"))
87     {
88     }
89   else if (!strcmp (key, "ttytype"))
90     {
91     }
92   else if (!strcmp (key, "lc-ctype"))
93     {
94     }
95   else if (!strcmp (key, "lc-messages"))
96     {
97     }
98   else if (!strcmp (key, "xauthority"))
99     {
100     }
101   else if (!strcmp (key, "pinentry_user_data"))
102     {
103     }
104   else if (!strcmp (key, "list-mode"))
105     {
106       /* This is for now a dummy option. */
107     }
108   else if (!strcmp (key, "allow-pinentry-notify"))
109     {
110       ctrl->server_local->allow_pinentry_notify = 1;
111     }
112   else
113     return gpg_error (GPG_ERR_UNKNOWN_OPTION);
114
115   return 0;
116 }
117
118
119 /* Called by libassuan for RESET commands. */
120 static gpg_error_t
121 reset_notify (assuan_context_t ctx, char *line)
122 {
123   ctrl_t ctrl = assuan_get_pointer (ctx);
124
125   (void)line;
126
127   release_pk_list (ctrl->server_local->recplist);
128   ctrl->server_local->recplist = NULL;
129
130   close_message_fd (ctrl);
131   assuan_close_input_fd (ctx);
132   assuan_close_output_fd (ctx);
133   return 0;
134 }
135
136
137 /* Called by libassuan for INPUT commands. */
138 static gpg_error_t
139 input_notify (assuan_context_t ctx, char *line)
140 {
141 /*   ctrl_t ctrl = assuan_get_pointer (ctx); */
142
143   (void)ctx;
144
145   if (strstr (line, "--armor"))
146     ; /* FIXME */
147   else if (strstr (line, "--base64"))
148     ; /* FIXME */
149   else if (strstr (line, "--binary"))
150     ;
151   else
152     {
153       /* FIXME (autodetect encoding) */
154     }
155   return 0;
156 }
157
158
159 /* Called by libassuan for OUTPUT commands. */
160 static gpg_error_t
161 output_notify (assuan_context_t ctx, char *line)
162 {
163 /*   ctrl_t ctrl = assuan_get_pointer (ctx); */
164
165   (void)ctx;
166
167   if (strstr (line, "--armor"))
168     ; /* FIXME */
169   else if (strstr (line, "--base64"))
170     {
171       /* FIXME */
172     }
173   return 0;
174 }
175
176
177
178 \f
179 /*  RECIPIENT [--hidden] <userID>
180
181    Set the recipient for the encryption.  <userID> should be the
182    internal representation of the key; the server may accept any other
183    way of specification.  If this is a valid and trusted recipient the
184    server does respond with OK, otherwise the return is an ERR with
185    the reason why the recipient can't be used, the encryption will
186    then not be done for this recipient.  If the policy is not to
187    encrypt at all if not all recipients are valid, the client has to
188    take care of this.  All RECIPIENT commands are cumulative until a
189    RESET or an successful ENCRYPT command.  */
190 static gpg_error_t
191 cmd_recipient (assuan_context_t ctx, char *line)
192 {
193   ctrl_t ctrl = assuan_get_pointer (ctx);
194   gpg_error_t err;
195   int hidden;
196
197   hidden = has_option (line,"--hidden");
198   line = skip_options (line);
199
200   /* FIXME: Expand groups
201   if (opt.grouplist)
202     remusr = expand_group (rcpts);
203   else
204     remusr = rcpts;
205   */
206
207   err = find_and_check_key (ctrl, line, PUBKEY_USAGE_ENC, hidden,
208                             &ctrl->server_local->recplist);
209
210   if (err)
211     log_error ("command '%s' failed: %s\n", "RECIPIENT", gpg_strerror (err));
212   return err;
213 }
214
215
216 \f
217 /*  SIGNER <userID>
218
219    Set the signer's keys for the signature creation.  <userID> should
220    be the internal representation of the key; the server may accept
221    any other way of specification.  If this is a valid and usable
222    signing key the server does respond with OK, otherwise it returns
223    an ERR with the reason why the key can't be used, the signing will
224    then not be done for this key.  If the policy is not to sign at all
225    if not all signer keys are valid, the client has to take care of
226    this.  All SIGNER commands are cumulative until a RESET but they
227    are *not* reset by an SIGN command because it can be expected that
228    set of signers are used for more than one sign operation.
229
230    Note that this command returns an INV_RECP status which is a bit
231    strange, but they are very similar.  */
232 static gpg_error_t
233 cmd_signer (assuan_context_t ctx, char *line)
234 {
235   (void)ctx;
236   (void)line;
237   return gpg_error (GPG_ERR_NOT_SUPPORTED);
238 }
239
240
241 \f
242 /*  ENCRYPT
243
244    Do the actual encryption process.  Takes the plaintext from the
245    INPUT command, writes the ciphertext to the file descriptor set
246    with the OUTPUT command, take the recipients from all the
247    recipients set so far with RECIPIENTS.
248
249    If this command fails the clients should try to delete all output
250    currently done or otherwise mark it as invalid.  GPG does ensure
251    that there won't be any security problem with leftover data on the
252    output in this case.
253
254    In most cases this command won't fail because most necessary checks
255    have been done while setting the recipients.  However some checks
256    can only be done right here and thus error may occur anyway (for
257    example, no recipients at all).
258
259    The input, output and message pipes are closed after this
260    command.  */
261 static gpg_error_t
262 cmd_encrypt (assuan_context_t ctx, char *line)
263 {
264   ctrl_t ctrl = assuan_get_pointer (ctx);
265   gpg_error_t err;
266   int inp_fd, out_fd;
267
268   (void)line; /* LINE is not used.  */
269
270   if ( !ctrl->server_local->recplist )
271     {
272       write_status_text (STATUS_NO_RECP, "0");
273       err = gpg_error (GPG_ERR_NO_USER_ID);
274       goto leave;
275     }
276
277   inp_fd = translate_sys2libc_fd (assuan_get_input_fd (ctx), 0);
278   if (inp_fd == -1)
279     {
280       err = set_error (GPG_ERR_ASS_NO_INPUT, NULL);
281       goto leave;
282     }
283   out_fd = translate_sys2libc_fd (assuan_get_output_fd (ctx), 1);
284   if (out_fd == -1)
285     {
286       err = set_error (GPG_ERR_ASS_NO_OUTPUT, NULL);
287       goto leave;
288     }
289
290
291   /* FIXME: GPGSM does this here: Add all encrypt-to marked recipients
292      from the default list. */
293
294   /* fixme: err = ctrl->audit? 0 : start_audit_session (ctrl);*/
295
296   err = encrypt_crypt (ctrl, inp_fd, NULL, NULL, 0,
297                        ctrl->server_local->recplist,
298                        out_fd);
299
300  leave:
301   /* Release the recipient list on success.  */
302   if (!err)
303     {
304       release_pk_list (ctrl->server_local->recplist);
305       ctrl->server_local->recplist = NULL;
306     }
307
308   /* Close and reset the fds. */
309   close_message_fd (ctrl);
310   assuan_close_input_fd (ctx);
311   assuan_close_output_fd (ctx);
312
313   if (err)
314     log_error ("command '%s' failed: %s\n", "ENCRYPT", gpg_strerror (err));
315   return err;
316 }
317
318
319 \f
320 /*  DECRYPT
321
322     This performs the decrypt operation.  */
323 static gpg_error_t
324 cmd_decrypt (assuan_context_t ctx, char *line)
325 {
326   ctrl_t ctrl = assuan_get_pointer (ctx);
327   gpg_error_t err;
328   int inp_fd, out_fd;
329
330   (void)line; /* LINE is not used.  */
331
332   inp_fd = translate_sys2libc_fd (assuan_get_input_fd (ctx), 0);
333   if (inp_fd == -1)
334     return set_error (GPG_ERR_ASS_NO_INPUT, NULL);
335   out_fd = translate_sys2libc_fd (assuan_get_output_fd (ctx), 1);
336   if (out_fd == -1)
337     return set_error (GPG_ERR_ASS_NO_OUTPUT, NULL);
338
339   glo_ctrl.lasterr = 0;
340   err = decrypt_message_fd (ctrl, inp_fd, out_fd);
341   if (!err)
342     err = glo_ctrl.lasterr;
343
344   /* Close and reset the fds. */
345   close_message_fd (ctrl);
346   assuan_close_input_fd (ctx);
347   assuan_close_output_fd (ctx);
348
349   if (err)
350     log_error ("command '%s' failed: %s\n", "DECRYPT", gpg_strerror (err));
351   return err;
352 }
353
354
355 \f
356 /*  VERIFY
357
358    This does a verify operation on the message send to the input-FD.
359    The result is written out using status lines.  If an output FD was
360    given, the signed text will be written to that.
361
362    If the signature is a detached one, the server will inquire about
363    the signed material and the client must provide it.
364  */
365 static gpg_error_t
366 cmd_verify (assuan_context_t ctx, char *line)
367 {
368   int rc;
369 #ifdef HAVE_W32_SYSTEM
370   (void)ctx;
371   (void)line;
372   rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
373 #else
374   ctrl_t ctrl = assuan_get_pointer (ctx);
375   gnupg_fd_t fd = assuan_get_input_fd (ctx);
376   gnupg_fd_t out_fd = assuan_get_output_fd (ctx);
377   estream_t out_fp = NULL;
378
379   /* FIXME: Revamp this code it is nearly to 3 years old and was only
380      intended as a quick test.  */
381
382   (void)line;
383
384   if (fd == GNUPG_INVALID_FD)
385     return gpg_error (GPG_ERR_ASS_NO_INPUT);
386
387   if (out_fd != GNUPG_INVALID_FD)
388     {
389       es_syshd_t syshd;
390
391 #ifdef HAVE_W32_SYSTEM
392       syshd.type = ES_SYSHD_HANDLE;
393       syshd.u.handle = out_fd;
394 #else
395       syshd.type = ES_SYSHD_FD;
396       syshd.u.fd = out_fd;
397 #endif
398       out_fp = es_sysopen_nc (&syshd, "w");
399       if (!out_fp)
400         return set_error (gpg_err_code_from_syserror (), "fdopen() failed");
401     }
402
403   log_debug ("WARNING: The server mode is WORK "
404              "IN PROGRESS and not ready for use\n");
405
406   rc = gpg_verify (ctrl, fd, ctrl->server_local->message_fd, out_fp);
407
408   es_fclose (out_fp);
409   close_message_fd (ctrl);
410   assuan_close_input_fd (ctx);
411   assuan_close_output_fd (ctx);
412 #endif
413
414   if (rc)
415     log_error ("command '%s' failed: %s\n", "VERIFY", gpg_strerror (rc));
416   return rc;
417 }
418
419
420 \f
421 /*  SIGN [--detached]
422
423    Sign the data set with the INPUT command and write it to the sink
424    set by OUTPUT.  With "--detached" specified, a detached signature
425    is created.  */
426 static gpg_error_t
427 cmd_sign (assuan_context_t ctx, char *line)
428 {
429   (void)ctx;
430   (void)line;
431   return gpg_error (GPG_ERR_NOT_SUPPORTED);
432 }
433
434
435 \f
436 /*  IMPORT
437
438   Import keys as read from the input-fd, return status message for
439   each imported one.  The import checks the validity of the key.  */
440 static gpg_error_t
441 cmd_import (assuan_context_t ctx, char *line)
442 {
443   (void)ctx;
444   (void)line;
445   return gpg_error (GPG_ERR_NOT_SUPPORTED);
446 }
447
448
449 \f
450 /*  EXPORT [--data [--armor|--base64]] [--] pattern
451
452    Similar to the --export command line command, this command exports
453    public keys matching PATTERN.  The output is send to the output fd
454    unless the --data option has been used in which case the output
455    gets send inline using regular data lines.  The options "--armor"
456    and "--base" ospecify an output format if "--data" has been used.
457    Recall that in general the output format is set with the OUTPUT
458    command.
459  */
460 static gpg_error_t
461 cmd_export (assuan_context_t ctx, char *line)
462 {
463   (void)ctx;
464   (void)line;
465   return gpg_error (GPG_ERR_NOT_SUPPORTED);
466 }
467
468
469 \f
470 /*  DELKEYS
471
472     Fixme
473 */
474 static gpg_error_t
475 cmd_delkeys (assuan_context_t ctx, char *line)
476 {
477   (void)ctx;
478   (void)line;
479   return gpg_error (GPG_ERR_NOT_SUPPORTED);
480 }
481
482
483 \f
484 /*  MESSAGE FD[=<n>]
485
486    Set the file descriptor to read a message which is used with
487    detached signatures.  */
488 static gpg_error_t
489 cmd_message (assuan_context_t ctx, char *line)
490 {
491   int rc;
492   gnupg_fd_t fd;
493   ctrl_t ctrl = assuan_get_pointer (ctx);
494
495   rc = assuan_command_parse_fd (ctx, line, &fd);
496   if (rc)
497     return rc;
498   if (fd == GNUPG_INVALID_FD)
499     return gpg_error (GPG_ERR_ASS_NO_INPUT);
500   ctrl->server_local->message_fd = fd;
501   return 0;
502 }
503
504
505 \f
506 /* LISTKEYS [<patterns>]
507    LISTSECRETKEYS [<patterns>]
508
509    fixme
510 */
511 static gpg_error_t
512 do_listkeys (assuan_context_t ctx, char *line, int mode)
513 {
514   (void)ctx;
515   (void)line;
516   (void)mode;
517
518   return gpg_error (GPG_ERR_NOT_SUPPORTED);
519 }
520
521
522 static gpg_error_t
523 cmd_listkeys (assuan_context_t ctx, char *line)
524 {
525   return do_listkeys (ctx, line, 3);
526 }
527
528
529 static gpg_error_t
530 cmd_listsecretkeys (assuan_context_t ctx, char *line)
531 {
532   return do_listkeys (ctx, line, 2);
533 }
534
535
536 \f
537 /* GENKEY
538
539    Read the parameters in native format from the input fd and create a
540    new OpenPGP key.
541  */
542 static gpg_error_t
543 cmd_genkey (assuan_context_t ctx, char *line)
544 {
545   (void)ctx;
546   (void)line;
547   return gpg_error (GPG_ERR_NOT_SUPPORTED);
548 }
549
550
551 /* GETINFO <what>
552
553    Multipurpose function to return a variety of information.
554    Supported values for WHAT are:
555
556      version     - Return the version of the program.
557      pid         - Return the process id of the server.
558
559  */
560 static gpg_error_t
561 cmd_getinfo (assuan_context_t ctx, char *line)
562 {
563   int rc;
564
565   if (!strcmp (line, "version"))
566     {
567       const char *s = VERSION;
568       rc = assuan_send_data (ctx, s, strlen (s));
569     }
570   else if (!strcmp (line, "pid"))
571     {
572       char numbuf[50];
573
574       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
575       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
576     }
577   else
578     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
579   return rc;
580 }
581
582 static const char hlp_passwd[] =
583   "PASSWD <userID>\n"
584   "\n"
585   "Change the passphrase of the secret key for USERID.";
586 static gpg_error_t
587 cmd_passwd (assuan_context_t ctx, char *line)
588 {
589   /* ctrl_t ctrl = assuan_get_pointer (ctx); */
590   gpg_error_t err;
591
592   (void)ctx;
593   (void)line;
594   /* line = skip_options (line); */
595
596   err = gpg_error (GPG_ERR_NOT_SUPPORTED);
597
598   return err;
599 }
600
601
602
603 \f
604 /* Helper to register our commands with libassuan. */
605 static int
606 register_commands (assuan_context_t ctx)
607 {
608   static struct
609   {
610     const char *name;
611     assuan_handler_t handler;
612     const char * const help;
613   } table[] = {
614     { "RECIPIENT",     cmd_recipient },
615     { "SIGNER",        cmd_signer    },
616     { "ENCRYPT",       cmd_encrypt   },
617     { "DECRYPT",       cmd_decrypt   },
618     { "VERIFY",        cmd_verify    },
619     { "SIGN",          cmd_sign      },
620     { "IMPORT",        cmd_import    },
621     { "EXPORT",        cmd_export    },
622     { "INPUT",         NULL          },
623     { "OUTPUT",        NULL          },
624     { "MESSAGE",       cmd_message   },
625     { "LISTKEYS",      cmd_listkeys  },
626     { "LISTSECRETKEYS",cmd_listsecretkeys },
627     { "GENKEY",        cmd_genkey    },
628     { "DELKEYS",       cmd_delkeys   },
629     { "GETINFO",       cmd_getinfo   },
630     { "PASSWD",        cmd_passwd,  hlp_passwd},
631     { NULL }
632   };
633   int i, rc;
634
635   for (i=0; table[i].name; i++)
636     {
637       rc = assuan_register_command (ctx, table[i].name,
638                                     table[i].handler, table[i].help);
639       if (rc)
640         return rc;
641     }
642   return 0;
643 }
644
645
646
647 \f
648 /* Startup the server.  CTRL must have been allocated by the caller
649    and set to the default values. */
650 int
651 gpg_server (ctrl_t ctrl)
652 {
653   int rc;
654 #ifndef HAVE_W32_SYSTEM
655   int filedes[2];
656 #endif
657   assuan_context_t ctx = NULL;
658   static const char hello[] = ("GNU Privacy Guard's OpenPGP server "
659                                VERSION " ready");
660
661   /* We use a pipe based server so that we can work from scripts.
662      assuan_init_pipe_server will automagically detect when we are
663      called with a socketpair and ignore FILEDES in this case.  */
664 #ifndef HAVE_W32_SYSTEM
665   filedes[0] = assuan_fdopen (0);
666   filedes[1] = assuan_fdopen (1);
667 #endif
668   rc = assuan_new (&ctx);
669   if (rc)
670     {
671       log_error ("failed to allocate the assuan context: %s\n",
672                  gpg_strerror (rc));
673       goto leave;
674     }
675
676 #ifdef HAVE_W32_SYSTEM
677   rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
678 #else
679   rc = assuan_init_pipe_server (ctx, filedes);
680 #endif
681   if (rc)
682     {
683       log_error ("failed to initialize the server: %s\n", gpg_strerror (rc));
684       goto leave;
685     }
686
687   rc = register_commands (ctx);
688   if (rc)
689     {
690       log_error ("failed to the register commands with Assuan: %s\n",
691                  gpg_strerror(rc));
692       goto leave;
693     }
694
695   assuan_set_pointer (ctx, ctrl);
696   if (opt.verbose || opt.debug)
697     {
698       char *tmp;
699
700       tmp = xtryasprintf ("Home: %s\n"
701                           "Config: %s\n"
702                           "%s",
703                           gnupg_homedir (),
704                           "fixme: need config filename",
705                           hello);
706       if (tmp)
707         {
708           assuan_set_hello_line (ctx, tmp);
709           xfree (tmp);
710         }
711     }
712   else
713     assuan_set_hello_line (ctx, hello);
714   assuan_register_reset_notify (ctx, reset_notify);
715   assuan_register_input_notify (ctx, input_notify);
716   assuan_register_output_notify (ctx, output_notify);
717   assuan_register_option_handler (ctx, option_handler);
718
719   ctrl->server_local = xtrycalloc (1, sizeof *ctrl->server_local);
720   if (!ctrl->server_local)
721     {
722       rc = gpg_error_from_syserror ();
723       goto leave;
724     }
725   ctrl->server_local->assuan_ctx = ctx;
726   ctrl->server_local->message_fd = GNUPG_INVALID_FD;
727
728   for (;;)
729     {
730       rc = assuan_accept (ctx);
731       if (rc == -1)
732         {
733           rc = 0;
734           break;
735         }
736       else if (rc)
737         {
738           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
739           break;
740         }
741
742       rc = assuan_process (ctx);
743       if (rc)
744         {
745           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
746           continue;
747         }
748     }
749
750  leave:
751   if (ctrl->server_local)
752     {
753       release_pk_list (ctrl->server_local->recplist);
754
755       xfree (ctrl->server_local);
756       ctrl->server_local = NULL;
757     }
758   assuan_release (ctx);
759   return rc;
760 }
761
762
763 /* Helper to notify the client about Pinentry events.  Because that
764    might disturb some older clients, this is only done when enabled
765    via an option.  If it is not enabled we tell Windows to allow
766    setting the foreground window right here.  Returns an gpg error
767    code. */
768 gpg_error_t
769 gpg_proxy_pinentry_notify (ctrl_t ctrl, const unsigned char *line)
770 {
771   if (!ctrl || !ctrl->server_local
772       || !ctrl->server_local->allow_pinentry_notify)
773     {
774       gnupg_allow_set_foregound_window ((pid_t)strtoul (line+17, NULL, 10));
775       /* Client might be interested in that event - send as status line.  */
776       if (!strncmp (line, "PINENTRY_LAUNCHED", 17)
777           && (line[17]==' '||!line[17]))
778         {
779           for (line += 17; *line && spacep (line); line++)
780             ;
781           write_status_text (STATUS_PINENTRY_LAUNCHED, line);
782         }
783       return 0;
784     }
785   return assuan_inquire (ctrl->server_local->assuan_ctx, line, NULL, NULL, 0);
786 }