* certpath.c (gpgsm_validate_path): Ask the agent to add the
[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 to 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.
86
87 */
88 static int
89 cmd_learn (ASSUAN_CONTEXT ctx, char *line)
90 {
91   CTRL ctrl = assuan_get_pointer (ctx);
92   int rc = 0;
93
94   /* if this is the first command issued for a new card, open the card and 
95      and create a context */
96   if (!ctrl->card_ctx)
97     {
98       rc = card_open (&ctrl->card_ctx);
99       if (rc)
100         return map_to_assuan_status (rc);
101     }
102
103   /* Unless the force option is used we try a shortcut by identifying
104      the card using a serial number and inquiring the client with
105      that. The client may choose to cancel the operation if he already
106      knows about this card */
107   if (!has_option (line, "--force"))
108     {
109       char *serial;
110       time_t stamp;
111       char *command;
112
113       rc = card_get_serial_and_stamp (ctrl->card_ctx, &serial, &stamp);
114       if (rc)
115         return map_to_assuan_status (rc);
116
117       rc = asprintf (&command, "KNOWNCARDP %s %lu",
118                      serial, (unsigned long)stamp);
119       xfree (serial);
120       if (rc < 0)
121         return ASSUAN_Out_Of_Core;
122       rc = 0;
123       rc = assuan_inquire (ctx, command, NULL, NULL, 0); 
124       free (command);  /* (must use standard free here) */
125       if (rc)
126         {
127           if (rc != ASSUAN_Canceled)
128             log_error ("inquire KNOWNCARDP failed: %s\n",
129                        assuan_strerror (rc));
130           return rc; 
131         }
132       /* not canceled, so we have to proceeed */
133     }
134
135   return map_to_assuan_status (rc);
136 }
137
138
139
140
141
142 \f
143 /* Tell the assuan library about our commands */
144 static int
145 register_commands (ASSUAN_CONTEXT ctx)
146 {
147   static struct {
148     const char *name;
149     int cmd_id;
150     int (*handler)(ASSUAN_CONTEXT, char *line);
151   } table[] = {
152     { "LEARN", 0, cmd_learn },
153     { "",     ASSUAN_CMD_INPUT, NULL }, 
154     { "",     ASSUAN_CMD_OUTPUT, NULL }, 
155     { NULL }
156   };
157   int i, j, rc;
158
159   for (i=j=0; table[i].name; i++)
160     {
161       rc = assuan_register_command (ctx,
162                                     table[i].cmd_id? table[i].cmd_id
163                                                    : (ASSUAN_CMD_USER + j++),
164                                     table[i].name, table[i].handler);
165       if (rc)
166         return rc;
167     } 
168   assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
169
170   assuan_register_reset_notify (ctx, reset_notify);
171   assuan_register_option_handler (ctx, option_handler);
172   return 0;
173 }
174
175
176 /* Startup the server.  If LISTEN_FD is given as -1, this is simple
177    piper server, otherwise it is a regular server */
178 void
179 scd_command_handler (int listen_fd)
180 {
181   int rc;
182   ASSUAN_CONTEXT ctx;
183   struct server_control_s ctrl;
184
185   memset (&ctrl, 0, sizeof ctrl);
186   scd_init_default_ctrl (&ctrl);
187   
188   if (listen_fd == -1)
189     {
190       int filedes[2];
191
192       filedes[0] = 0;
193       filedes[1] = 1;
194       rc = assuan_init_pipe_server (&ctx, filedes);
195     }
196   else
197     {
198       rc = assuan_init_socket_server (&ctx, listen_fd);
199     }
200   if (rc)
201     {
202       log_error ("failed to initialize the server: %s\n",
203                  assuan_strerror(rc));
204       scd_exit (2);
205     }
206   rc = register_commands (ctx);
207   if (rc)
208     {
209       log_error ("failed to register commands with Assuan: %s\n",
210                  assuan_strerror(rc));
211       scd_exit (2);
212     }
213   assuan_set_pointer (ctx, &ctrl);
214   ctrl.server_local = xcalloc (1, sizeof *ctrl.server_local);
215   ctrl.server_local->assuan_ctx = ctx;
216
217   if (DBG_ASSUAN)
218     assuan_set_log_stream (ctx, log_get_stream ());
219
220   for (;;)
221     {
222       rc = assuan_accept (ctx);
223       if (rc == -1)
224         {
225           break;
226         }
227       else if (rc)
228         {
229           log_info ("Assuan accept problem: %s\n", assuan_strerror (rc));
230           break;
231         }
232       
233       rc = assuan_process (ctx);
234       if (rc)
235         {
236           log_info ("Assuan processing failed: %s\n", assuan_strerror (rc));
237           continue;
238         }
239     }
240   reset_notify (ctx); /* used for cleanup */
241
242   assuan_deinit_server (ctx);
243 }