Changes needed to support smartcards. Well, only _support_. There is
[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     }
65 }
66
67
68 static int
69 option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
70 {
71   return 0;
72 }
73
74
75 /* LEARN [--force]
76
77    Learn all useful information of the currently inserted card.  When
78    used without the force options, the command might do an INQUIRE
79    like this:
80
81       INQUIRE KNOWNCARDP <hexstring_with_serialNumber> <timestamp>
82
83    The client should just send an "END" if the processing should go on
84    or a "CANCEL" to force the function to terminate with a Cancel
85    error message.  The response of this command is a list of status
86    lines formatted as this:
87
88      S KEYPAIRINFO <hexstring_with_keygrip> <hexstring_with_id>
89
90    If there is no certificate yet stored on the card a single "X" is
91    returned as the keygrip.
92
93 */
94 static int
95 cmd_learn (ASSUAN_CONTEXT ctx, char *line)
96 {
97   CTRL ctrl = assuan_get_pointer (ctx);
98   int rc = 0;
99   int idx;
100
101   /* if this is the first command issued for a new card, open the card and 
102      and create a context */
103   if (!ctrl->card_ctx)
104     {
105       rc = card_open (&ctrl->card_ctx);
106       if (rc)
107         return map_to_assuan_status (rc);
108     }
109
110   /* Unless the force option is used we try a shortcut by identifying
111      the card using a serial number and inquiring the client with
112      that. The client may choose to cancel the operation if he already
113      knows about this card */
114   {
115     char *serial_and_stamp;
116     char *serial;
117     time_t stamp;
118    
119     rc = card_get_serial_and_stamp (ctrl->card_ctx, &serial, &stamp);
120     if (rc)
121       return map_to_assuan_status (rc);
122     rc = asprintf (&serial_and_stamp, "%s %lu", serial, (unsigned long)stamp);
123     xfree (serial);
124     if (rc < 0)
125       return ASSUAN_Out_Of_Core;
126     rc = 0;
127     assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
128
129     if (!has_option (line, "--force"))
130       {
131         char *command;
132
133         rc = asprintf (&command, "KNOWNCARDP %s", serial_and_stamp);
134         if (rc < 0)
135           {
136             free (serial_and_stamp);
137             return ASSUAN_Out_Of_Core;
138           }
139         rc = 0;
140         rc = assuan_inquire (ctx, command, NULL, NULL, 0); 
141         free (command);  /* (must use standard free here) */
142         if (rc)
143           {
144             if (rc != ASSUAN_Canceled)
145               log_error ("inquire KNOWNCARDP failed: %s\n",
146                          assuan_strerror (rc));
147             free (serial_and_stamp);
148             return rc; 
149           }
150         /* not canceled, so we have to proceeed */
151       }
152     free (serial_and_stamp);
153   }
154
155   for (idx=0; !rc; idx++)
156     {
157       unsigned char keygrip[20];
158       unsigned char *keyid;
159       size_t nkeyid;
160       int no_cert = 0;
161
162       rc = card_enum_keypairs (ctrl->card_ctx, idx, 
163                                keygrip, &keyid, &nkeyid);
164       if (rc == GNUPG_Missing_Certificate && keyid)
165         {
166           /* this does happen with an incomplete personalized
167              card; i.e. during the time we have stored the key on the
168              card but not stored the certificate; probably becuase it
169              has not yet been received back from the CA.  Note that we
170              must release KEYID in this case. */
171           rc = 0; 
172           no_cert = 1;
173         }
174       if (!rc)
175         {
176           char *buf, *p;
177
178           buf = p = xtrymalloc (40+1+9+2*nkeyid+1);
179           if (!buf)
180             rc = GNUPG_Out_Of_Core;
181           else
182             {
183               int i;
184               
185               if (no_cert)
186                 *p++ = 'X';
187               else
188                 {
189                   for (i=0; i < 20; i++, p += 2)
190                     sprintf (p, "%02X", keygrip[i]);
191                 }
192               *p++ = ' ';
193               /* fixme: we need to get the pkcs-15 DF from the card function */
194               p = stpcpy (p, "3F005015.");
195               for (i=0; i < nkeyid; i++, p += 2)
196                 sprintf (p, "%02X", keyid[i]);
197               *p = 0;
198               assuan_write_status (ctx, "KEYPAIRINFO", buf);
199               xfree (buf);
200             }
201         }
202       xfree (keyid);
203     }
204   if (rc == -1)
205     rc = 0;
206
207
208   return map_to_assuan_status (rc);
209 }
210
211
212 \f
213 /* READCERT <hexified_certid>
214
215  */
216 static int
217 cmd_readcert (ASSUAN_CONTEXT ctx, char *line)
218 {
219   CTRL ctrl = assuan_get_pointer (ctx);
220   int rc;
221   unsigned char *cert;
222   size_t ncert;
223
224   if (!ctrl->card_ctx)
225     {
226       rc = card_open (&ctrl->card_ctx);
227       if (rc)
228         return map_to_assuan_status (rc);
229     }
230
231   rc = card_read_cert (ctrl->card_ctx, line, &cert, &ncert);
232   if (rc)
233     {
234       log_error ("card_read_cert failed: %s\n", gnupg_strerror (rc));
235     }
236   if (!rc)
237     {
238       rc = assuan_send_data (ctx, cert, ncert);
239       xfree (cert);
240       if (rc)
241         return rc;
242     }
243
244   return map_to_assuan_status (rc);
245 }
246
247 \f
248 /* Tell the assuan library about our commands */
249 static int
250 register_commands (ASSUAN_CONTEXT ctx)
251 {
252   static struct {
253     const char *name;
254     int cmd_id;
255     int (*handler)(ASSUAN_CONTEXT, char *line);
256   } table[] = {
257     { "LEARN", 0, cmd_learn },
258     { "READCERT", 0, cmd_readcert },
259     { "",     ASSUAN_CMD_INPUT, NULL }, 
260     { "",     ASSUAN_CMD_OUTPUT, NULL }, 
261     { NULL }
262   };
263   int i, j, rc;
264
265   for (i=j=0; table[i].name; i++)
266     {
267       rc = assuan_register_command (ctx,
268                                     table[i].cmd_id? table[i].cmd_id
269                                                    : (ASSUAN_CMD_USER + j++),
270                                     table[i].name, table[i].handler);
271       if (rc)
272         return rc;
273     } 
274   assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
275
276   assuan_register_reset_notify (ctx, reset_notify);
277   assuan_register_option_handler (ctx, option_handler);
278   return 0;
279 }
280
281
282 /* Startup the server.  If LISTEN_FD is given as -1, this is simple
283    piper server, otherwise it is a regular server */
284 void
285 scd_command_handler (int listen_fd)
286 {
287   int rc;
288   ASSUAN_CONTEXT ctx;
289   struct server_control_s ctrl;
290
291   memset (&ctrl, 0, sizeof ctrl);
292   scd_init_default_ctrl (&ctrl);
293   
294   if (listen_fd == -1)
295     {
296       int filedes[2];
297
298       filedes[0] = 0;
299       filedes[1] = 1;
300       rc = assuan_init_pipe_server (&ctx, filedes);
301     }
302   else
303     {
304       rc = assuan_init_socket_server (&ctx, listen_fd);
305     }
306   if (rc)
307     {
308       log_error ("failed to initialize the server: %s\n",
309                  assuan_strerror(rc));
310       scd_exit (2);
311     }
312   rc = register_commands (ctx);
313   if (rc)
314     {
315       log_error ("failed to register commands with Assuan: %s\n",
316                  assuan_strerror(rc));
317       scd_exit (2);
318     }
319   assuan_set_pointer (ctx, &ctrl);
320   ctrl.server_local = xcalloc (1, sizeof *ctrl.server_local);
321   ctrl.server_local->assuan_ctx = ctx;
322
323   if (DBG_ASSUAN)
324     assuan_set_log_stream (ctx, log_get_stream ());
325
326   for (;;)
327     {
328       rc = assuan_accept (ctx);
329       if (rc == -1)
330         {
331           break;
332         }
333       else if (rc)
334         {
335           log_info ("Assuan accept problem: %s\n", assuan_strerror (rc));
336           break;
337         }
338       
339       rc = assuan_process (ctx);
340       if (rc)
341         {
342           log_info ("Assuan processing failed: %s\n", assuan_strerror (rc));
343           continue;
344         }
345     }
346   reset_notify (ctx); /* used for cleanup */
347
348   assuan_deinit_server (ctx);
349 }