Typo fixes
[gnupg.git] / scd / card.c
index 682a766..7a41ab7 100644 (file)
@@ -15,7 +15,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
  */
 
 #include <config.h>
 #ifdef HAVE_OPENSC
 #include <opensc/pkcs15.h>
 #endif
-#include <ksba.h>
 
 #include "scdaemon.h"
+#include <ksba.h>
+
 #include "card-common.h"
 
 /* Map the SC error codes to the GNUPG ones */
@@ -48,20 +50,23 @@ map_sc_err (int rc)
     case SC_ERROR_OUT_OF_MEMORY:         e = GPG_ERR_ENOMEM; break;
     case SC_ERROR_CARD_NOT_PRESENT:      e = GPG_ERR_CARD_NOT_PRESENT; break;
     case SC_ERROR_CARD_REMOVED:          e = GPG_ERR_CARD_REMOVED; break;
-    case SC_ERROR_INVALID_CARD:          e = GPG_ERR_INVALID_CARD; break;
+    case SC_ERROR_INVALID_CARD:          e = GPG_ERR_INV_CARD; break;
 #endif
-    default: e = GPG_ERR_CARD_ERROR; break;
+    default: e = GPG_ERR_CARD; break;
     }
-  return gpg_make_error (GPG_ERR_SOURCE_UNKNOWN, e);
+  /* It does not make much sense to further distingusih the error
+     source between OpenSC and SCD.  Thus we use SCD as source
+     here. */
+  return gpg_err_make (GPG_ERR_SOURCE_SCD, e);
 }
 
 /* Get the keygrip from CERT, return 0 on success */
 int
-card_help_get_keygrip (KsbaCert cert, unsigned char *array)
+card_help_get_keygrip (ksba_cert_t cert, unsigned char *array)
 {
-  GCRY_SEXP s_pkey;
+  gcry_sexp_t s_pkey;
   int rc;
-  KsbaSexp p;
+  ksba_sexp_t p;
   size_t n;
   
   p = ksba_cert_get_public_key (cert);
@@ -88,7 +93,7 @@ card_help_get_keygrip (KsbaCert cert, unsigned char *array)
 
 \f
 /* Create a new context for the card and figures out some basic
-   information of the card.  Detects whgether a PKCS_15 application is
+   information of the card.  Detects whether a PKCS_15 application is
    stored.
 
    Common errors: GPG_ERR_CARD_NOT_PRESENT */
@@ -99,9 +104,12 @@ card_open (CARD *rcard)
   CARD card;
   int rc;
 
+  if (opt.disable_opensc)
+    return gpg_error (GPG_ERR_NOT_SUPPORTED);
+
   card = xtrycalloc (1, sizeof *card);
   if (!card)
-    return out_of_core ();
+    return gpg_error (gpg_err_code_from_errno (errno));
   card->reader = 0;
   
   rc = sc_establish_context (&card->ctx, "scdaemon");
@@ -114,7 +122,7 @@ card_open (CARD *rcard)
   if (card->reader >= card->ctx->reader_count)
     {
       log_error ("no card reader available\n");
-      rc = gpg_error (GPG_ERR_CARD_ERROR);
+      rc = gpg_error (GPG_ERR_CARD);
       goto leave;
     }
   card->ctx->error_file = log_get_stream ();
@@ -196,6 +204,7 @@ card_close (CARD card)
    return a pointer to value as well as its length in NBYTES.  Return
    NULL if it was not found.  Note, that the function does not check
    whether the value fits into the provided buffer. */
+#ifdef HAVE_OPENSC
 static const char *
 find_simple_tlv (const unsigned char *buffer, size_t length,
                  int tag, size_t *nbytes)
@@ -228,11 +237,13 @@ find_simple_tlv (const unsigned char *buffer, size_t length,
       s += len; n -= len;
     }
 }
+#endif /*HAVE_OPENSC*/
 
 /* Find the ICC Serial Number within the provided BUFFER of LENGTH
    (which should contain the GDO file) and return it as a hex encoded
    string and allocated string in SERIAL.  Return an error code when
    the ICCSN was not found. */
