Started to implement the audit log feature.
[gnupg.git] / g10 / server.c
1 /* server.c - server mode for gpg
2  * Copyright (C) 2006  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 #include <assuan.h>
30
31 #include "gpg.h"
32 #include "util.h"
33 #include "i18n.h"
34 #include "options.h"
35 #include "../common/sysutils.h"
36
37
38 #define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
39
40
41 /* Data used to associate an Assuan context with local server data.  */
42 struct server_local_s 
43 {
44   /* Our current Assuan context. */
45   assuan_context_t assuan_ctx;  
46   /* File descriptor as set by the MESSAGE command. */
47   gnupg_fd_t message_fd;               
48 };
49
50
51 \f
52 /* Helper to close the message fd if it is open. */
53 static void 
54 close_message_fd (ctrl_t ctrl)
55 {
56   if (ctrl->server_local->message_fd != GNUPG_INVALID_FD)
57     {
58       assuan_sock_close (ctrl->server_local->message_fd);
59       ctrl->server_local->message_fd = GNUPG_INVALID_FD;
60     } 
61 }
62
63
64 \f
65 /* Called by libassuan for Assuan options.  See the Assuan manual for
66    details. */
67 static int
68 option_handler (assuan_context_t ctx, const char *key, const char *value)
69 {
70 /*   ctrl_t ctrl = assuan_get_pointer (ctx); */
71
72   /* Fixme: Implement the tty and locale args. */
73   if (!strcmp (key, "display"))
74     {
75     }
76   else if (!strcmp (key, "ttyname"))
77     {
78     }
79   else if (!strcmp (key, "ttytype"))
80     {
81     }
82   else if (!strcmp (key, "lc-ctype"))
83     {
84     }
85   else if (!strcmp (key, "lc-messages"))
86     {
87     }
88   else if (!strcmp (key, "xauthority"))
89     {
90     }
91   else if (!strcmp (key, "pinentry_user_data"))
92     {
93     }
94   else if (!strcmp (key, "list-mode"))
95     {
96       /* This is for now a dummy option. */
97     }
98   else
99     return gpg_error (GPG_ERR_UNKNOWN_OPTION);
100
101   return 0;
102 }
103
104
105 /* Called by libassuan for RESET commands. */
106 static void
107 reset_notify (assuan_context_t ctx)
108 {
109   ctrl_t ctrl = assuan_get_pointer (ctx);
110
111   close_message_fd (ctrl);
112   assuan_close_input_fd (ctx);
113   assuan_close_output_fd (ctx);
114 }
115
116
117 /* Called by libassuan for INPUT commands. */
118 static void
119 input_notify (assuan_context_t ctx, const char *line)
120 {
121 /*   ctrl_t ctrl = assuan_get_pointer (ctx); */
122
123   if (strstr (line, "--armor"))
124     ; /* FIXME */
125   else if (strstr (line, "--base64"))
126     ; /* FIXME */
127   else if (strstr (line, "--binary"))
128     ;
129   else
130     ; /* FIXME (autodetect encoding) */
131 }
132
133
134 /* Called by libassuan for OUTPUT commands. */
135 static void
136 output_notify (assuan_context_t ctx, const char *line)
137 {
138 /*   ctrl_t ctrl = assuan_get_pointer (ctx); */
139
140   if (strstr (line, "--armor"))
141     ; /* FIXME */
142   else if (strstr (line, "--base64"))
143     ; /* FIXME */
144 }
145
146
147
148 \f
149 /*  RECIPIENT <userID>
150
151    Set the recipient for the encryption.  <userID> should be the
152    internal representation of the key; the server may accept any other
153    way of specification.  If this is a valid and trusted recipient the
154    server does respond with OK, otherwise the return is an ERR with
155    the reason why the recipient can't be used, the encryption will
156    then not be done for this recipient.  If the policy is not to
157    encrypt at all if not all recipients are valid, the client has to
158    take care of this.  All RECIPIENT commands are cumulative until a
159    RESET or an successful ENCRYPT command.  */
160 static int 
161 cmd_recipient (assuan_context_t ctx, char *line)
162 {
163   return gpg_error (GPG_ERR_NOT_SUPPORTED);
164 }
165
166
167 \f
168 /*  SIGNER <userID>
169
170    Set the signer's keys for the signature creation.  <userID> should
171    be the internal representation of the key; the server may accept
172    any other way of specification.  If this is a valid and usable
173    signing key the server does respond with OK, otherwise it returns
174    an ERR with the reason why the key can't be used, the signing will
175    then not be done for this key.  If the policy is not to sign at all
176    if not all signer keys are valid, the client has to take care of
177    this.  All SIGNER commands are cumulative until a RESET but they
178    are *not* reset by an SIGN command becuase it can be expected that
179    set of signers are used for more than one sign operation.
180
181    Note that this command returns an INV_RECP status which is a bit
182    strange, but they are very similar.  */
183 static int 
184 cmd_signer (assuan_context_t ctx, char *line)
185 {
186   return gpg_error (GPG_ERR_NOT_SUPPORTED);
187 }
188
189
190 \f
191 /*  ENCRYPT 
192
193    Do the actual encryption process.  Takes the plaintext from the
194    INPUT command, writes to the ciphertext to the file descriptor set
195    with the OUTPUT command, take the recipients form all the
196    recipients set so far.  If this command fails the clients should
197    try to delete all output currently done or otherwise mark it as
198    invalid.  GPG does ensure that there won't be any security problem
199    with leftover data on the output in this case.
200
201    This command should in general not fail, as all necessary checks
202    have been done while setting the recipients.  The input and output
203    pipes are closed.  */
204 static int 
205 cmd_encrypt (assuan_context_t ctx, char *line)
206 {
207   return gpg_error (GPG_ERR_NOT_SUPPORTED);
208 }
209
210
211 \f
212 /*  DECRYPT
213
214    This performs the decrypt operation after doing some checks on the
215    internal state (e.g. that only needed data has been set).   */
216 static int 
217 cmd_decrypt (assuan_context_t ctx, char *line)
218 {
219   return gpg_error (GPG_ERR_NOT_SUPPORTED);
220 }
221
222
223 \f
224 /*  VERIFY
225
226    This does a verify operation on the message send to the input-FD.
227    The result is written out using status lines.  If an output FD was
228    given, the signed text will be written to that.
229   
230    If the signature is a detached one, the server will inquire about
231    the signed material and the client must provide it.
232  */
233 static int 
234 cmd_verify (assuan_context_t ctx, char *line)
235 {
236   int rc;
237   ctrl_t ctrl = assuan_get_pointer (ctx);
238   gnupg_fd_t fd = assuan_get_input_fd (ctx);
239   gnupg_fd_t out_fd = assuan_get_output_fd (ctx);
240   FILE *out_fp = NULL;
241
242   if (fd == GNUPG_INVALID_FD)
243     return gpg_error (GPG_ERR_ASS_NO_INPUT);
244
245   if (out_fd != GNUPG_INVALID_FD)
246     {
247       out_fp = fdopen ( dup (FD2INT (out_fd)), "w");
248       if (!out_fp)
249         return set_error (GPG_ERR_ASS_GENERAL, "fdopen() failed");
250     }
251
252   log_debug ("WARNING: The server mode work "
253              "in progress and not ready for use\n");
254
255   /* Need to dup it because it might get closed and libassuan won't
256      know about it then. */
257   rc = gpg_verify (ctrl,
258                    dup ( FD2INT (fd)), 
259                    dup ( FD2INT (ctrl->server_local->message_fd)),
260                    out_fp);
261
262   if (out_fp)
263     fclose (out_fp);
264   close_message_fd (ctrl);
265   assuan_close_input_fd (ctx);
266   assuan_close_output_fd (ctx);
267
268   return rc;
269 }
270
271
272 \f
273 /*  SIGN [--detached]
274
275    Sign the data set with the INPUT command and write it to the sink
276    set by OUTPUT.  With "--detached" specified, a detached signature
277    is created.  */
278 static int 
279 cmd_sign (assuan_context_t ctx, char *line)
280 {
281   return gpg_error (GPG_ERR_NOT_SUPPORTED);
282 }
283
284
285 \f
286 /*  IMPORT
287
288   Import keys as read from the input-fd, return status message for
289   each imported one.  The import checks the validity of the key.  */
290 static int 
291 cmd_import (assuan_context_t ctx, char *line)
292 {
293   return gpg_error (GPG_ERR_NOT_SUPPORTED);
294 }
295
296
297 \f
298 /*  EXPORT [--data [--armor|--base64]] [--] pattern
299
300    Similar to the --export command line command, this command exports
301    public keys matching PATTERN.  The output is send to the output fd
302    unless the --data option has been used in which case the output
303    gets send inline using regular data lines.  The options "--armor"
304    and "--base" ospecify an output format if "--data" has been used.
305    Recall that in general the output format is set with the OUTPUT
306    command.
307  */
308 static int 
309 cmd_export (assuan_context_t ctx, char *line)
310 {
311   return gpg_error (GPG_ERR_NOT_SUPPORTED);
312 }
313
314
315 \f
316 /*  DELKEYS
317
318     Fixme
319 */
320 static int 
321 cmd_delkeys (assuan_context_t ctx, char *line)
322 {
323   return gpg_error (GPG_ERR_NOT_SUPPORTED);
324 }
325
326
327 \f
328 /*  MESSAGE FD[=<n>]
329
330    Set the file descriptor to read a message which is used with
331    detached signatures.  */
332 static int 
333 cmd_message (assuan_context_t ctx, char *line)
334 {
335   int rc;
336   gnupg_fd_t fd;
337   ctrl_t ctrl = assuan_get_pointer (ctx);
338
339   rc = assuan_command_parse_fd (ctx, line, &fd);
340   if (rc)
341     return rc;
342   if (fd == GNUPG_INVALID_FD)
343     return gpg_error (GPG_ERR_ASS_NO_INPUT);
344   ctrl->server_local->message_fd = fd;
345   return 0;
346 }
347
348
349 \f
350 /* LISTKEYS [<patterns>]
351    LISTSECRETKEYS [<patterns>]
352
353    fixme
354 */
355 static int 
356 do_listkeys (assuan_context_t ctx, char *line, int mode)
357 {
358   return gpg_error (GPG_ERR_NOT_SUPPORTED);
359 }
360
361
362 static int 
363 cmd_listkeys (assuan_context_t ctx, char *line)
364 {
365   return do_listkeys (ctx, line, 3);
366 }
367
368
369 static int 
370 cmd_listsecretkeys (assuan_context_t ctx, char *line)
371 {
372   return do_listkeys (ctx, line, 2);
373 }
374
375
376 \f
377 /* GENKEY
378
379    Read the parameters in native format from the input fd and create a
380    new OpenPGP key.
381  */
382 static int 
383 cmd_genkey (assuan_context_t ctx, char *line)
384 {
385   return gpg_error (GPG_ERR_NOT_SUPPORTED);
386 }
387
388
389
390
391
392 \f
393 /* Helper to register our commands with libassuan. */
394 static int
395 register_commands (assuan_context_t ctx)
396 {
397   static struct 
398   {
399     const char *name;
400     int (*handler)(assuan_context_t, char *line);
401   } table[] = {
402     { "RECIPIENT",     cmd_recipient },
403     { "SIGNER",        cmd_signer    },
404     { "ENCRYPT",       cmd_encrypt   },
405     { "DECRYPT",       cmd_decrypt   },
406     { "VERIFY",        cmd_verify    },
407     { "SIGN",          cmd_sign      },
408     { "IMPORT",        cmd_import    },
409     { "EXPORT",        cmd_export    },
410     { "INPUT",         NULL          }, 
411     { "OUTPUT",        NULL          }, 
412     { "MESSAGE",       cmd_message   },
413     { "LISTKEYS",      cmd_listkeys  },
414     { "LISTSECRETKEYS",cmd_listsecretkeys },
415     { "GENKEY",        cmd_genkey    },
416     { "DELKEYS",       cmd_delkeys   },
417     { NULL }
418   };
419   int i, rc;
420
421   for (i=0; table[i].name; i++)
422     {
423       rc = assuan_register_command (ctx, table[i].name, table[i].handler);
424       if (rc)
425         return rc;
426     } 
427   return 0;
428 }
429
430
431
432 \f
433 /* Startup the server.  CTRL must have been allocated by the caller
434    and set to the default values. */
435 int
436 gpg_server (ctrl_t ctrl)
437 {
438   int rc;
439   int filedes[2];
440   assuan_context_t ctx;
441   static const char hello[] = ("GNU Privacy Guard's OpenPGP server "
442                                VERSION " ready");
443
444   /* We use a pipe based server so that we can work from scripts.
445      assuan_init_pipe_server will automagically detect when we are
446      called with a socketpair and ignore FILEDES in this case.  */
447   filedes[0] = 0;
448   filedes[1] = 1;
449   rc = assuan_init_pipe_server (&ctx, filedes);
450   if (rc)
451     {
452       log_error ("failed to initialize the server: %s\n", gpg_strerror (rc));
453       goto leave;
454     }
455
456   rc = register_commands (ctx);
457   if (rc)
458     {
459       log_error ("failed to the register commands with Assuan: %s\n",
460                  gpg_strerror(rc));
461       goto leave;
462     }
463
464   assuan_set_pointer (ctx, ctrl);
465   if (opt.verbose || opt.debug)
466     {
467       char *tmp = NULL;
468       const char *s1 = getenv ("GPG_AGENT_INFO");
469
470       if (asprintf (&tmp,
471                     "Home: %s\n"
472                     "Config: %s\n"
473                     "AgentInfo: %s\n"
474                     "%s",
475                     opt.homedir,
476                     "fixme: need config filename",
477                     s1?s1:"[not set]",
478                     hello) > 0)
479         {
480           assuan_set_hello_line (ctx, tmp);
481           free (tmp);
482         }
483     }
484   else
485     assuan_set_hello_line (ctx, hello);
486   assuan_register_reset_notify (ctx, reset_notify);
487   assuan_register_input_notify (ctx, input_notify);
488   assuan_register_output_notify (ctx, output_notify);
489   assuan_register_option_handler (ctx, option_handler);
490
491   ctrl->server_local = xtrycalloc (1, sizeof *ctrl->server_local);
492   if (!ctrl->server_local)
493     {
494       rc = gpg_error_from_syserror ();
495       goto leave;
496     }
497   ctrl->server_local->assuan_ctx = ctx;
498   ctrl->server_local->message_fd = GNUPG_INVALID_FD;
499
500   if (DBG_ASSUAN)
501     assuan_set_log_stream (ctx, log_get_stream ());
502
503   for (;;)
504     {
505       rc = assuan_accept (ctx);
506       if (rc == -1)
507         {
508           rc = 0;
509           break;
510         }
511       else if (rc)
512         {
513           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
514           break;
515         }
516       
517       rc = assuan_process (ctx);
518       if (rc)
519         {
520           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
521           continue;
522         }
523     }
524
525  leave:
526   xfree (ctrl->server_local);
527   ctrl->server_local = NULL;
528   assuan_deinit_server (ctx);
529   return rc;
530 }
531