Added more code fragments.
[gnupg.git] / scd / command.c
1 /* command.c - SCdaemon command handler
2  *      Copyright (C) 2001, 2002 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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28
29 #include "scdaemon.h"
30 #include "../assuan/assuan.h"
31
32 #define set_error(e,t) assuan_set_error (ctx, ASSUAN_ ## e, (t))
33
34 /* Data used to associate an Assuan context with local server data */
35 struct server_local_s {
36   ASSUAN_CONTEXT assuan_ctx;
37 };
38
39
40 /* Check whether the option NAME appears in LINE */
41 static int
42 has_option (const char *line, const char *name)
43 {
44   const char *s;
45   int n = strlen (name);
46
47   s = strstr (line, name);
48   return (s && (s == line || spacep (s-1)) && (!s[n] || spacep (s+n)));
49 }
50
51
52
53 \f
54 /* Note, that this reset_notify is also used for cleanup purposes. */
55 static void
56 reset_notify (ASSUAN_CONTEXT ctx)
57 {
58   CTRL ctrl = assuan_get_pointer (ctx); 
59
60   if (ctrl->card_ctx)
61     {
62       card_close (ctrl->card_ctx);
63       ctrl->card_ctx = NULL;
64       xfree (ctrl->in_data.value);
65       ctrl->in_data.value = NULL;
66     }
67 }
68
69
70 static int
71 option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
72 {
73   return 0;
74 }
75
76
77 /* If the card has not yet been opened, do it.  Note that this
78    function returns an Assuan error, so don't map the error a second
79    time */
80 static AssuanError
81 open_card (CTRL ctrl)
82 {
83   if (!ctrl->card_ctx)
84     {
85       int rc = card_open (&ctrl->card_ctx);
86       if (rc)
87         return map_to_assuan_status (rc);
88     }
89   return 0;
90 }
91
92
93 /* SERIALNO 
94
95    Return the serial number of the card using a status reponse.  This
96    functon should be used to check for the presence of a card.
97
98    This function is special in that it can be used to reset the card.
99    Most other functions will return an error when a card change has
100    been detected and the use of this function is therefore required.
101
102    Background: We want to keep the client clear of handling card
103    changes between operations; i.e. the client can assume that all
104    operations are doneon the same card unless he call this function.
105  */
106 static int
107 cmd_serialno (ASSUAN_CONTEXT ctx, char *line)
108 {
109   CTRL ctrl = assuan_get_pointer (ctx);
110   int rc = 0;
111   char *serial_and_stamp;
112   char *serial;
113   time_t stamp;
114
115   if ((rc = open_card (ctrl)))
116     return rc;
117
118   rc = card_get_serial_and_stamp (ctrl->card_ctx, &serial, &stamp);
119   if (rc)
120     return map_to_assuan_status (rc);
121   rc = asprintf (&serial_and_stamp, "%s %lu", serial, (unsigned long)stamp);
122   xfree (serial);
123   if (rc < 0)
124     return ASSUAN_Out_Of_Core;
125   rc = 0;
126   assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
127   free (serial_and_stamp);
128   return 0;
129 }
130
131
132
133
134 /* LEARN [--force]
135
136    Learn all useful information of the currently inserted card.  When
137    used without the force options, the command might do an INQUIRE
138    like this:
139
140       INQUIRE KNOWNCARDP <hexstring_with_serialNumber> <timestamp>
141
142    The client should just send an "END" if the processing should go on
143    or a "CANCEL" to force the function to terminate with a Cancel
144    error message.  The response of this command is a list of status
145    lines formatted as this:
146
147      S KEYPAIRINFO <hexstring_with_keygrip> <hexstring_with_id>
148
149    If there is no certificate yet stored on the card a single "X" is
150    returned as the keygrip.
151
152 */
153 static int
154 cmd_learn (ASSUAN_CONTEXT ctx, char *line)
155 {
156   CTRL ctrl = assuan_get_pointer (ctx);
157   int rc = 0;
158   int idx;
159
160   if ((rc = open_card (ctrl)))
161     return rc;
162
163   /* Unless the force option is used we try a shortcut by identifying
164      the card using a serial number and inquiring the client with
165      that. The client may choose to cancel the operation if he already
166      knows about this card */
167   {
168     char *serial_and_stamp;
169     char *serial;
170     time_t stamp;
171    
172     rc = card_get_serial_and_stamp (ctrl->card_ctx, &serial, &stamp);
173     if (rc)
174       return map_to_assuan_status (rc);
175     rc = asprintf (&serial_and_stamp, "%s %lu", serial, (unsigned long)stamp);
176     xfree (serial);
177     if (rc < 0)
178       return ASSUAN_Out_Of_Core;
179     rc = 0;
180     assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
181
182     if (!has_option (line, "--force"))
183       {
184         char *command;
185
186         rc = asprintf (&command, "KNOWNCARDP %s", serial_and_stamp);
187         if (rc < 0)
188           {
189             free (serial_and_stamp);
190             return ASSUAN_Out_Of_Core;
191           }
192         rc = 0;
193         rc = assuan_inquire (ctx, command, NULL, NULL, 0); 
194         free (command);  /* (must use standard free here) */
195         if (rc)
196           {
197             if (rc != ASSUAN_Canceled)
198               log_error ("inquire KNOWNCARDP failed: %s\n",
199                          assuan_strerror (rc));
200             free (serial_and_stamp);
201             return rc; 
202           }
203         /* not canceled, so we have to proceeed */
204       }
205     free (serial_and_stamp);
206   }
207
208   for (idx=0; !rc; idx++)
209     {
210       unsigned char keygrip[20];
211       unsigned char *keyid;
212       size_t nkeyid;
213       int no_cert = 0;
214
215       rc = card_enum_keypairs (ctrl->card_ctx, idx, 
216                                keygrip, &keyid, &nkeyid);
217       if (rc == GNUPG_Missing_Certificate && keyid)
218         {
219           /* this does happen with an incomplete personalized
220              card; i.e. during the time we have stored the key on the
221              card but not stored the certificate; probably becuase it
222              has not yet been received back from the CA.  Note that we
223              must release KEYID in this case. */
224           rc = 0; 
225           no_cert = 1;
226         }
227       if (!rc)
228         {
229           char *buf, *p;
230
231           buf = p = xtrymalloc (40+1+9+2*nkeyid+1);
232           if (!buf)
233             rc = GNUPG_Out_Of_Core;
234           else
235             {
236               int i;
237               
238               if (no_cert)
239                 *p++ = 'X';
240               else
241                 {
242                   for (i=0; i < 20; i++, p += 2)
243                     sprintf (p, "%02X", keygrip[i]);
244                 }
245               *p++ = ' ';
246               /* fixme: we need to get the pkcs-15 DF from the card function */
247               p = stpcpy (p, "3F005015.");
248               for (i=0; i < nkeyid; i++, p += 2)
249                 sprintf (p, "%02X", keyid[i]);
250               *p = 0;
251               assuan_write_status (ctx, "KEYPAIRINFO", buf);
252               xfree (buf);
253             }
254         }
255       xfree (keyid);
256     }
257   if (rc == -1)
258     rc = 0;
259
260
261   return map_to_assuan_status (rc);
262 }
263
264
265 \f
266 /* READCERT <hexified_certid>
267
268  */
269 static int
270 cmd_readcert (ASSUAN_CONTEXT ctx, char *line)
271 {
272   CTRL ctrl = assuan_get_pointer (ctx);
273   int rc;
274   unsigned char *cert;
275   size_t ncert;
276
277   if ((rc = open_card (ctrl)))
278     return rc;
279
280   rc = card_read_cert (ctrl->card_ctx, line, &cert, &ncert);
281   if (rc)
282     {
283       log_error ("card_read_cert failed: %s\n", gnupg_strerror (rc));
284     }
285   if (!rc)
286     {
287       rc = assuan_send_data (ctx, cert, ncert);
288       xfree (cert);
289       if (rc)
290         return rc;
291     }
292
293   return map_to_assuan_status (rc);
294 }
295
296
297 \f
298
299 /* SETDATA <hexstring> 
300
301    The client should use this command to tell us the data he want to
302    sign.  */
303 static int
304 cmd_setdata (ASSUAN_CONTEXT ctx, char *line)
305 {
306   CTRL ctrl = assuan_get_pointer (ctx);
307   int n;
308   char *p;
309   unsigned char *buf;
310
311   /* parse the hexstring */
312   for (p=line,n=0; hexdigitp (p); p++, n++)
313     ;
314   if (*p)
315     return set_error (Parameter_Error, "invalid hexstring");
316   if ((n&1))
317     return set_error (Parameter_Error, "odd number of digits");
318   n /= 2;
319   buf = xtrymalloc (n);
320   if (!buf)
321     return ASSUAN_Out_Of_Core;
322
323   ctrl->in_data.value = buf;
324   ctrl->in_data.valuelen = n;
325   for (p=line, n=0; n < ctrl->in_data.valuelen; p += 2, n++)
326     buf[n] = xtoi_2 (p);
327   return 0;
328 }
329
330
331
332 /* PKSIGN <hexified_id>
333
334  */
335 static int
336 cmd_pksign (ASSUAN_CONTEXT ctx, char *line)
337 {
338   CTRL ctrl = assuan_get_pointer (ctx);
339   int rc;
340
341   if ((rc = open_card (ctrl)))
342     return rc;
343
344
345
346   return map_to_assuan_status (rc);
347 }
348
349
350
351 \f
352 /* Tell the assuan library about our commands */
353 static int
354 register_commands (ASSUAN_CONTEXT ctx)
355 {
356   static struct {
357     const char *name;
358     int cmd_id;
359     int (*handler)(ASSUAN_CONTEXT, char *line);
360   } table[] = {
361     { "SERIALNO", 0, cmd_serialno },
362     { "LEARN", 0, cmd_learn },
363     { "READCERT", 0, cmd_readcert },
364     { "SETDATA", 0,  cmd_setdata },
365     { "PKSIGN", 0,   cmd_pksign },
366     { "",     ASSUAN_CMD_INPUT, NULL }, 
367     { "",     ASSUAN_CMD_OUTPUT, NULL }, 
368     { NULL }
369   };
370   int i, j, rc;
371
372   for (i=j=0; table[i].name; i++)
373     {
374       rc = assuan_register_command (ctx,
375                                     table[i].cmd_id? table[i].cmd_id
376                                                    : (ASSUAN_CMD_USER + j++),
377                                     table[i].name, table[i].handler);
378       if (rc)
379         return rc;
380     } 
381   assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
382
383   assuan_register_reset_notify (ctx, reset_notify);
384   assuan_register_option_handler (ctx, option_handler);
385   return 0;
386 }
387
388
389 /* Startup the server.  If LISTEN_FD is given as -1, this is simple
390    piper server, otherwise it is a regular server */
391 void
392 scd_command_handler (int listen_fd)
393 {
394   int rc;
395   ASSUAN_CONTEXT ctx;
396   struct server_control_s ctrl;
397
398   memset (&ctrl, 0, sizeof ctrl);
399   scd_init_default_ctrl (&ctrl);
400   
401   if (listen_fd == -1)
402     {
403       int filedes[2];
404
405       filedes[0] = 0;
406       filedes[1] = 1;
407       rc = assuan_init_pipe_server (&ctx, filedes);
408     }
409   else
410     {
411       rc = assuan_init_socket_server (&ctx, listen_fd);
412     }
413   if (rc)
414     {
415       log_error ("failed to initialize the server: %s\n",
416                  assuan_strerror(rc));
417       scd_exit (2);
418     }
419   rc = register_commands (ctx);
420   if (rc)
421     {
422       log_error ("failed to register commands with Assuan: %s\n",
423                  assuan_strerror(rc));
424       scd_exit (2);
425     }
426   assuan_set_pointer (ctx, &ctrl);
427   ctrl.server_local = xcalloc (1, sizeof *ctrl.server_local);
428   ctrl.server_local->assuan_ctx = ctx;
429
430   if (DBG_ASSUAN)
431     assuan_set_log_stream (ctx, log_get_stream ());
432
433   for (;;)
434     {
435       rc = assuan_accept (ctx);
436       if (rc == -1)
437         {
438           break;
439         }
440       else if (rc)
441         {
442           log_info ("Assuan accept problem: %s\n", assuan_strerror (rc));
443           break;
444         }
445       
446       rc = assuan_process (ctx);
447       if (rc)
448         {
449           log_info ("Assuan processing failed: %s\n", assuan_strerror (rc));
450           continue;
451         }
452     }
453   reset_notify (ctx); /* used for cleanup */
454
455   assuan_deinit_server (ctx);
456 }