+#ifdef HAVE_OPENSC
 static int
 find_iccsn (const unsigned char *buffer, size_t length, char **serial)
 {
@@ -242,7 +253,7 @@ find_iccsn (const unsigned char *buffer, size_t length, char **serial)
 
   s = find_simple_tlv (buffer, length, 0x5A, &n);
   if (!s)
-    return gpg_error (GPG_ERR_CARD_ERROR);
+    return gpg_error (GPG_ERR_CARD);
   length -= s - buffer;
   if (n > length)
     {
@@ -257,22 +268,21 @@ find_iccsn (const unsigned char *buffer, size_t length, char **serial)
           n--;
         }
       else
-        return gpg_error (GPG_ERR_CARD_ERROR); /* Bad encoding; does
-                                                  not fit into
-                                                  buffer. */
+        return gpg_error (GPG_ERR_CARD); /* Bad encoding; does
+                                           not fit into buffer. */
     }
   if (!n)
-    return gpg_error (GPG_ERR_CARD_ERROR); /* Well, that is too short. */
+    return gpg_error (GPG_ERR_CARD); /* Well, that is too short. */
 
   *serial = p = xtrymalloc (2*n+1);
   if (!*serial)
-    return out_of_core ();
+    return gpg_error (gpg_err_code_from_errno (errno));
   for (; n; n--, p += 2, s++)
     sprintf (p, "%02X", *s);
   *p = 0;
   return 0;
 }
-
+#endif /*HAVE_OPENSC*/
 
 /* Retrieve the serial number and the time of the last update of the
    card.  The serial number is returned as a malloced string (hex
@@ -316,8 +326,6 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
         }
       if (card->p15card)
         card_p15_bind (card);
-      else
-        card_dinsig_bind (card);
       card->fnc.initialized = 1;
     }
       
@@ -332,21 +340,21 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
   if (rc)
     {
       log_error ("sc_select_file failed: %s\n", sc_strerror (rc));
-      return gpg_error (GPG_ERR_CARD_ERROR);
+      return gpg_error (GPG_ERR_CARD);
     }
   if (file->type != SC_FILE_TYPE_WORKING_EF
       || file->ef_structure != SC_FILE_EF_TRANSPARENT)
     {
       log_error ("wrong type or structure of GDO file\n");
       sc_file_free (file);
-      return gpg_error (GPG_ERR_CARD_ERROR);
+      return gpg_error (GPG_ERR_CARD);
     }
 
   if (!file->size || file->size >= DIM(buf) )
     { /* FIXME: Use a real parser */
       log_error ("unsupported size of GDO file (%d)\n", file->size);
       sc_file_free (file);
-      return gpg_error (GPG_ERR_CARD_ERROR);
+      return gpg_error (GPG_ERR_CARD);
     }
   buflen = file->size;
       
@@ -355,16 +363,16 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
   if (rc < 0) 
     {
       log_error ("error reading GDO file: %s\n", sc_strerror (rc));
-      return gpg_error (GPG_ERR_CARD_ERROR);
+      return gpg_error (GPG_ERR_CARD);
     }
   if (rc != buflen)
     {
       log_error ("short read on GDO file\n");
-      return gpg_error (GPG_ERR_CARD_ERROR);
+      return gpg_error (GPG_ERR_CARD);
     }
 
   rc = find_iccsn (buf, buflen, serial);
