gnupg/scd/apdu.c

/* apdu.c - ISO 7816 APDU functions and low level I/O
 *	Copyright (C) 2003 Free Software Foundation, Inc.
 *
 * This file is part of GnuPG.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * 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
 */

#include <config.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>

#include "scdaemon.h"
#include "apdu.h"

#define HAVE_CTAPI 1

#define MAX_READER 4 /* Number of readers we support concurrently. */
#define CARD_CONNECT_TIMEOUT 30 /* Number of seconds to wait for
                                   insertion of the card. */



/* A global table to keep track of active readers. */
static struct {
  int used;            /* True if slot is used. */
  unsigned short port; /* port number0 = unused, 1 - dev/tty */
  int status;
  unsigned char atr[33];
  size_t atrlen;
} reader_table[MAX_READER];                          


/* ct API function pointer. */
static char (*CT_init) (unsigned short ctn, unsigned short Pn);
static char (*CT_data) (unsigned short ctn, unsigned char *dad,
                        unsigned char *sad, unsigned short lc,
                        unsigned char *cmd, unsigned short *lr,
                        unsigned char *rsp);
static char (*CT_close) (unsigned short ctn);





/* 
      Helper
 */
 

/* Find an unused reader slot for PORT and put it into the reader
   table.  Return -1 on error or the index into the reader table. */
static int 
new_reader_slot (int port)    
{
  int i, reader = -1;

  if (port < 0 || port > 0xffff)
    {
      log_error ("new_reader_slot: invalid port %d requested\n", port);
      return -1;
    }

  for (i=0; i < MAX_READER; i++)
    {
      if (reader_table[i].used && reader_table[i].port == port)
        {
          log_error ("new_reader_slot: requested port %d already in use\n",
                     reader);
          return -1; 
        }
      else if (!reader_table[i].used && reader == -1)
        reader = i;
    }
  if (reader == -1)
    {
      log_error ("new_reader_slot: out of slots\n");
      return -1;
    }
  reader_table[reader].used = 1;
  reader_table[reader].port = port;
  return reader;
}


static void
dump_reader_status (int reader)
{
  log_info ("reader %d: %s\n", reader,
            reader_table[reader].status == 1? "Processor ICC present" :
            reader_table[reader].status == 0? "Memory ICC present" :
                                              "ICC not present" );
 
  if (reader_table[reader].status != -1)
    {
      log_info ("reader %d: ATR=", reader);
      log_printhex ("", reader_table[reader].atr,
                    reader_table[reader].atrlen);
    }
}



#ifdef HAVE_CTAPI
/* 
       ct API Interface 
 */

static const char *
ct_error_string (int err)
{
  switch (err)
    {
    case 0: return "okay";
    case -1: return "invalid data";
    case -8: return "ct error";
    case -10: return "transmission error";
    case -11: return "memory allocation error";
    case -128: return "HTSI error";
    default: return "unknown CT-API error";
    }
}

/* Wait for the card in READER and activate it.  Return -1 on error or
   0 on success. */
static int
ct_activate_card (int reader)
{
  int rc, count;

  for (count = 0; count < CARD_CONNECT_TIMEOUT; count++)
    {
      unsigned char dad[1], sad[1], cmd[11], buf[256];
      unsigned short buflen;

      /* Check whether card has been inserted. */
      dad[0] = 1;     /* Destination address: CT. */    
      sad[0] = 2;     /* Source address: Host. */

      cmd[0] = 0x20;  /* Class byte. */
      cmd[1] = 0x13;  /* Request status. */
      cmd[2] = 0x00;  /* From kernel. */
      cmd[3] = 0x80;  /* Return card's DO. */
      cmd[4] = 0x00;

      buflen = DIM(buf);

      rc = CT_data (reader, dad, sad, 5, cmd, &buflen, buf);
      if (rc || buflen < 2 || buf[buflen-2] != 0x90)
        {
          log_error ("ct_activate_card: can't get status of reader %d: %s\n",
                     reader, ct_error_string (rc));
          return -1;
        }

      if (buf[0] == 0x05)
        { /* Connected, now activate the card. */           
          dad[0] = 1;    /* Destination address: CT. */    
          sad[0] = 2;    /* Source address: Host. */

          cmd[0] = 0x20;  /* Class byte. */
          cmd[1] = 0x12;  /* Request ICC. */
          cmd[2] = 0x01;  /* From first interface. */
          cmd[3] = 0x01;  /* Return card's ATR. */
          cmd[4] = 0x00;

          buflen = DIM(buf);

          rc = CT_data (reader, dad, sad, 5, cmd, &buflen, buf);
          if (rc || buflen < 2 || buf[buflen-2] != 0x90)
            {
              log_error ("ct_activate_card(%d): activation failed: %s\n",
                         reader, ct_error_string (rc));
              return -1;
            }

          /* Store the type and the ATR. */
          if (buflen - 2 > DIM (reader_table[0].atr))
            {
              log_error ("ct_activate_card(%d): ATR too long\n", reader);
              return -1;
            }

          reader_table[reader].status = buf[buflen - 1];
          memcpy (reader_table[reader].atr, buf, buflen - 2);
          reader_table[reader].atrlen = buflen - 2;
          return 0;
        }

      sleep (1); /* FIXME: we should use a more reliable timer. */
    }
 
  log_info ("ct_activate_card(%d): timeout waiting for card\n", reader);
  return -1;
}


/* Open a reader and return an internal handle for it.  PORT is a
   non-negative value with the port number of the reader. USB readers
   do habe port numbers starting at 32769. */
static int
open_ct_reader (int port)
{
  int rc, reader;

  reader = new_reader_slot (port);
  if (reader == -1)
    return reader;

  rc = CT_init (reader, (unsigned short)port);
  if (rc)
    {
      log_error ("apdu_open_ct_reader failed on port %d: %s\n",
                 port, ct_error_string (rc));
      reader_table[reader].used = 0;
      return -1;
    }

  rc = ct_activate_card (reader);
  if (rc)
    {
      reader_table[reader].used = 0;
      return -1;
    }

  dump_reader_status (reader);
  return reader;
}


#endif /*HAVE_CTAPI*/


#ifdef HAVE_PCSC
/* 
       PC/SC Interface
 */


#endif /*HAVE_PCSC*/


/* 
       Driver Access
 */

/* Open the reader and return an internal slot number or -1 on
   error. */
int
apdu_open_reader (int port)
{
  static int ct_api_loaded;

  if (!ct_api_loaded)
    {
      void *handle;

      handle = dlopen ("libtowitoko.so", RTLD_LAZY);
      if (!handle)
        {
          log_error ("apdu_open_reader: failed to open driver: %s",
                     dlerror ());
          return -1;
        }
      CT_init = dlsym (handle, "CT_init");
      CT_data = dlsym (handle, "CT_data");
      CT_close = dlsym (handle, "CT_close");
      if (!CT_init || !CT_data || !CT_close)
        {
          log_error ("apdu_open_reader: invalid driver\n");
          dlclose (handle);
          return -1;
        }
      ct_api_loaded = 1;
    }
  return open_ct_reader (port);
}