3702ae348cadc0f4562f6457536a1d541747ed4d
[gnupg.git] / scd / card.c
1 /* card.c - SCdaemon card functions
2  *      Copyright (C) 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 <time.h>
27
28 #include <opensc-pkcs15.h>
29
30 #include "scdaemon.h"
31
32
33
34 struct card_ctx_s {
35   int reader;   /* used reader */
36   struct sc_context *ctx;
37   struct sc_card *scard;
38   struct sc_pkcs15_card *p15card; /* only if there is a pkcs15 application */
39   
40 };
41
42 /* Map the SC error codes to the GNUPG ones */
43 static int
44 map_sc_err (int rc)
45 {
46   switch (rc)
47     {
48     case 0: rc = 0; break;
49     case SC_ERROR_CMD_TOO_SHORT:         rc = GNUPG_Card_Error; break;
50     case SC_ERROR_CMD_TOO_LONG:          rc = GNUPG_Card_Error; break;
51     case SC_ERROR_NOT_SUPPORTED:         rc = GNUPG_Not_Supported; break;
52     case SC_ERROR_TRANSMIT_FAILED:       rc = GNUPG_Card_Error; break;
53     case SC_ERROR_FILE_NOT_FOUND:        rc = GNUPG_Card_Error; break;
54     case SC_ERROR_INVALID_ARGUMENTS:     rc = GNUPG_Card_Error; break;
55     case SC_ERROR_PKCS15_APP_NOT_FOUND:  rc = GNUPG_No_PKCS15_App; break;
56     case SC_ERROR_REQUIRED_PARAMETER_NOT_FOUND: rc = GNUPG_Card_Error; break;
57     case SC_ERROR_OUT_OF_MEMORY:         rc = GNUPG_Out_Of_Core; break;
58     case SC_ERROR_NO_READERS_FOUND:      rc = GNUPG_Card_Error; break;
59     case SC_ERROR_OBJECT_NOT_VALID:      rc = GNUPG_Card_Error; break;
60     case SC_ERROR_ILLEGAL_RESPONSE:      rc = GNUPG_Card_Error; break;
61     case SC_ERROR_PIN_CODE_INCORRECT:    rc = GNUPG_Card_Error; break;
62     case SC_ERROR_SECURITY_STATUS_NOT_SATISFIED: rc = GNUPG_Card_Error; break;
63     case SC_ERROR_CONNECTING_TO_RES_MGR: rc = GNUPG_Card_Error; break;
64     case SC_ERROR_INVALID_ASN1_OBJECT:   rc = GNUPG_Card_Error; break;
65     case SC_ERROR_BUFFER_TOO_SMALL:      rc = GNUPG_Card_Error; break;
66     case SC_ERROR_CARD_NOT_PRESENT:      rc = GNUPG_Card_Not_Present; break;
67     case SC_ERROR_RESOURCE_MANAGER:      rc = GNUPG_Card_Error; break;
68     case SC_ERROR_CARD_REMOVED:          rc = GNUPG_Card_Removed; break;
69     case SC_ERROR_INVALID_PIN_LENGTH:    rc = GNUPG_Card_Error; break;
70     case SC_ERROR_UNKNOWN_SMARTCARD:     rc = GNUPG_Card_Error; break;
71     case SC_ERROR_UNKNOWN_REPLY:         rc = GNUPG_Card_Error; break;
72     case SC_ERROR_OBJECT_NOT_FOUND:      rc = GNUPG_Card_Error; break;
73     case SC_ERROR_CARD_RESET:            rc = GNUPG_Card_Reset; break;
74     case SC_ERROR_ASN1_OBJECT_NOT_FOUND: rc = GNUPG_Card_Error; break;
75     case SC_ERROR_ASN1_END_OF_CONTENTS:  rc = GNUPG_Card_Error; break;
76     case SC_ERROR_TOO_MANY_OBJECTS:      rc = GNUPG_Card_Error; break;
77     case SC_ERROR_INVALID_CARD:          rc = GNUPG_Invalid_Card; break;
78     case SC_ERROR_WRONG_LENGTH:          rc = GNUPG_Card_Error; break;
79     case SC_ERROR_RECORD_NOT_FOUND:      rc = GNUPG_Card_Error; break;
80     case SC_ERROR_INTERNAL:              rc = GNUPG_Card_Error; break;
81     default: rc = GNUPG_Card_Error; break;
82     }
83   return rc;
84 }
85
86
87 /* Create a new context for the card and figures out some basic
88    information of the card.  Detects whether a PKCS_15 application is
89    stored.
90
91    Common errors: GNUPG_Card_Not_Present */
92 int
93 card_open (CARD *rcard)
94 {
95   CARD card;
96   int rc;
97
98   card = xtrycalloc (1, sizeof *card);
99   if (!card)
100     return GNUPG_Out_Of_Core;
101   card->reader = 0;
102   
103   rc = sc_establish_context (&card->ctx);
104   if (rc)
105     {
106       log_error ("failed to establish SC context: %s\n", sc_strerror (rc));
107       rc = map_sc_err (rc);
108       goto leave;
109     }
110   if (card->reader >= card->ctx->reader_count)
111     {
112       log_error ("no card reader available\n");
113       rc = GNUPG_Card_Error;
114     }
115   card->ctx->error_file = log_get_stream ();
116   card->ctx->debug_file = log_get_stream ();
117   if (sc_detect_card (card->ctx, card->reader) != 1)
118     {
119       rc = GNUPG_Card_Not_Present;
120       goto leave;
121     }
122
123   rc = sc_connect_card (card->ctx, card->reader, &card->scard);
124   if (rc)
125     {
126       log_error ("failed to connect card in reader %d: %s\n",
127                  card->reader, sc_strerror (rc));
128       rc = map_sc_err (rc);
129       goto leave;
130     }
131   if (opt.verbose)
132     log_info ("connected to card in reader %d using driver `%s'\n",
133               card->reader, card->scard->driver->name);
134
135   rc = sc_lock (card->scard);
136   if (rc)
137     {
138       log_error ("can't lock card in reader %d: %s\n",
139                  card->reader, sc_strerror (rc));
140       rc = map_sc_err (rc);
141       goto leave;
142     }
143
144   rc = sc_pkcs15_bind (card->scard, &card->p15card);
145   if (rc == SC_ERROR_PKCS15_APP_NOT_FOUND)
146     rc = 0; /* okay */
147   else if (rc)
148     {
149       log_error ("binding of existing PKCS-15 failed in reader %d: %s\n",
150                  card->reader, sc_strerror (rc));
151       rc = map_sc_err (rc);
152       goto leave;
153     }
154     
155  leave:
156   if (rc)
157     card_close (card);
158   else
159     *rcard = card;
160   return rc;
161 }
162
163
164 /* Close a card and release all resources */
165 void
166 card_close (CARD card)
167 {
168   if (card)
169     {
170       if (card->p15card)
171         {
172           sc_pkcs15_unbind (card->p15card);
173           card->p15card = NULL;
174         }
175       if (card->scard)
176         {
177           sc_unlock (card->scard);
178           sc_disconnect_card (card->scard);
179           card->scard = NULL;
180         }
181       if (card->ctx)
182         {
183           sc_destroy_context (card->ctx);
184           card->ctx = NULL;
185         }
186       xfree (card);
187     }      
188 }
189
190 /* Retrieve the serial number and the time of the last update of the
191    card.  The serial number is returned as a malloced string (hex
192    encoded) in SERIAL and the time of update is returned in STAMP.
193    If no update time is available the returned value is 0.  The serial
194    is mandatory for a PKCS_15 application and an error will be
195    returned if this value is not availbale.  For non-PKCS-15 cards a
196    serial number is constructed by other means. Caller must free
197    SERIAL unless the fucntion returns an error. */
198 int 
199 card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
200 {
201   char *s;
202
203   if (!card || !serial || !stamp)
204     return GNUPG_Invalid_Value;
205
206   *serial = NULL;
207   *stamp = 0; /* not available */
208   if (!card->p15card)
209     { /* fixme: construct a serial number */
210       /* We should lookup the iso 7812-1 and 8583-3 - argh ISO practice is
211          suppressing innovation - IETF rules! */
212       return GNUPG_No_PKCS15_App;
213     }
214   s = card->p15card->serial_number;
215   if (!s || !hexdigitp (s) )
216     return GNUPG_Invalid_Card; /* the serial number is mandatory */
217   *serial = xstrdup (s);
218   if (!*serial)
219     return GNUPG_Out_Of_Core;
220   return 0;
221 }