-  if (gpg_err_code (rc) == GPG_ERR_CARD_ERROR)
+  if (gpg_err_code (rc) == GPG_ERR_CARD)
     log_error ("invalid structure of GDO file\n");
   if (!rc && card->p15card && !strcmp (*serial, "D27600000000000000000000"))
     { /* This is a German card with a silly serial number.  Try to get
@@ -380,7 +388,7 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
       *serial = NULL;
       p = xtrymalloc (strlen (efser) + 7);
       if (!p)
-          rc = out_of_core ();
+          rc = gpg_error (gpg_err_code_from_errno (errno));
       else
         {
           strcpy (p, "FF0100");
@@ -396,7 +404,7 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
         {
           xfree (*serial);
           *serial = NULL;
-          rc = out_of_core ();
+          rc = gpg_error (gpg_err_code_from_errno (errno));
         }
       else
         {
@@ -436,7 +444,7 @@ card_enum_keypairs (CARD card, int idx,
   if (!card || !keygrip)
     return gpg_error (GPG_ERR_INV_VALUE);
   if (idx < 0)
-    return gpg_error (GPG_ERR_INVALID_INDEX);
+    return gpg_error (GPG_ERR_INV_INDEX);
   if (!card->fnc.initialized)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!card->fnc.enum_keypairs)
@@ -444,7 +452,7 @@ card_enum_keypairs (CARD card, int idx,
   rc = card->fnc.enum_keypairs (card, idx, keygrip, keyid);
   if (opt.verbose)
     log_info ("card operation enum_keypairs result: %s\n",
-              gnupg_strerror (rc));
+              gpg_strerror (rc));
   return rc;
 }
 
@@ -456,6 +464,7 @@ card_enum_keypairs (CARD card, int idx,
       100 := Regular X.509 cert
       101 := Trusted X.509 cert
       102 := Useful X.509 cert
+      110 := Root CA cert (DINSIG)
  */
 int
 card_enum_certs (CARD card, int idx, char **certid, int *certtype)
@@ -468,7 +477,7 @@ card_enum_certs (CARD card, int idx, char **certid, int *certtype)
   if (!card)
     return gpg_error (GPG_ERR_INV_VALUE);
   if (idx < 0)
-    return gpg_error (GPG_ERR_INVALID_INDEX);
+    return gpg_error (GPG_ERR_INV_INDEX);
   if (!card->fnc.initialized)
     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
   if (!card->fnc.enum_certs)
@@ -476,7 +485,7 @@ card_enum_certs (CARD card, int idx, char **certid, int *certtype)
   rc = card->fnc.enum_certs (card, idx, certid, certtype);
   if (opt.verbose)
     log_info ("card operation enum_certs result: %s\n",
-              gnupg_strerror (rc));
+              gpg_strerror (rc));
   return rc;
 }
 
@@ -500,7 +509,7 @@ card_read_cert (CARD card, const char *certidstr,
     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
   rc = card->fnc.read_cert (card, certidstr, cert, ncert);
   if (opt.verbose)
-    log_info ("card operation read_cert result: %s\n", gnupg_strerror (rc));
+    log_info ("card operation read_cert result: %s\n", gpg_strerror (rc));
   return rc;
 }
 
@@ -513,7 +522,7 @@ card_sign (CARD card, const char *keyidstr, int hashalgo,
            int (pincb)(void*, const char *, char **),
            void *pincb_arg,
            const void *indata, size_t indatalen,
-           void **outdata, size_t *outdatalen )
+           unsigned char **outdata, size_t *outdatalen )
 {
   int rc;
 
@@ -528,7 +537,7 @@ card_sign (CARD card, const char *keyidstr, int hashalgo,
                         indata, indatalen,
                         outdata, outdatalen);
   if (opt.verbose)
-    log_info ("card operation sign result: %s\n", gnupg_strerror (rc));
+    log_info ("card operation sign result: %s\n", gpg_strerror (rc));
   return rc;
 }
 
@@ -541,7 +550,7 @@ card_decipher (CARD card, const char *keyidstr,
                int (pincb)(void*, const char *, char **),
                void *pincb_arg,
                const void *indata, size_t indatalen,
-               void **outdata, size_t *outdatalen )
+               unsigned char **outdata, size_t *outdatalen )
 {
   int rc;
 
@@ -556,6 +565,7 @@ card_decipher (CARD card, const char *keyidstr,
                             indata, indatalen,
                             outdata, outdatalen);
   if (opt.verbose)
-    log_info ("card operation decipher result: %s\n", gnupg_strerror (rc));
+    log_info ("card operation decipher result: %s\n", gpg_strerror (rc));
   return rc;
 }
+