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