src/usb-icc.c

   1 /*
   2  * usb-icc.c -- USB CCID protocol handling
   3  *
   4  * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016
   5  *               Free Software Initiative of Japan
   6  * Author: NIIBE Yutaka <gniibe@fsij.org>
   7  *
   8  * This file is a part of Gnuk, a GnuPG USB Token implementation.
   9  *
  10  * Gnuk is free software: you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation, either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
  16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  18  * License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  *
  23  */
  24
  25 #include <stdint.h>
  26 #include <string.h>
  27 #include <chopstx.h>
  28 #include <eventflag.h>
  29
  30 #include "config.h"
  31
  32 #ifdef DEBUG
  33 #include "debug.h"
  34 struct stdout stdout;
  35 #endif
  36
  37 #include "gnuk.h"
  38 #include "usb_lld.h"
  39 #include "usb_conf.h"
  40
  41 /*
  42  * USB buffer size of USB-CCID driver
  43  */
  44 #if MAX_RES_APDU_DATA_SIZE > MAX_CMD_APDU_DATA_SIZE
  45 #define USB_BUF_SIZE (MAX_RES_APDU_DATA_SIZE+5)
  46 #else
  47 #define USB_BUF_SIZE (MAX_CMD_APDU_DATA_SIZE+5)
  48 #endif
  49
  50 struct apdu apdu;
  51
  52 /*
  53  * There are three layers in USB CCID implementation
  54  *
  55  *   +-------------------+
  56  *   | Application Layer |
  57  *   +-------------------+
  58  *      ^ command APDU |
  59  *      |              v response APDU
  60  *   +-------------------+
  61  *   |    CCID Layer     |
  62  *   +-------------------+
  63  *    ^ CCID PC_to_RDR  | CCID RDR_to_PC
  64  *    | Message         v Message
  65  *   +-------------------+
  66  *   |    USB Layer      |
  67  *   +-------------------+
  68  *    ^ USB             | USB
  69  *    | Bulk-OUT Packet v Bulk-IN Packet
  70  *
  71  */
  72
  73 /*
  74  * USB layer data structures
  75  */
  76
  77 struct ep_in {
  78   uint8_t ep_num;
  79   uint8_t tx_done;
  80   void (*notify) (struct ep_in *epi);
  81   const uint8_t *buf;
  82   size_t cnt;
  83   size_t buf_len;
  84   void *priv;
  85   void (*next_buf) (struct ep_in *epi, size_t len);
  86 };
  87
  88 static void epi_init (struct ep_in *epi, int ep_num,
  89                       void (*notify) (struct ep_in *epi), void *priv)
  90 {
  91   epi->ep_num = ep_num;
  92   epi->tx_done = 0;
  93   epi->notify = notify;
  94   epi->buf = NULL;
  95   epi->cnt = 0;
  96   epi->buf_len = 0;
  97   epi->priv = priv;
  98   epi->next_buf = NULL;
  99 }
 100
 101 struct ep_out {
 102   uint8_t ep_num;
 103   uint8_t err;
 104   void (*notify) (struct ep_out *epo);
 105   uint8_t *buf;
 106   size_t cnt;
 107   size_t buf_len;
 108   void *priv;
 109   void (*next_buf) (struct ep_out *epo, size_t len);
 110   int  (*end_rx) (struct ep_out *epo, size_t orig_len);
 111 };
 112
 113 static struct ep_out endpoint_out;
 114 static struct ep_in endpoint_in;
 115
 116 static void epo_init (struct ep_out *epo, int ep_num,
 117                       void (*notify) (struct ep_out *epo), void *priv)
 118 {
 119   epo->ep_num = ep_num;
 120   epo->err = 0;
 121   epo->notify = notify;
 122   epo->buf = NULL;
 123   epo->cnt = 0;
 124   epo->buf_len = 0;
 125   epo->priv = priv;
 126   epo->next_buf = NULL;
 127   epo->end_rx = NULL;
 128 }
 129
 130 /*
 131  * CCID Layer
 132  */
 133
 134 /*
 135  * Buffer of USB communication: for both of RX and TX
 136  *
 137  * The buffer will be filled by multiple RX packets (Bulk-OUT)
 138  * or will be used for multiple TX packets (Bulk-IN)
 139  */
 140 static uint8_t icc_buffer[USB_BUF_SIZE];
 141
 142 #define ICC_SET_PARAMS          0x61 /* non-ICCD command  */
 143 #define ICC_POWER_ON            0x62
 144 #define ICC_POWER_OFF           0x63
 145 #define ICC_SLOT_STATUS         0x65 /* non-ICCD command */
 146 #define ICC_SECURE              0x69 /* non-ICCD command */
 147 #define ICC_GET_PARAMS          0x6C /* non-ICCD command */
 148 #define ICC_RESET_PARAMS        0x6D /* non-ICCD command */
 149 #define ICC_XFR_BLOCK           0x6F
 150 #define ICC_DATA_BLOCK_RET      0x80
 151 #define ICC_SLOT_STATUS_RET     0x81 /* non-ICCD result */
 152 #define ICC_PARAMS_RET          0x82 /* non-ICCD result */
 153
 154 #define ICC_MSG_SEQ_OFFSET      6
 155 #define ICC_MSG_STATUS_OFFSET   7
 156 #define ICC_MSG_ERROR_OFFSET    8
 157 #define ICC_MSG_CHAIN_OFFSET    9
 158 #define ICC_MSG_DATA_OFFSET     10      /* == ICC_MSG_HEADER_SIZE */
 159 #define ICC_MAX_MSG_DATA_SIZE   USB_BUF_SIZE
 160
 161 #define ICC_STATUS_RUN          0x00
 162 #define ICC_STATUS_PRESENT      0x01
 163 #define ICC_STATUS_NOTPRESENT   0x02
 164 #define ICC_CMD_STATUS_OK       0x00
 165 #define ICC_CMD_STATUS_ERROR    0x40
 166 #define ICC_CMD_STATUS_TIMEEXT  0x80
 167
 168 #define ICC_ERROR_XFR_OVERRUN   0xFC
 169
 170 /*
 171  * Since command-byte is at offset 0,
 172  * error with offset 0 means "command not supported".
 173  */
 174 #define ICC_OFFSET_CMD_NOT_SUPPORTED 0
 175 #define ICC_OFFSET_DATA_LEN 1
 176 #define ICC_OFFSET_PARAM 8
 177
 178 struct icc_header {
 179   uint8_t msg_type;
 180   uint32_t data_len;
 181   uint8_t slot;
 182   uint8_t seq;
 183   uint8_t rsvd;
 184   uint16_t param;
 185 } __attribute__((packed));
 186
 187
 188 /* Data structure handled by CCID layer */
 189 struct ccid {
 190   enum icc_state icc_state;
 191   uint8_t state;
 192   uint8_t *p;
 193   size_t len;
 194
 195   uint8_t err;
 196
 197   struct icc_header icc_header;
 198
 199   uint8_t sw1sw2[2];
 200   uint8_t chained_cls_ins_p1_p2[4];
 201
 202   /* lower layer */
 203   struct ep_out *epo;
 204   struct ep_in *epi;
 205
 206   /* from both layers */
 207   struct eventflag ccid_comm;
 208
 209   /* upper layer */
 210   struct eventflag openpgp_comm;
 211   chopstx_t application;
 212   struct apdu *a;
 213 };
 214
 215 /*
 216  * APDU_STATE_WAIT_COMMAND           +---------+
 217  *        |           |              |         |
 218  *        |           v              v         |
 219  *        |      APDU_STATE_COMMAND_CHAINING --+
 220  *        |                 |
 221  *        v                 v
 222  *      APDU_STATE_COMMAND_RECEIVED
 223  *                  |
 224  *                  v
 225  *          ===================
 226  *          | Process COMMAND |
 227  *          ===================
 228  *                  |
 229  *                  v
 230  *            +-----+----------+                  +---------+
 231  *            |                |                  |         |
 232  *            v                v                  v         |
 233  * APDU_STATE_RESULT <---- APDU_STATE_RESULT_GET_RESPONSE --+
 234  *         |
 235  *         |
 236  *         v
 237  * APDU_STATE_WAIT_COMMAND
 238  */
 239
 240 #define APDU_STATE_WAIT_COMMAND        0
 241 #define APDU_STATE_COMMAND_CHAINING    1
 242 #define APDU_STATE_COMMAND_RECEIVED    2
 243 #define APDU_STATE_RESULT              3
 244 #define APDU_STATE_RESULT_GET_RESPONSE 4
 245
 246 static void ccid_reset (struct ccid *c)
 247 {
 248   c->err = 0;
 249   c->state = APDU_STATE_WAIT_COMMAND;
 250   c->p = c->a->cmd_apdu_data;
 251   c->len = MAX_CMD_APDU_DATA_SIZE;
 252   c->a->cmd_apdu_data_len = 0;
 253   c->a->expected_res_size = 0;
 254 }
 255
 256 static void ccid_init (struct ccid *c, struct ep_in *epi, struct ep_out *epo,
 257                        struct apdu *a)
 258 {
 259   icc_state_p = &c->icc_state;
 260
 261   c->icc_state = ICC_STATE_NOCARD;
 262   c->state = APDU_STATE_WAIT_COMMAND;
 263   c->p = a->cmd_apdu_data;
 264   c->len = MAX_CMD_APDU_DATA_SIZE;
 265   c->err = 0;
 266   memset (&c->icc_header, 0, sizeof (struct icc_header));
 267   c->sw1sw2[0] = 0x90;
 268   c->sw1sw2[1] = 0x00;
 269   eventflag_init (&c->ccid_comm);
 270   c->application = 0;
 271   eventflag_init (&c->openpgp_comm);
 272   c->epi = epi;
 273   c->epo = epo;
 274   c->a = a;
 275 }
 276
 277 /*
 278  * Application layer
 279  */
 280
 281 /*
 282  * USB-CCID communication could be considered "half duplex".
 283  *
 284  * While the device is sending something, there is no possibility for
 285  * the device to receive anything.
 286  *
 287  * While the device is receiving something, there is no possibility
 288  * for the device to send anything.
 289  *
 290  * Thus, the buffer can be shared for RX and TX.
 291  *
 292  * Exception: When we support ABORT of CCID, it is possible to receive
 293  * ABORT Class Specific Request to control pipe while we are
 294  * receiving/sending something at OUT/IN endpoint.
 295  *
 296  */
 297
 298 #define CMD_APDU_HEAD_SIZE 5
 299
 300 static void apdu_init (struct apdu *a)
 301 {
 302   a->seq = 0;                   /* will be set by lower layer */
 303   a->cmd_apdu_head = &icc_buffer[0];
 304   a->cmd_apdu_data = &icc_buffer[5];
 305   a->cmd_apdu_data_len = 0;     /* will be set by lower layer */
 306   a->expected_res_size = 0;     /* will be set by lower layer */
 307
 308   a->sw = 0x9000;                    /* will be set by upper layer */
 309   a->res_apdu_data = &icc_buffer[5]; /* will be set by upper layer */
 310   a->res_apdu_data_len = 0;          /* will be set by upper layer */
 311 }
 312
 313
 314 static void notify_tx (struct ep_in *epi)
 315 {
 316   struct ccid *c = (struct ccid *)epi->priv;
 317
 318   /* The sequence of Bulk-IN transactions finished */
 319   eventflag_signal (&c->ccid_comm, EV_TX_FINISHED);
 320 }
 321
 322 static void no_buf (struct ep_in *epi, size_t len)
 323 {
 324   (void)len;
 325   epi->buf = NULL;
 326   epi->cnt = 0;
 327   epi->buf_len = 0;
 328 }
 329
 330 static void set_sw1sw2 (struct ccid *c, size_t chunk_len)
 331 {
 332   if (c->a->expected_res_size >= c->len)
 333     {
 334       c->sw1sw2[0] = 0x90;
 335       c->sw1sw2[1] = 0x00;
 336     }
 337   else
 338     {
 339       c->sw1sw2[0] = 0x61;
 340       if (c->len - chunk_len >= 256)
 341         c->sw1sw2[1] = 0;
 342       else
 343         c->sw1sw2[1] = (uint8_t)(c->len - chunk_len);
 344     }
 345 }
 346
 347 static void get_sw1sw2 (struct ep_in *epi, size_t len)
 348 {
 349   struct ccid *c = (struct ccid *)epi->priv;
 350
 351   (void)len;
 352   epi->buf = c->sw1sw2;
 353   epi->cnt = 0;
 354   epi->buf_len = 2;
 355   epi->next_buf = no_buf;
 356 }
 357
 358
 359 /*
 360  * Tx done callback
 361  */
 362 static void
 363 EP1_IN_Callback (void)
 364 {
 365   struct ep_in *epi = &endpoint_in;
 366
 367   if (epi->buf == NULL)
 368     if (epi->tx_done)
 369       epi->notify (epi);
 370     else
 371       {
 372         epi->tx_done = 1;
 373         usb_lld_tx_enable (epi->ep_num, 0); /* send ZLP */
 374       }
 375   else
 376     {
 377       int tx_size = 0;
 378       size_t remain = USB_LL_BUF_SIZE;
 379       int offset = 0;
 380
 381       while (epi->buf)
 382         if (epi->buf_len < remain)
 383           {
 384             usb_lld_txcpy (epi->buf, epi->ep_num, offset, epi->buf_len);
 385             offset += epi->buf_len;
 386             remain -= epi->buf_len;
 387             tx_size += epi->buf_len;
 388             epi->next_buf (epi, remain); /* Update epi->buf, cnt, buf_len */
 389           }
 390         else
 391           {
 392             usb_lld_txcpy (epi->buf, epi->ep_num, offset, remain);
 393             epi->buf += remain;
 394             epi->cnt += remain;
 395             epi->buf_len -= remain;
 396             tx_size += remain;
 397             break;
 398           }
 399
 400       if (tx_size < USB_LL_BUF_SIZE)
 401         epi->tx_done = 1;
 402       usb_lld_tx_enable (epi->ep_num, tx_size);
 403     }
 404 }
 405
 406
 407 static void notify_icc (struct ep_out *epo)
 408 {
 409   struct ccid *c = (struct ccid *)epo->priv;
 410
 411   c->err = epo->err;
 412   eventflag_signal (&c->ccid_comm, EV_RX_DATA_READY);
 413 }
 414
 415 static int end_icc_rx (struct ep_out *epo, size_t orig_len)
 416 {
 417   (void)orig_len;
 418   if (epo->cnt < sizeof (struct icc_header))
 419     /* short packet, just ignore */
 420     return 1;
 421
 422   /* icc message with no abdata */
 423   return 0;
 424 }
 425
 426 static int end_abdata (struct ep_out *epo, size_t orig_len)
 427 {
 428   struct ccid *c = (struct ccid *)epo->priv;
 429   size_t len = epo->cnt;
 430
 431   if (orig_len == USB_LL_BUF_SIZE && len < c->icc_header.data_len)
 432     /* more packet comes */
 433     return 1;
 434
 435   if (len != c->icc_header.data_len)
 436     epo->err = 1;
 437
 438   return 0;
 439 }
 440
 441 static int end_cmd_apdu_head (struct ep_out *epo, size_t orig_len)
 442 {
 443   struct ccid *c = (struct ccid *)epo->priv;
 444
 445   (void)orig_len;
 446
 447   if (epo->cnt < 4 || epo->cnt != c->icc_header.data_len)
 448     {
 449       epo->err = 1;
 450       return 0;
 451     }
 452
 453   if ((c->state == APDU_STATE_COMMAND_CHAINING)
 454       && (c->chained_cls_ins_p1_p2[0] != (c->a->cmd_apdu_head[0] & ~0x10)
 455           || c->chained_cls_ins_p1_p2[1] != c->a->cmd_apdu_head[1]
 456           || c->chained_cls_ins_p1_p2[2] != c->a->cmd_apdu_head[2]
 457           || c->chained_cls_ins_p1_p2[3] != c->a->cmd_apdu_head[3]))
 458     /*
 459      * Handling exceptional request.
 460      *
 461      * Host stops sending command APDU using command chaining,
 462      * and start another command APDU.
 463      *
 464      * Discard old one, and start handling new one.
 465      */
 466     {
 467       c->state = APDU_STATE_WAIT_COMMAND;
 468       c->p = c->a->cmd_apdu_data;
 469       c->len = MAX_CMD_APDU_DATA_SIZE;
 470     }
 471
 472   if (epo->cnt == 4)
 473     /* No Lc and Le */
 474     c->a->expected_res_size = 0;
 475   else if (epo->cnt == 5)
 476     {
 477       /* No Lc but Le */
 478       c->a->expected_res_size = c->a->cmd_apdu_head[4];
 479       if (c->a->expected_res_size == 0)
 480         c->a->expected_res_size = 256;
 481       c->a->cmd_apdu_head[4] = 0;
 482     }
 483
 484   c->a->cmd_apdu_data_len = 0;
 485   return 0;
 486 }
 487
 488
 489 static int end_nomore_data (struct ep_out *epo, size_t orig_len)
 490 {
 491   (void)epo;
 492   if (orig_len == USB_LL_BUF_SIZE)
 493     return 1;
 494   else
 495     return 0;
 496 }
 497
 498
 499 static int end_cmd_apdu_data (struct ep_out *epo, size_t orig_len)
 500 {
 501   struct ccid *c = (struct ccid *)epo->priv;
 502   size_t len = epo->cnt;
 503
 504   if (orig_len == USB_LL_BUF_SIZE
 505       && CMD_APDU_HEAD_SIZE + len < c->icc_header.data_len)
 506     /* more packet comes */
 507     return 1;
 508
 509   if (CMD_APDU_HEAD_SIZE + len != c->icc_header.data_len)
 510     goto error;
 511
 512   if (len == c->a->cmd_apdu_head[4])
 513     /* No Le field*/
 514     c->a->expected_res_size = 0;
 515   else if (len == (size_t)c->a->cmd_apdu_head[4] + 1)
 516     {
 517       /* it has Le field*/
 518       c->a->expected_res_size = epo->buf[-1];
 519       if (c->a->expected_res_size == 0)
 520         c->a->expected_res_size = 256;
 521       len--;
 522     }
 523   else
 524     {
 525     error:
 526       epo->err = 1;
 527       return 0;
 528     }
 529
 530   c->a->cmd_apdu_data_len += len;
 531   return 0;
 532 }
 533
 534
 535 static void nomore_data (struct ep_out *epo, size_t len)
 536 {
 537   (void)len;
 538   epo->err = 1;
 539   epo->end_rx = end_nomore_data;
 540   epo->buf = NULL;
 541   epo->buf_len = 0;
 542   epo->cnt = 0;
 543   epo->next_buf = nomore_data;
 544 }
 545
 546 #define INS_GET_RESPONSE 0xc0
 547
 548 static void icc_cmd_apdu_data (struct ep_out *epo, size_t len)
 549 {
 550   struct ccid *c = (struct ccid *)epo->priv;
 551
 552   (void)len;
 553   if (c->state == APDU_STATE_RESULT_GET_RESPONSE
 554       && c->a->cmd_apdu_head[1] != INS_GET_RESPONSE)
 555     {
 556       /*
 557        * Handling exceptional request.
 558        *
 559        * Host didn't finish receiving the whole response APDU by GET RESPONSE,
 560        * but initiates another command.
 561        */
 562
 563       c->state = APDU_STATE_WAIT_COMMAND;
 564       c->p = c->a->cmd_apdu_data;
 565       c->len = MAX_CMD_APDU_DATA_SIZE;
 566     }
 567   else if (c->state == APDU_STATE_COMMAND_CHAINING)
 568     {
 569       if (c->chained_cls_ins_p1_p2[0] != (c->a->cmd_apdu_head[0] & ~0x10)
 570           || c->chained_cls_ins_p1_p2[1] != c->a->cmd_apdu_head[1]
 571           || c->chained_cls_ins_p1_p2[2] != c->a->cmd_apdu_head[2]
 572           || c->chained_cls_ins_p1_p2[3] != c->a->cmd_apdu_head[3])
 573         /*
 574          * Handling exceptional request.
 575          *
 576          * Host stops sending command APDU using command chaining,
 577          * and start another command APDU.
 578          *
 579          * Discard old one, and start handling new one.
 580          */
 581         {
 582           c->state = APDU_STATE_WAIT_COMMAND;
 583           c->p = c->a->cmd_apdu_data;
 584           c->len = MAX_CMD_APDU_DATA_SIZE;
 585           c->a->cmd_apdu_data_len = 0;
 586         }
 587     }
 588
 589   epo->end_rx = end_cmd_apdu_data;
 590   epo->buf = c->p;
 591   epo->buf_len = c->len;
 592   epo->cnt = 0;
 593   epo->next_buf = nomore_data;
 594 }
 595
 596 static void icc_abdata (struct ep_out *epo, size_t len)
 597 {
 598   struct ccid *c = (struct ccid *)epo->priv;
 599
 600   (void)len;
 601   c->a->seq = c->icc_header.seq;
 602   if (c->icc_header.msg_type == ICC_XFR_BLOCK)
 603     {
 604       c->a->seq = c->icc_header.seq;
 605       epo->end_rx = end_cmd_apdu_head;
 606       epo->buf = c->a->cmd_apdu_head;
 607       epo->buf_len = 5;
 608       epo->cnt = 0;
 609       epo->next_buf = icc_cmd_apdu_data;
 610     }
 611   else
 612     {
 613       epo->end_rx = end_abdata;
 614       epo->buf = c->p;
 615       epo->buf_len = c->len;
 616       epo->cnt = 0;
 617       epo->next_buf = nomore_data;
 618     }
 619 }
 620
 621
 622 static void
 623 icc_prepare_receive (struct ccid *c)
 624 {
 625   c->epo->err = 0;
 626   c->epo->buf = (uint8_t *)&c->icc_header;
 627   c->epo->buf_len = sizeof (struct icc_header);
 628   c->epo->cnt = 0;
 629   c->epo->next_buf = icc_abdata;
 630   c->epo->end_rx = end_icc_rx;
 631   usb_lld_rx_enable (c->epo->ep_num);
 632   DEBUG_INFO ("Rx ready\r\n");
 633 }
 634
 635 /*
 636  * Rx ready callback
 637  */
 638
 639 static void
 640 EP1_OUT_Callback (void)
 641 {
 642   struct ep_out *epo = &endpoint_out;
 643   size_t len = usb_lld_rx_data_len (epo->ep_num);
 644   int offset = 0;
 645   int cont;
 646   size_t orig_len = len;
 647
 648   while (epo->err == 0)
 649     if (len == 0)
 650       break;
 651     else if (len <= epo->buf_len)
 652       {
 653         usb_lld_rxcpy (epo->buf, epo->ep_num, offset, len);
 654         epo->buf += len;
 655         epo->cnt += len;
 656         epo->buf_len -= len;
 657         break;
 658       }
 659     else /* len > buf_len */
 660       {
 661         usb_lld_rxcpy (epo->buf, epo->ep_num, offset, epo->buf_len);
 662         len -= epo->buf_len;
 663         offset += epo->buf_len;
 664         epo->next_buf (epo, len); /* Update epo->buf, cnt, buf_len */
 665       }
 666
 667   /*
 668    * ORIG_LEN to distingush ZLP and the end of transaction
 669    *  (ORIG_LEN != USB_LL_BUF_SIZE)
 670    */
 671   cont = epo->end_rx (epo, orig_len);
 672
 673   if (cont)
 674     usb_lld_rx_enable (epo->ep_num);
 675   else
 676     epo->notify (epo);
 677 }
 678
 679
 680 extern void EP6_IN_Callback (void);
 681
 682 void
 683 usb_cb_rx_ready (uint8_t ep_num)
 684 {
 685   if (ep_num == ENDP1)
 686     EP1_OUT_Callback ();
 687 #ifdef DEBUG
 688   else if (ep_num == ENDP5)
 689     {
 690       chopstx_mutex_lock (&stdout.m_dev);
 691       usb_lld_rx_enable (ep_num);
 692       chopstx_mutex_unlock (&stdout.m_dev);
 693     }
 694 #endif
 695 }
 696
 697 void
 698 usb_cb_tx_done (uint8_t ep_num)
 699 {
 700   if (ep_num == ENDP1)
 701     EP1_IN_Callback ();
 702   else if (ep_num == ENDP2)
 703     {
 704       /* INTERRUPT Transfer done */
 705     }
 706 #ifdef DEBUG
 707   else if (ep_num == ENDP3)
 708     {
 709       chopstx_mutex_lock (&stdout.m_dev);
 710       chopstx_cond_signal (&stdout.cond_dev);
 711       chopstx_mutex_unlock (&stdout.m_dev);
 712     }
 713 #endif
 714 #ifdef PINPAD_SUPPORT
 715   else if (ep_num == ENDP6)
 716     EP6_IN_Callback ();
 717 #endif
 718 }
 719
 720 /*
 721  * ATR (Answer To Reset) string
 722  *
 723  * TS = 0x3b: Direct conversion
 724  * T0 = 0xda: TA1, TC1 and TD1 follow, 10 historical bytes
 725  * TA1 = 0x11: FI=1, DI=1
 726  * TC1 = 0xff
 727  * TD1 = 0x81: TD2 follows, T=1
 728  * TD2 = 0xb1: TA3, TB3 and TD3 follow, T=1
 729  * TA3 = 0xFE: IFSC = 254 bytes
 730  * TB3 = 0x55: BWI = 5, CWI = 5   (BWT timeout 3.2 sec)
 731  * TD3 = 0x1f: TA4 follows, T=15
 732  * TA4 = 0x03: 5V or 3.3V
 733  * Historical bytes: to be explained...
 734  * XOR check
 735  *
 736  * Minimum: 0x3b, 0x8a, 0x80, 0x01, + historical bytes, xor check
 737  *
 738  */
 739 static const uint8_t ATR[] = {
 740   0x3b, 0xda, 0x11, 0xff, 0x81, 0xb1, 0xfe, 0x55, 0x1f, 0x03,
 741   0x00,
 742         0x31, 0x84, /* full DF name, GET DATA, MF */
 743         0x73,
 744               0x80, /* DF full name */
 745               0x01, /* 1-byte */
 746               0x80, /* Command chaining, No extended Lc and extended Le */
 747         0x00,
 748         0x90, 0x00,
 749  (0xda^0x11^0xff^0x81^0xb1^0xfe^0x55^0x1f^0x03
 750   ^0x00^0x31^0x84^0x73^0x80^0x01^0x80^0x00^0x90^0x00)
 751 };
 752
 753 /*
 754  * Send back error
 755  */
 756 static void icc_error (struct ccid *c, int offset)
 757 {
 758   uint8_t icc_reply[ICC_MSG_HEADER_SIZE];
 759
 760   icc_reply[0] = ICC_SLOT_STATUS_RET; /* Any value should be OK */
 761   icc_reply[1] = 0x00;
 762   icc_reply[2] = 0x00;
 763   icc_reply[3] = 0x00;
 764   icc_reply[4] = 0x00;
 765   icc_reply[5] = 0x00;  /* Slot */
 766   icc_reply[ICC_MSG_SEQ_OFFSET] = c->icc_header.seq;
 767   if (c->icc_state == ICC_STATE_NOCARD)
 768     icc_reply[ICC_MSG_STATUS_OFFSET] = 2; /* 2: No ICC present */
 769   else if (c->icc_state == ICC_STATE_START)
 770     icc_reply[ICC_MSG_STATUS_OFFSET] = 1; /* 1: ICC present but not activated */
 771   else
 772     icc_reply[ICC_MSG_STATUS_OFFSET] = 0; /* An ICC is present and active */
 773   icc_reply[ICC_MSG_STATUS_OFFSET] |= ICC_CMD_STATUS_ERROR; /* Failed */
 774   icc_reply[ICC_MSG_ERROR_OFFSET] = offset;
 775   icc_reply[ICC_MSG_CHAIN_OFFSET] = 0x00;
 776
 777   /* This is a single packet Bulk-IN transaction */
 778   c->epi->buf = NULL;
 779   c->epi->tx_done = 1;
 780   usb_lld_write (c->epi->ep_num, icc_reply, ICC_MSG_HEADER_SIZE);
 781 }
 782
 783 extern void *openpgp_card_thread (void *arg);
 784
 785 extern uint8_t __process3_stack_base__, __process3_stack_size__;
 786 const uint32_t __stackaddr_gpg = (uint32_t)&__process3_stack_base__;
 787 const size_t __stacksize_gpg = (size_t)&__process3_stack_size__;
 788 #define PRIO_GPG 1
 789
 790
 791 /* Send back ATR (Answer To Reset) */
 792 static enum icc_state
 793 icc_power_on (struct ccid *c)
 794 {
 795   size_t size_atr = sizeof (ATR);
 796   uint8_t p[ICC_MSG_HEADER_SIZE];
 797
 798   if (c->application == 0)
 799     c->application = chopstx_create (PRIO_GPG, __stackaddr_gpg,
 800                                      __stacksize_gpg, openpgp_card_thread,
 801                                      (void *)&c->ccid_comm);
 802
 803   p[0] = ICC_DATA_BLOCK_RET;
 804   p[1] = size_atr;
 805   p[2] = 0x00;
 806   p[3] = 0x00;
 807   p[4] = 0x00;
 808   p[5] = 0x00;  /* Slot */
 809   p[ICC_MSG_SEQ_OFFSET] = c->icc_header.seq;
 810   p[ICC_MSG_STATUS_OFFSET] = 0x00;
 811   p[ICC_MSG_ERROR_OFFSET] = 0x00;
 812   p[ICC_MSG_CHAIN_OFFSET] = 0x00;
 813
 814   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE);
 815   usb_lld_txcpy (ATR, c->epi->ep_num, ICC_MSG_HEADER_SIZE, size_atr);
 816
 817   /* This is a single packet Bulk-IN transaction */
 818   c->epi->buf = NULL;
 819   c->epi->tx_done = 1;
 820   usb_lld_tx_enable (c->epi->ep_num, ICC_MSG_HEADER_SIZE + size_atr);
 821   DEBUG_INFO ("ON\r\n");
 822
 823   return ICC_STATE_WAIT;
 824 }
 825
 826 static void
 827 icc_send_status (struct ccid *c)
 828 {
 829   uint8_t icc_reply[ICC_MSG_HEADER_SIZE];
 830
 831   icc_reply[0] = ICC_SLOT_STATUS_RET;
 832   icc_reply[1] = 0x00;
 833   icc_reply[2] = 0x00;
 834   icc_reply[3] = 0x00;
 835   icc_reply[4] = 0x00;
 836   icc_reply[5] = 0x00;  /* Slot */
 837   icc_reply[ICC_MSG_SEQ_OFFSET] = c->icc_header.seq;
 838   if (c->icc_state == ICC_STATE_NOCARD)
 839     icc_reply[ICC_MSG_STATUS_OFFSET] = 2; /* 2: No ICC present */
 840   else if (c->icc_state == ICC_STATE_START)
 841     icc_reply[ICC_MSG_STATUS_OFFSET] = 1; /* 1: ICC present but not activated */
 842   else
 843     icc_reply[ICC_MSG_STATUS_OFFSET] = 0; /* An ICC is present and active */
 844   icc_reply[ICC_MSG_ERROR_OFFSET] = 0x00;
 845   icc_reply[ICC_MSG_CHAIN_OFFSET] = 0x00;
 846
 847   /* This is a single packet Bulk-IN transaction */
 848   c->epi->buf = NULL;
 849   c->epi->tx_done = 1;
 850   usb_lld_write (c->epi->ep_num, icc_reply, ICC_MSG_HEADER_SIZE);
 851
 852   led_blink (LED_SHOW_STATUS);
 853 #ifdef DEBUG_MORE
 854   DEBUG_INFO ("St\r\n");
 855 #endif
 856 }
 857
 858 static enum icc_state
 859 icc_power_off (struct ccid *c)
 860 {
 861   if (c->application)
 862     {
 863       eventflag_signal (&c->openpgp_comm, EV_EXIT);
 864       chopstx_join (c->application, NULL);
 865       c->application = 0;
 866     }
 867
 868   c->icc_state = ICC_STATE_START; /* This status change should be here */
 869   icc_send_status (c);
 870   DEBUG_INFO ("OFF\r\n");
 871   return ICC_STATE_START;
 872 }
 873
 874 static void
 875 icc_send_data_block_internal (struct ccid *c, uint8_t status, uint8_t error)
 876 {
 877   int tx_size = USB_LL_BUF_SIZE;
 878   uint8_t p[ICC_MSG_HEADER_SIZE];
 879   size_t len;
 880
 881   if (status == 0)
 882     len = c->a->res_apdu_data_len + 2;
 883   else
 884     len = 0;
 885
 886   p[0] = ICC_DATA_BLOCK_RET;
 887   p[1] = len & 0xFF;
 888   p[2] = (len >> 8)& 0xFF;
 889   p[3] = (len >> 16)& 0xFF;
 890   p[4] = (len >> 24)& 0xFF;
 891   p[5] = 0x00;  /* Slot */
 892   p[ICC_MSG_SEQ_OFFSET] = c->a->seq;
 893   p[ICC_MSG_STATUS_OFFSET] = status;
 894   p[ICC_MSG_ERROR_OFFSET] = error;
 895   p[ICC_MSG_CHAIN_OFFSET] = 0;
 896
 897   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE);
 898   if (len == 0)
 899     {
 900       usb_lld_tx_enable (c->epi->ep_num, ICC_MSG_HEADER_SIZE);
 901       return;
 902     }
 903
 904   if (ICC_MSG_HEADER_SIZE + len <= USB_LL_BUF_SIZE)
 905     {
 906       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
 907                      ICC_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
 908       usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
 909                      ICC_MSG_HEADER_SIZE + c->a->res_apdu_data_len, 2);
 910       c->epi->buf = NULL;
 911       if (ICC_MSG_HEADER_SIZE + len < USB_LL_BUF_SIZE)
 912         c->epi->tx_done = 1;
 913       tx_size = ICC_MSG_HEADER_SIZE + len;
 914     }
 915   else if (ICC_MSG_HEADER_SIZE + len - 1 == USB_LL_BUF_SIZE)
 916     {
 917       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
 918                      ICC_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
 919       usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
 920                      ICC_MSG_HEADER_SIZE + c->a->res_apdu_data_len, 1);
 921       c->epi->buf = &c->sw1sw2[1];
 922       c->epi->cnt = 1;
 923       c->epi->buf_len = 1;
 924       c->epi->next_buf = no_buf;
 925     }
 926   else if (ICC_MSG_HEADER_SIZE + len - 2 == USB_LL_BUF_SIZE)
 927     {
 928       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
 929                      ICC_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
 930       c->epi->buf = &c->sw1sw2[0];
 931       c->epi->cnt = 0;
 932       c->epi->buf_len = 2;
 933       c->epi->next_buf = no_buf;
 934     }
 935   else
 936     {
 937       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num, ICC_MSG_HEADER_SIZE,
 938                      USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE);
 939       c->epi->buf = c->a->res_apdu_data + USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE;
 940       c->epi->cnt = USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE;
 941       c->epi->buf_len = c->a->res_apdu_data_len
 942         - (USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE);
 943       c->epi->next_buf = get_sw1sw2;
 944     }
 945
 946   usb_lld_tx_enable (c->epi->ep_num, tx_size);
 947 #ifdef DEBUG_MORE
 948   DEBUG_INFO ("DATA\r\n");
 949 #endif
 950 }
 951
 952 static void
 953 icc_send_data_block (struct ccid *c)
 954 {
 955   icc_send_data_block_internal (c, 0, 0);
 956 }
 957
 958 static void
 959 icc_send_data_block_time_extension (struct ccid *c)
 960 {
 961   icc_send_data_block_internal (c, ICC_CMD_STATUS_TIMEEXT, 1);
 962 }
 963
 964 static void
 965 icc_send_data_block_0x9000 (struct ccid *c)
 966 {
 967   uint8_t p[ICC_MSG_HEADER_SIZE+2];
 968   size_t len = 2;
 969
 970   p[0] = ICC_DATA_BLOCK_RET;
 971   p[1] = len & 0xFF;
 972   p[2] = (len >> 8)& 0xFF;
 973   p[3] = (len >> 16)& 0xFF;
 974   p[4] = (len >> 24)& 0xFF;
 975   p[5] = 0x00;  /* Slot */
 976   p[ICC_MSG_SEQ_OFFSET] = c->a->seq;
 977   p[ICC_MSG_STATUS_OFFSET] = 0;
 978   p[ICC_MSG_ERROR_OFFSET] = 0;
 979   p[ICC_MSG_CHAIN_OFFSET] = 0;
 980   p[ICC_MSG_CHAIN_OFFSET+1] = 0x90;
 981   p[ICC_MSG_CHAIN_OFFSET+2] = 0x00;
 982
 983   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE + len);
 984   c->epi->buf = NULL;
 985   c->epi->tx_done = 1;
 986
 987   usb_lld_tx_enable (c->epi->ep_num, ICC_MSG_HEADER_SIZE + len);
 988 #ifdef DEBUG_MORE
 989   DEBUG_INFO ("DATA\r\n");
 990 #endif
 991 }
 992
 993 /*
 994  * Reply to the host for "GET RESPONSE".
 995  */
 996 static void
 997 icc_send_data_block_gr (struct ccid *c, size_t chunk_len)
 998 {
 999   int tx_size = USB_LL_BUF_SIZE;
1000   uint8_t p[ICC_MSG_HEADER_SIZE];
1001   size_t len = chunk_len + 2;
1002
1003   p[0] = ICC_DATA_BLOCK_RET;
1004   p[1] = len & 0xFF;
1005   p[2] = (len >> 8)& 0xFF;
1006   p[3] = (len >> 16)& 0xFF;
1007   p[4] = (len >> 24)& 0xFF;
1008   p[5] = 0x00;  /* Slot */
1009   p[ICC_MSG_SEQ_OFFSET] = c->a->seq;
1010   p[ICC_MSG_STATUS_OFFSET] = 0;
1011   p[ICC_MSG_ERROR_OFFSET] = 0;
1012   p[ICC_MSG_CHAIN_OFFSET] = 0;
1013
1014   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE);
1015
1016   set_sw1sw2 (c, chunk_len);
1017
1018   if (chunk_len <= USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE)
1019     {
1020       int size_for_sw;
1021
1022       if (chunk_len <= USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE - 2)
1023         size_for_sw = 2;
1024       else if (chunk_len == USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE - 1)
1025         size_for_sw = 1;
1026       else
1027         size_for_sw = 0;
1028
1029       usb_lld_txcpy (c->p, c->epi->ep_num, ICC_MSG_HEADER_SIZE, chunk_len);
1030       if (size_for_sw)
1031         usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
1032                        ICC_MSG_HEADER_SIZE + chunk_len, size_for_sw);
1033       tx_size = ICC_MSG_HEADER_SIZE + chunk_len + size_for_sw;
1034       if (size_for_sw == 2)
1035         {
1036           c->epi->buf = NULL;
1037           if (tx_size < USB_LL_BUF_SIZE)
1038             c->epi->tx_done = 1;
1039           /* Don't set epi->tx_done = 1, when it requires ZLP */
1040         }
1041       else
1042         {
1043           c->epi->buf = c->sw1sw2 + size_for_sw;
1044           c->epi->cnt = size_for_sw;
1045           c->epi->buf_len = 2 - size_for_sw;
1046           c->epi->next_buf = no_buf;
1047         }
1048     }
1049   else
1050     {
1051       usb_lld_txcpy (c->p, c->epi->ep_num, ICC_MSG_HEADER_SIZE,
1052                      USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE);
1053       c->epi->buf = c->p + USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE;
1054       c->epi->cnt = 0;
1055       c->epi->buf_len = chunk_len - (USB_LL_BUF_SIZE - ICC_MSG_HEADER_SIZE);
1056       c->epi->next_buf = get_sw1sw2;
1057     }
1058
1059   c->p += chunk_len;
1060   c->len -= chunk_len;
1061   usb_lld_tx_enable (c->epi->ep_num, tx_size);
1062 #ifdef DEBUG_MORE
1063   DEBUG_INFO ("DATA\r\n");
1064 #endif
1065 }
1066
1067
1068 static void
1069 icc_send_params (struct ccid *c)
1070 {
1071   uint8_t p[ICC_MSG_HEADER_SIZE];
1072   const uint8_t params[] =  {
1073     0x11,   /* bmFindexDindex */
1074     0x11, /* bmTCCKST1 */
1075     0xFE, /* bGuardTimeT1 */
1076     0x55, /* bmWaitingIntegersT1 */
1077     0x03, /* bClockStop */
1078     0xFE, /* bIFSC */
1079     0    /* bNadValue */
1080   };
1081
1082   p[0] = ICC_PARAMS_RET;
1083   p[1] = 0x07;  /* Length = 0x00000007 */
1084   p[2] = 0;
1085   p[3] = 0;
1086   p[4] = 0;
1087   p[5] = 0x00;  /* Slot */
1088   p[ICC_MSG_SEQ_OFFSET] = c->icc_header.seq;
1089   p[ICC_MSG_STATUS_OFFSET] = 0;
1090   p[ICC_MSG_ERROR_OFFSET] = 0;
1091   p[ICC_MSG_CHAIN_OFFSET] = 0x01;  /* ProtocolNum: T=1 */
1092
1093   usb_lld_txcpy (p, c->epi->ep_num, 0, ICC_MSG_HEADER_SIZE);
1094   usb_lld_txcpy (params, c->epi->ep_num, ICC_MSG_HEADER_SIZE, sizeof params);
1095
1096   /* This is a single packet Bulk-IN transaction */
1097   c->epi->buf = NULL;
1098   c->epi->tx_done = 1;
1099   usb_lld_tx_enable (c->epi->ep_num, ICC_MSG_HEADER_SIZE + sizeof params);
1100 #ifdef DEBUG_MORE
1101   DEBUG_INFO ("PARAMS\r\n");
1102 #endif
1103 }
1104
1105
1106 static enum icc_state
1107 icc_handle_data (struct ccid *c)
1108 {
1109   enum icc_state next_state = c->icc_state;
1110
1111   if (c->err != 0)
1112     {
1113       ccid_reset (c);
1114       icc_error (c, ICC_OFFSET_DATA_LEN);
1115       return next_state;
1116     }
1117
1118   switch (c->icc_state)
1119     {
1120     case ICC_STATE_NOCARD:
1121       if (c->icc_header.msg_type == ICC_SLOT_STATUS)
1122         icc_send_status (c);
1123       else
1124         {
1125           DEBUG_INFO ("ERR00\r\n");
1126           icc_error (c, ICC_OFFSET_CMD_NOT_SUPPORTED);
1127         }
1128       break;
1129     case ICC_STATE_START:
1130       if (c->icc_header.msg_type == ICC_POWER_ON)
1131         {
1132           ccid_reset (c);
1133           next_state = icc_power_on (c);
1134         }
1135       else if (c->icc_header.msg_type == ICC_POWER_OFF)
1136         {
1137           ccid_reset (c);
1138           next_state = icc_power_off (c);
1139         }
1140       else if (c->icc_header.msg_type == ICC_SLOT_STATUS)
1141         icc_send_status (c);
1142       else
1143         {
1144           DEBUG_INFO ("ERR01\r\n");
1145           icc_error (c, ICC_OFFSET_CMD_NOT_SUPPORTED);
1146         }
1147       break;
1148     case ICC_STATE_WAIT:
1149       if (c->icc_header.msg_type == ICC_POWER_ON)
1150         {
1151           /* Not in the spec., but pcscd/libccid */
1152           ccid_reset (c);
1153           next_state = icc_power_on (c);
1154         }
1155       else if (c->icc_header.msg_type == ICC_POWER_OFF)
1156         {
1157           ccid_reset (c);
1158           next_state = icc_power_off (c);
1159         }
1160       else if (c->icc_header.msg_type == ICC_SLOT_STATUS)
1161         icc_send_status (c);
1162       else if (c->icc_header.msg_type == ICC_XFR_BLOCK)
1163         {
1164           if (c->icc_header.param == 0)
1165             {
1166               if ((c->a->cmd_apdu_head[0] & 0x10) == 0)
1167                 {
1168                   if (c->state == APDU_STATE_COMMAND_CHAINING)
1169                     {           /* command chaining finished */
1170                       c->p += c->a->cmd_apdu_head[4];
1171                       c->a->cmd_apdu_head[4] = 0;
1172                       DEBUG_INFO ("CMD chaning finished.\r\n");
1173                     }
1174
1175                   if (c->a->cmd_apdu_head[1] == INS_GET_RESPONSE
1176                       && c->state == APDU_STATE_RESULT_GET_RESPONSE)
1177                     {
1178                       size_t len = c->a->expected_res_size;
1179
1180                       if (c->len <= c->a->expected_res_size)
1181                         len = c->len;
1182
1183                       icc_send_data_block_gr (c, len);
1184                       if (c->len == 0)
1185                         c->state = APDU_STATE_RESULT;
1186                       c->icc_state = ICC_STATE_WAIT;
1187                       DEBUG_INFO ("GET Response.\r\n");
1188                     }
1189                   else
1190                     {             /* Give this message to GPG thread */
1191                       c->state = APDU_STATE_COMMAND_RECEIVED;
1192
1193                       c->a->sw = 0x9000;
1194                       c->a->res_apdu_data_len = 0;
1195                       c->a->res_apdu_data = &icc_buffer[5];
1196
1197                       eventflag_signal (&c->openpgp_comm, EV_CMD_AVAILABLE);
1198                       next_state = ICC_STATE_EXECUTE;
1199                     }
1200                 }
1201               else
1202                 {
1203                   if (c->state == APDU_STATE_WAIT_COMMAND)
1204                     {           /* command chaining is started */
1205                       c->a->cmd_apdu_head[0] &= ~0x10;
1206                       memcpy (c->chained_cls_ins_p1_p2, c->a->cmd_apdu_head, 4);
1207                       c->state = APDU_STATE_COMMAND_CHAINING;
1208                     }
1209
1210                   c->p += c->a->cmd_apdu_head[4];
1211                   c->len -= c->a->cmd_apdu_head[4];
1212                   icc_send_data_block_0x9000 (c);
1213                   DEBUG_INFO ("CMD chaning...\r\n");
1214                 }
1215             }
1216           else
1217             {                /* ICC block chaining is not supported. */
1218               DEBUG_INFO ("ERR02\r\n");
1219               icc_error (c, ICC_OFFSET_PARAM);
1220             }
1221         }
1222       else if (c->icc_header.msg_type == ICC_SET_PARAMS
1223                || c->icc_header.msg_type == ICC_GET_PARAMS
1224                || c->icc_header.msg_type == ICC_RESET_PARAMS)
1225         icc_send_params (c);
1226       else if (c->icc_header.msg_type == ICC_SECURE)
1227         {
1228           if (c->p != c->a->cmd_apdu_data)
1229             {
1230               /* SECURE received in the middle of command chaining */
1231               ccid_reset (c);
1232               icc_error (c, ICC_OFFSET_DATA_LEN);
1233               return next_state;
1234             }
1235
1236           if (c->p[10-10] == 0x00) /* PIN verification */
1237             {
1238               c->a->cmd_apdu_head[0] = c->p[25-10];
1239               c->a->cmd_apdu_head[1] = c->p[26-10];
1240               c->a->cmd_apdu_head[2] = c->p[27-10];
1241               c->a->cmd_apdu_head[3] = c->p[28-10];
1242               /**/
1243               c->a->cmd_apdu_data[0] = 0; /* bConfirmPIN */
1244               c->a->cmd_apdu_data[1] = c->p[17-10]; /* bEntryValidationCondition */
1245               c->a->cmd_apdu_data[2] = c->p[18-10]; /* bNumberMessage */
1246               c->a->cmd_apdu_data[3] = c->p[19-10]; /* wLangId L */
1247               c->a->cmd_apdu_data[4] = c->p[20-10]; /* wLangId H */
1248               c->a->cmd_apdu_data[5] = c->p[21-10]; /* bMsgIndex */
1249
1250               c->a->cmd_apdu_data_len = 6;
1251               c->a->expected_res_size = 0;
1252
1253               c->a->sw = 0x9000;
1254               c->a->res_apdu_data_len = 0;
1255               c->a->res_apdu_data = &c->p[5];
1256
1257               eventflag_signal (&c->openpgp_comm, EV_VERIFY_CMD_AVAILABLE);
1258               next_state = ICC_STATE_EXECUTE;
1259             }
1260           else if (c->p[10-10] == 0x01) /* PIN Modification */
1261             {
1262               uint8_t num_msgs = c->p[21-10];
1263
1264               if (num_msgs == 0x00)
1265                 num_msgs = 1;
1266               else if (num_msgs == 0xff)
1267                 num_msgs = 3;
1268               c->a->cmd_apdu_head[0] = c->p[27 + num_msgs-10];
1269               c->a->cmd_apdu_head[1] = c->p[28 + num_msgs-10];
1270               c->a->cmd_apdu_head[2] = c->p[29 + num_msgs-10];
1271               c->a->cmd_apdu_head[3] = c->p[30 + num_msgs-10];
1272               /**/
1273               c->a->cmd_apdu_data[0] = c->p[19-10]; /* bConfirmPIN */
1274               c->a->cmd_apdu_data[1] = c->p[20-10]; /* bEntryValidationCondition */
1275               c->a->cmd_apdu_data[2] = c->p[21-10]; /* bNumberMessage */
1276               c->a->cmd_apdu_data[3] = c->p[22-10]; /* wLangId L */
1277               c->a->cmd_apdu_data[4] = c->p[23-10]; /* wLangId H */
1278               c->a->cmd_apdu_data[5] = c->p[24-10]; /* bMsgIndex, bMsgIndex1 */
1279               if (num_msgs >= 2)
1280                 c->a->cmd_apdu_data[6] = c->p[25-10]; /* bMsgIndex2 */
1281               if (num_msgs == 3)
1282                 c->a->cmd_apdu_data[7] = c->p[26-10]; /* bMsgIndex3 */
1283
1284               c->a->cmd_apdu_data_len = 5 + num_msgs;
1285               c->a->expected_res_size = 0;
1286
1287               c->a->sw = 0x9000;
1288               c->a->res_apdu_data_len = 0;
1289               c->a->res_apdu_data = &icc_buffer[5];
1290
1291               eventflag_signal (&c->openpgp_comm, EV_MODIFY_CMD_AVAILABLE);
1292               next_state = ICC_STATE_EXECUTE;
1293             }
1294           else
1295             icc_error (c, ICC_MSG_DATA_OFFSET);
1296         }
1297       else
1298         {
1299           DEBUG_INFO ("ERR03\r\n");
1300           DEBUG_BYTE (c->icc_header.msg_type);
1301           icc_error (c, ICC_OFFSET_CMD_NOT_SUPPORTED);
1302         }
1303       break;
1304     case ICC_STATE_EXECUTE:
1305       if (c->icc_header.msg_type == ICC_POWER_OFF)
1306         next_state = icc_power_off (c);
1307       else if (c->icc_header.msg_type == ICC_SLOT_STATUS)
1308         icc_send_status (c);
1309       else
1310         {
1311           DEBUG_INFO ("ERR04\r\n");
1312           DEBUG_BYTE (c->icc_header.msg_type);
1313           icc_error (c, ICC_OFFSET_CMD_NOT_SUPPORTED);
1314         }
1315       break;
1316     default:
1317       next_state = ICC_STATE_START;
1318       DEBUG_INFO ("ERR10\r\n");
1319       break;
1320     }
1321
1322   return next_state;
1323 }
1324
1325 static enum icc_state
1326 icc_handle_timeout (struct ccid *c)
1327 {
1328   enum icc_state next_state = c->icc_state;
1329
1330   switch (c->icc_state)
1331     {
1332     case ICC_STATE_EXECUTE:
1333       icc_send_data_block_time_extension (c);
1334       led_blink (LED_ONESHOT);
1335       break;
1336     default:
1337       break;
1338     }
1339
1340   return next_state;
1341 }
1342
1343 static struct ccid ccid;
1344 enum icc_state *icc_state_p = &ccid.icc_state;
1345
1346 void
1347 ccid_card_change_signal (int how)
1348 {
1349   struct ccid *c = &ccid;
1350
1351   if (how == CARD_CHANGE_TOGGLE
1352       || (c->icc_state == ICC_STATE_NOCARD && how == CARD_CHANGE_INSERT)
1353       || (c->icc_state != ICC_STATE_NOCARD && how == CARD_CHANGE_REMOVE))
1354     eventflag_signal (&c->ccid_comm, EV_CARD_CHANGE);
1355 }
1356
1357 void
1358 ccid_usb_reset (void)
1359 {
1360   struct ccid *c = &ccid;
1361   eventflag_signal (&c->ccid_comm, EV_USB_RESET);
1362 }
1363
1364
1365 #define USB_ICC_TIMEOUT (1950*1000)
1366
1367 #define GPG_THREAD_TERMINATED 0xffff
1368
1369 #define NOTIFY_SLOT_CHANGE 0x50
1370
1371 #define INTR_REQ_USB 20
1372
1373 void *
1374 ccid_thread (void *arg)
1375 {
1376   chopstx_intr_t interrupt;
1377
1378   struct ep_in *epi = &endpoint_in;
1379   struct ep_out *epo = &endpoint_out;
1380   struct ccid *c = &ccid;
1381   struct apdu *a = &apdu;
1382
1383   (void)arg;
1384   usb_lld_init (USB_INITIAL_FEATURE);
1385   chopstx_claim_irq (&interrupt, INTR_REQ_USB);
1386   usb_interrupt_handler ();
1387
1388  reset:
1389   epi_init (epi, ENDP1, notify_tx, c);
1390   epo_init (epo, ENDP1, notify_icc, c);
1391   apdu_init (a);
1392   ccid_init (c, epi, epo, a);
1393
1394   icc_prepare_receive (c);
1395   while (1)
1396     {
1397       eventmask_t m;
1398       uint32_t timeout = USB_ICC_TIMEOUT;
1399       chopstx_poll_cond_t poll_desc;
1400
1401       eventflag_set_poll_desc (&c->ccid_comm, &poll_desc);
1402       chopstx_poll (&timeout, 2, &interrupt, &poll_desc);
1403       if (interrupt.ready)
1404         usb_interrupt_handler ();
1405
1406       if (poll_desc.ready)
1407         m = eventflag_wait (&c->ccid_comm);
1408
1409       if (m == EV_USB_RESET)
1410         {
1411           if (c->application)
1412             {
1413               chopstx_cancel (c->application);
1414               chopstx_join (c->application, NULL);
1415               c->application = 0;
1416             }
1417           goto reset;
1418         }
1419       else if (m == EV_CARD_CHANGE)
1420         {
1421           uint8_t int_msg[2];
1422
1423           int_msg[0] = NOTIFY_SLOT_CHANGE;
1424           if (c->icc_state == ICC_STATE_NOCARD)
1425             { /* Inserted!  */
1426               c->icc_state = ICC_STATE_START;
1427               int_msg[1] = 0x03;
1428             }
1429           else
1430             { /* Removed!  */
1431               if (c->application)
1432                 {
1433                   eventflag_signal (&c->openpgp_comm, EV_EXIT);
1434                   chopstx_join (c->application, NULL);
1435                   c->application = 0;
1436                 }
1437
1438               c->icc_state = ICC_STATE_NOCARD;
1439               int_msg[1] = 0x02;
1440             }
1441
1442           usb_lld_write (ENDP2, int_msg, sizeof int_msg);
1443           led_blink (LED_TWOSHOTS);
1444         }
1445       else if (m == EV_RX_DATA_READY)
1446         c->icc_state = icc_handle_data (c);
1447       else if (m == EV_EXEC_FINISHED)
1448         if (c->icc_state == ICC_STATE_EXECUTE)
1449           {
1450             if (c->a->sw == GPG_THREAD_TERMINATED)
1451               {
1452                 c->sw1sw2[0] = 0x90;
1453                 c->sw1sw2[1] = 0x00;
1454                 c->state = APDU_STATE_RESULT;
1455                 icc_send_data_block (c);
1456                 c->icc_state = ICC_STATE_EXITED;
1457                 break;
1458               }
1459
1460             c->a->cmd_apdu_data_len = 0;
1461             c->sw1sw2[0] = c->a->sw >> 8;
1462             c->sw1sw2[1] = c->a->sw & 0xff;
1463
1464             if (c->a->res_apdu_data_len <= c->a->expected_res_size)
1465               {
1466                 c->state = APDU_STATE_RESULT;
1467                 icc_send_data_block (c);
1468                 c->icc_state = ICC_STATE_WAIT;
1469               }
1470             else
1471               {
1472                 c->state = APDU_STATE_RESULT_GET_RESPONSE;
1473                 c->p = c->a->res_apdu_data;
1474                 c->len = c->a->res_apdu_data_len;
1475                 icc_send_data_block_gr (c, c->a->expected_res_size);
1476                 c->icc_state = ICC_STATE_WAIT;
1477               }
1478           }
1479         else
1480           {
1481             DEBUG_INFO ("ERR07\r\n");
1482           }
1483       else if (m == EV_TX_FINISHED)
1484         {
1485           if (c->state == APDU_STATE_RESULT)
1486             {
1487               c->state = APDU_STATE_WAIT_COMMAND;
1488               c->p = c->a->cmd_apdu_data;
1489               c->len = MAX_CMD_APDU_DATA_SIZE;
1490               c->err = 0;
1491               c->a->cmd_apdu_data_len = 0;
1492               c->a->expected_res_size = 0;
1493             }
1494
1495           if (c->state == APDU_STATE_WAIT_COMMAND
1496               || c->state == APDU_STATE_COMMAND_CHAINING
1497               || c->state == APDU_STATE_RESULT_GET_RESPONSE)
1498             icc_prepare_receive (c);
1499         }
1500       else                      /* Timeout */
1501         c->icc_state = icc_handle_timeout (c);
1502     }
1503
1504   if (c->application)
1505     {
1506       chopstx_join (c->application, NULL);
1507       c->application = 0;
1508     }
1509
1510   return NULL;
1511 }
1512
1513
1514 #ifdef DEBUG
1515 static void
1516 stdout_init (void)
1517 {
1518   chopstx_mutex_init (&stdout.m);
1519   chopstx_mutex_init (&stdout.m_dev);
1520   chopstx_cond_init (&stdout.cond_dev);
1521   stdout.connected = 0;
1522 }
1523
1524 void
1525 _write (const char *s, int len)
1526 {
1527   int packet_len;
1528
1529   if (len == 0)
1530     return;
1531
1532   chopstx_mutex_lock (&stdout.m);
1533
1534   chopstx_mutex_lock (&stdout.m_dev);
1535   if (!stdout.connected)
1536     chopstx_cond_wait (&stdout.cond_dev, &stdout.m_dev);
1537   chopstx_mutex_unlock (&stdout.m_dev);
1538
1539   do
1540     {
1541       packet_len =
1542         (len < VIRTUAL_COM_PORT_DATA_SIZE) ? len : VIRTUAL_COM_PORT_DATA_SIZE;
1543
1544       chopstx_mutex_lock (&stdout.m_dev);
1545       usb_lld_write (ENDP3, s, packet_len);
1546       chopstx_cond_wait (&stdout.cond_dev, &stdout.m_dev);
1547       chopstx_mutex_unlock (&stdout.m_dev);
1548
1549       s += packet_len;
1550       len -= packet_len;
1551     }
1552   /* Send a Zero-Length-Packet if the last packet is full size.  */
1553   while (len != 0 || packet_len == VIRTUAL_COM_PORT_DATA_SIZE);
1554
1555   chopstx_mutex_unlock (&stdout.m);
1556 }
1557
1558 #else
1559 void
1560 _write (const char *s, int size)
1561 {
1562   (void)s;
1563   (void)size;
1564 }
1565 #endif