docker: source checking container
[gnuk/gnuk.git] / src / usb-ccid.c
1 /*
2  * usb-ccid.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   const uint8_t *buf;
81   size_t cnt;
82   size_t buf_len;
83   void *priv;
84   void (*next_buf) (struct ep_in *epi, size_t len);
85 };
86
87 static void epi_init (struct ep_in *epi, int ep_num, void *priv)
88 {
89   epi->ep_num = ep_num;
90   epi->tx_done = 0;
91   epi->buf = NULL;
92   epi->cnt = 0;
93   epi->buf_len = 0;
94   epi->priv = priv;
95   epi->next_buf = NULL;
96 }
97
98 struct ep_out {
99   uint8_t ep_num;
100   uint8_t err;
101   uint8_t *buf;
102   size_t cnt;
103   size_t buf_len;
104   void *priv;
105   void (*next_buf) (struct ep_out *epo, size_t len);
106   int  (*end_rx) (struct ep_out *epo, size_t orig_len);
107 };
108
109 static struct ep_out endpoint_out;
110 static struct ep_in endpoint_in;
111
112 static void epo_init (struct ep_out *epo, int ep_num, void *priv)
113 {
114   epo->ep_num = ep_num;
115   epo->err = 0;
116   epo->buf = NULL;
117   epo->cnt = 0;
118   epo->buf_len = 0;
119   epo->priv = priv;
120   epo->next_buf = NULL;
121   epo->end_rx = NULL;
122 }
123
124 /*
125  * CCID Layer
126  */
127
128 /*
129  * Buffer of USB communication: for both of RX and TX
130  *
131  * The buffer will be filled by multiple RX packets (Bulk-OUT)
132  * or will be used for multiple TX packets (Bulk-IN)
133  */
134 static uint8_t ccid_buffer[USB_BUF_SIZE];
135
136 #define CCID_SET_PARAMS         0x61 /* non-ICCD command  */
137 #define CCID_POWER_ON           0x62
138 #define CCID_POWER_OFF          0x63
139 #define CCID_SLOT_STATUS        0x65 /* non-ICCD command */
140 #define CCID_SECURE             0x69 /* non-ICCD command */
141 #define CCID_GET_PARAMS         0x6C /* non-ICCD command */
142 #define CCID_RESET_PARAMS       0x6D /* non-ICCD command */
143 #define CCID_XFR_BLOCK          0x6F
144 #define CCID_DATA_BLOCK_RET     0x80
145 #define CCID_SLOT_STATUS_RET    0x81 /* non-ICCD result */
146 #define CCID_PARAMS_RET         0x82 /* non-ICCD result */
147
148 #define CCID_MSG_SEQ_OFFSET     6
149 #define CCID_MSG_STATUS_OFFSET  7
150 #define CCID_MSG_ERROR_OFFSET   8
151 #define CCID_MSG_CHAIN_OFFSET   9
152 #define CCID_MSG_DATA_OFFSET    10      /* == CCID_MSG_HEADER_SIZE */
153 #define CCID_MAX_MSG_DATA_SIZE  USB_BUF_SIZE
154
155 #define CCID_STATUS_RUN         0x00
156 #define CCID_STATUS_PRESENT     0x01
157 #define CCID_STATUS_NOTPRESENT  0x02
158 #define CCID_CMD_STATUS_OK      0x00
159 #define CCID_CMD_STATUS_ERROR   0x40
160 #define CCID_CMD_STATUS_TIMEEXT 0x80
161
162 #define CCID_ERROR_XFR_OVERRUN  0xFC
163
164 /*
165  * Since command-byte is at offset 0,
166  * error with offset 0 means "command not supported".
167  */
168 #define CCID_OFFSET_CMD_NOT_SUPPORTED 0
169 #define CCID_OFFSET_DATA_LEN 1
170 #define CCID_OFFSET_PARAM 8
171
172 struct ccid_header {
173   uint8_t msg_type;
174   uint32_t data_len;
175   uint8_t slot;
176   uint8_t seq;
177   uint8_t rsvd;
178   uint16_t param;
179 } __attribute__((packed));
180
181
182 /* Data structure handled by CCID layer */
183 struct ccid {
184   enum ccid_state ccid_state;
185   uint8_t state;
186   uint8_t err;
187
188   uint8_t *p;
189   size_t len;
190
191   struct ccid_header ccid_header;
192
193   uint8_t sw1sw2[2];
194   uint8_t chained_cls_ins_p1_p2[4];
195
196   /* lower layer */
197   struct ep_out *epo;
198   struct ep_in *epi;
199
200   /* from both layers */
201   struct eventflag ccid_comm;
202
203   /* upper layer */
204   struct eventflag openpgp_comm;
205   chopstx_t application;
206   struct apdu *a;
207 };
208
209 /*
210  * APDU_STATE_WAIT_COMMAND           +---------+
211  *        |           |              |         |
212  *        |           v              v         |
213  *        |      APDU_STATE_COMMAND_CHAINING --+
214  *        |                 |
215  *        v                 v
216  *      APDU_STATE_COMMAND_RECEIVED
217  *                  |
218  *                  v
219  *          ===================
220  *          | Process COMMAND |
221  *          ===================
222  *                  |
223  *                  v
224  *            +-----+----------+                  +---------+
225  *            |                |                  |         |
226  *            v                v                  v         |
227  * APDU_STATE_RESULT <---- APDU_STATE_RESULT_GET_RESPONSE --+
228  *         |
229  *         |
230  *         v
231  * APDU_STATE_WAIT_COMMAND
232  */
233
234 #define APDU_STATE_WAIT_COMMAND        0
235 #define APDU_STATE_COMMAND_CHAINING    1
236 #define APDU_STATE_COMMAND_RECEIVED    2
237 #define APDU_STATE_RESULT              3
238 #define APDU_STATE_RESULT_GET_RESPONSE 4
239
240 static void ccid_reset (struct ccid *c)
241 {
242   c->err = 0;
243   c->state = APDU_STATE_WAIT_COMMAND;
244   c->p = c->a->cmd_apdu_data;
245   c->len = MAX_CMD_APDU_DATA_SIZE;
246   c->a->cmd_apdu_data_len = 0;
247   c->a->expected_res_size = 0;
248 }
249
250 static void ccid_init (struct ccid *c, struct ep_in *epi, struct ep_out *epo,
251                        struct apdu *a)
252 {
253   c->ccid_state = CCID_STATE_START;
254   c->state = APDU_STATE_WAIT_COMMAND;
255   c->p = a->cmd_apdu_data;
256   c->len = MAX_CMD_APDU_DATA_SIZE;
257   c->err = 0;
258   memset (&c->ccid_header, 0, sizeof (struct ccid_header));
259   c->sw1sw2[0] = 0x90;
260   c->sw1sw2[1] = 0x00;
261   c->application = 0;
262   c->epi = epi;
263   c->epo = epo;
264   c->a = a;
265 }
266
267 /*
268  * Application layer
269  */
270
271 /*
272  * USB-CCID communication could be considered "half duplex".
273  *
274  * While the device is sending something, there is no possibility for
275  * the device to receive anything.
276  *
277  * While the device is receiving something, there is no possibility
278  * for the device to send anything.
279  *
280  * Thus, the buffer can be shared for RX and TX.
281  *
282  * Exception: When we support ABORT of CCID, it is possible to receive
283  * ABORT Class Specific Request to control pipe while we are
284  * receiving/sending something at OUT/IN endpoint.
285  *
286  */
287
288 #define CMD_APDU_HEAD_SIZE 5
289
290 static void apdu_init (struct apdu *a)
291 {
292   a->seq = 0;                   /* will be set by lower layer */
293   a->cmd_apdu_head = &ccid_buffer[0];
294   a->cmd_apdu_data = &ccid_buffer[5];
295   a->cmd_apdu_data_len = 0;     /* will be set by lower layer */
296   a->expected_res_size = 0;     /* will be set by lower layer */
297
298   a->sw = 0x9000;                    /* will be set by upper layer */
299   a->res_apdu_data = &ccid_buffer[5]; /* will be set by upper layer */
300   a->res_apdu_data_len = 0;          /* will be set by upper layer */
301 }
302
303
304 static void notify_tx (struct ep_in *epi)
305 {
306   struct ccid *c = (struct ccid *)epi->priv;
307
308   /* The sequence of Bulk-IN transactions finished */
309   eventflag_signal (&c->ccid_comm, EV_TX_FINISHED);
310 }
311
312 static void no_buf (struct ep_in *epi, size_t len)
313 {
314   (void)len;
315   epi->buf = NULL;
316   epi->cnt = 0;
317   epi->buf_len = 0;
318 }
319
320 static void set_sw1sw2 (struct ccid *c, size_t chunk_len)
321 {
322   if (c->a->expected_res_size >= c->len)
323     {
324       c->sw1sw2[0] = 0x90;
325       c->sw1sw2[1] = 0x00;
326     }
327   else
328     {
329       c->sw1sw2[0] = 0x61;
330       if (c->len - chunk_len >= 256)
331         c->sw1sw2[1] = 0;
332       else
333         c->sw1sw2[1] = (uint8_t)(c->len - chunk_len);
334     }
335 }
336
337 static void get_sw1sw2 (struct ep_in *epi, size_t len)
338 {
339   struct ccid *c = (struct ccid *)epi->priv;
340
341   (void)len;
342   epi->buf = c->sw1sw2;
343   epi->cnt = 0;
344   epi->buf_len = 2;
345   epi->next_buf = no_buf;
346 }
347
348
349 /*
350  * Tx done callback
351  */
352 static void
353 EP1_IN_Callback (uint16_t len)
354 {
355   struct ep_in *epi = &endpoint_in;
356
357   (void)len;
358   if (epi->buf == NULL)
359     if (epi->tx_done)
360       notify_tx (epi);
361     else
362       {
363         epi->tx_done = 1;
364         usb_lld_tx_enable (epi->ep_num, 0); /* send ZLP */
365       }
366   else
367     {
368       int tx_size = 0;
369       size_t remain = USB_LL_BUF_SIZE;
370       int offset = 0;
371
372       while (epi->buf)
373         if (epi->buf_len < remain)
374           {
375             usb_lld_txcpy (epi->buf, epi->ep_num, offset, epi->buf_len);
376             offset += epi->buf_len;
377             remain -= epi->buf_len;
378             tx_size += epi->buf_len;
379             epi->next_buf (epi, remain); /* Update epi->buf, cnt, buf_len */
380           }
381         else
382           {
383             usb_lld_txcpy (epi->buf, epi->ep_num, offset, remain);
384             epi->buf += remain;
385             epi->cnt += remain;
386             epi->buf_len -= remain;
387             tx_size += remain;
388             break;
389           }
390
391       if (tx_size < USB_LL_BUF_SIZE)
392         epi->tx_done = 1;
393       usb_lld_tx_enable (epi->ep_num, tx_size);
394     }
395 }
396
397
398 static void notify_icc (struct ep_out *epo)
399 {
400   struct ccid *c = (struct ccid *)epo->priv;
401
402   c->err = epo->err;
403   eventflag_signal (&c->ccid_comm, EV_RX_DATA_READY);
404 }
405
406 static int end_ccid_rx (struct ep_out *epo, size_t orig_len)
407 {
408   (void)orig_len;
409   if (epo->cnt < sizeof (struct ccid_header))
410     /* short packet, just ignore */
411     return 1;
412
413   /* icc message with no abdata */
414   return 0;
415 }
416
417 static int end_abdata (struct ep_out *epo, size_t orig_len)
418 {
419   struct ccid *c = (struct ccid *)epo->priv;
420   size_t len = epo->cnt;
421
422   if (orig_len == USB_LL_BUF_SIZE && len < c->ccid_header.data_len)
423     /* more packet comes */
424     return 1;
425
426   if (len != c->ccid_header.data_len)
427     epo->err = 1;
428
429   return 0;
430 }
431
432 static int end_cmd_apdu_head (struct ep_out *epo, size_t orig_len)
433 {
434   struct ccid *c = (struct ccid *)epo->priv;
435
436   (void)orig_len;
437
438   if (epo->cnt < 4 || epo->cnt != c->ccid_header.data_len)
439     {
440       epo->err = 1;
441       return 0;
442     }
443
444   if ((c->state == APDU_STATE_COMMAND_CHAINING)
445       && (c->chained_cls_ins_p1_p2[0] != (c->a->cmd_apdu_head[0] & ~0x10)
446           || c->chained_cls_ins_p1_p2[1] != c->a->cmd_apdu_head[1]
447           || c->chained_cls_ins_p1_p2[2] != c->a->cmd_apdu_head[2]
448           || c->chained_cls_ins_p1_p2[3] != c->a->cmd_apdu_head[3]))
449     /*
450      * Handling exceptional request.
451      *
452      * Host stops sending command APDU using command chaining,
453      * and start another command APDU.
454      *
455      * Discard old one, and start handling new one.
456      */
457     {
458       c->state = APDU_STATE_WAIT_COMMAND;
459       c->p = c->a->cmd_apdu_data;
460       c->len = MAX_CMD_APDU_DATA_SIZE;
461     }
462
463   if (epo->cnt == 4)
464     /* No Lc and Le */
465     c->a->expected_res_size = 0;
466   else if (epo->cnt == 5)
467     {
468       /* No Lc but Le */
469       c->a->expected_res_size = c->a->cmd_apdu_head[4];
470       if (c->a->expected_res_size == 0)
471         c->a->expected_res_size = 256;
472       c->a->cmd_apdu_head[4] = 0;
473     }
474
475   c->a->cmd_apdu_data_len = 0;
476   return 0;
477 }
478
479
480 static int end_nomore_data (struct ep_out *epo, size_t orig_len)
481 {
482   (void)epo;
483   if (orig_len == USB_LL_BUF_SIZE)
484     return 1;
485   else
486     return 0;
487 }
488
489
490 static int end_cmd_apdu_data (struct ep_out *epo, size_t orig_len)
491 {
492   struct ccid *c = (struct ccid *)epo->priv;
493   size_t len = epo->cnt;
494
495   if (orig_len == USB_LL_BUF_SIZE
496       && CMD_APDU_HEAD_SIZE + len < c->ccid_header.data_len)
497     /* more packet comes */
498     return 1;
499
500   if (CMD_APDU_HEAD_SIZE + len != c->ccid_header.data_len)
501     goto error;
502
503   if (len == c->a->cmd_apdu_head[4])
504     /* No Le field*/
505     c->a->expected_res_size = 0;
506   else if (len == (size_t)c->a->cmd_apdu_head[4] + 1)
507     {
508       /* it has Le field*/
509       c->a->expected_res_size = epo->buf[-1];
510       if (c->a->expected_res_size == 0)
511         c->a->expected_res_size = 256;
512       len--;
513     }
514   else
515     {
516     error:
517       epo->err = 1;
518       return 0;
519     }
520
521   c->a->cmd_apdu_data_len += len;
522   return 0;
523 }
524
525
526 static void nomore_data (struct ep_out *epo, size_t len)
527 {
528   (void)len;
529   epo->err = 1;
530   epo->end_rx = end_nomore_data;
531   epo->buf = NULL;
532   epo->buf_len = 0;
533   epo->cnt = 0;
534   epo->next_buf = nomore_data;
535 }
536
537 #define INS_GET_RESPONSE 0xc0
538
539 static void ccid_cmd_apdu_data (struct ep_out *epo, size_t len)
540 {
541   struct ccid *c = (struct ccid *)epo->priv;
542
543   (void)len;
544   if (c->state == APDU_STATE_RESULT_GET_RESPONSE
545       && c->a->cmd_apdu_head[1] != INS_GET_RESPONSE)
546     {
547       /*
548        * Handling exceptional request.
549        *
550        * Host didn't finish receiving the whole response APDU by GET RESPONSE,
551        * but initiates another command.
552        */
553
554       c->state = APDU_STATE_WAIT_COMMAND;
555       c->p = c->a->cmd_apdu_data;
556       c->len = MAX_CMD_APDU_DATA_SIZE;
557     }
558   else if (c->state == APDU_STATE_COMMAND_CHAINING)
559     {
560       if (c->chained_cls_ins_p1_p2[0] != (c->a->cmd_apdu_head[0] & ~0x10)
561           || c->chained_cls_ins_p1_p2[1] != c->a->cmd_apdu_head[1]
562           || c->chained_cls_ins_p1_p2[2] != c->a->cmd_apdu_head[2]
563           || c->chained_cls_ins_p1_p2[3] != c->a->cmd_apdu_head[3])
564         /*
565          * Handling exceptional request.
566          *
567          * Host stops sending command APDU using command chaining,
568          * and start another command APDU.
569          *
570          * Discard old one, and start handling new one.
571          */
572         {
573           c->state = APDU_STATE_WAIT_COMMAND;
574           c->p = c->a->cmd_apdu_data;
575           c->len = MAX_CMD_APDU_DATA_SIZE;
576           c->a->cmd_apdu_data_len = 0;
577         }
578     }
579
580   epo->end_rx = end_cmd_apdu_data;
581   epo->buf = c->p;
582   epo->buf_len = c->len;
583   epo->cnt = 0;
584   epo->next_buf = nomore_data;
585 }
586
587 static void ccid_abdata (struct ep_out *epo, size_t len)
588 {
589   struct ccid *c = (struct ccid *)epo->priv;
590
591   (void)len;
592   c->a->seq = c->ccid_header.seq;
593   if (c->ccid_header.msg_type == CCID_XFR_BLOCK)
594     {
595       c->a->seq = c->ccid_header.seq;
596       epo->end_rx = end_cmd_apdu_head;
597       epo->buf = c->a->cmd_apdu_head;
598       epo->buf_len = 5;
599       epo->cnt = 0;
600       epo->next_buf = ccid_cmd_apdu_data;
601     }
602   else
603     {
604       epo->end_rx = end_abdata;
605       epo->buf = c->p;
606       epo->buf_len = c->len;
607       epo->cnt = 0;
608       epo->next_buf = nomore_data;
609     }
610 }
611
612
613 static void
614 ccid_prepare_receive (struct ccid *c)
615 {
616   c->epo->err = 0;
617   c->epo->buf = (uint8_t *)&c->ccid_header;
618   c->epo->buf_len = sizeof (struct ccid_header);
619   c->epo->cnt = 0;
620   c->epo->next_buf = ccid_abdata;
621   c->epo->end_rx = end_ccid_rx;
622   usb_lld_rx_enable (c->epo->ep_num);
623   DEBUG_INFO ("Rx ready\r\n");
624 }
625
626 /*
627  * Rx ready callback
628  */
629
630 static void
631 EP1_OUT_Callback (uint16_t len)
632 {
633   struct ep_out *epo = &endpoint_out;
634   int offset = 0;
635   int cont;
636   size_t orig_len = len;
637
638   while (epo->err == 0)
639     if (len == 0)
640       break;
641     else if (len <= epo->buf_len)
642       {
643         usb_lld_rxcpy (epo->buf, epo->ep_num, offset, len);
644         epo->buf += len;
645         epo->cnt += len;
646         epo->buf_len -= len;
647         break;
648       }
649     else /* len > buf_len */
650       {
651         usb_lld_rxcpy (epo->buf, epo->ep_num, offset, epo->buf_len);
652         len -= epo->buf_len;
653         offset += epo->buf_len;
654         epo->next_buf (epo, len); /* Update epo->buf, cnt, buf_len */
655       }
656
657   /*
658    * ORIG_LEN to distingush ZLP and the end of transaction
659    *  (ORIG_LEN != USB_LL_BUF_SIZE)
660    */
661   cont = epo->end_rx (epo, orig_len);
662
663   if (cont)
664     usb_lld_rx_enable (epo->ep_num);
665   else
666     notify_icc (epo);
667 }
668
669
670 extern void EP6_IN_Callback (uint16_t len);
671
672 static void
673 usb_rx_ready (uint8_t ep_num, uint16_t len)
674 {
675   if (ep_num == ENDP1)
676     EP1_OUT_Callback (len);
677 #ifdef DEBUG
678   else if (ep_num == ENDP5)
679     {
680       chopstx_mutex_lock (&stdout.m_dev);
681       usb_lld_rx_enable (ep_num);
682       chopstx_mutex_unlock (&stdout.m_dev);
683     }
684 #endif
685 }
686
687 static void
688 usb_tx_done (uint8_t ep_num, uint16_t len)
689 {
690   if (ep_num == ENDP1)
691     EP1_IN_Callback (len);
692   else if (ep_num == ENDP2)
693     {
694       /* INTERRUPT Transfer done */
695     }
696 #ifdef DEBUG
697   else if (ep_num == ENDP3)
698     {
699       chopstx_mutex_lock (&stdout.m_dev);
700       chopstx_cond_signal (&stdout.cond_dev);
701       chopstx_mutex_unlock (&stdout.m_dev);
702     }
703 #endif
704 #ifdef PINPAD_DND_SUPPORT
705   else if (ep_num == ENDP6)
706     EP6_IN_Callback (len);
707 #endif
708 }
709
710 /*
711  * ATR (Answer To Reset) string
712  *
713  * TS = 0x3b: Direct conversion
714  * T0 = 0xda: TA1, TC1 and TD1 follow, 10 historical bytes
715  * TA1 = 0x11: FI=1, DI=1
716  * TC1 = 0xff
717  * TD1 = 0x81: TD2 follows, T=1
718  * TD2 = 0xb1: TA3, TB3 and TD3 follow, T=1
719  * TA3 = 0xFE: IFSC = 254 bytes
720  * TB3 = 0x55: BWI = 5, CWI = 5   (BWT timeout 3.2 sec)
721  * TD3 = 0x1f: TA4 follows, T=15
722  * TA4 = 0x03: 5V or 3.3V
723  *
724  * Minimum: 0x3b, 0x8a, 0x80, 0x01
725  *
726  */
727 static const uint8_t ATR_head[] = {
728   0x3b, 0xda, 0x11, 0xff, 0x81, 0xb1, 0xfe, 0x55, 0x1f, 0x03,
729 };
730
731 /*
732  * Send back error
733  */
734 static void ccid_error (struct ccid *c, int offset)
735 {
736   uint8_t ccid_reply[CCID_MSG_HEADER_SIZE];
737
738   ccid_reply[0] = CCID_SLOT_STATUS_RET; /* Any value should be OK */
739   ccid_reply[1] = 0x00;
740   ccid_reply[2] = 0x00;
741   ccid_reply[3] = 0x00;
742   ccid_reply[4] = 0x00;
743   ccid_reply[5] = 0x00; /* Slot */
744   ccid_reply[CCID_MSG_SEQ_OFFSET] = c->ccid_header.seq;
745   if (c->ccid_state == CCID_STATE_NOCARD)
746     ccid_reply[CCID_MSG_STATUS_OFFSET] = 2; /* 2: No ICC present */
747   else if (c->ccid_state == CCID_STATE_START)
748     /* 1: ICC present but not activated */
749     ccid_reply[CCID_MSG_STATUS_OFFSET] = 1;
750   else
751     ccid_reply[CCID_MSG_STATUS_OFFSET] = 0; /* An ICC is present and active */
752   ccid_reply[CCID_MSG_STATUS_OFFSET] |= CCID_CMD_STATUS_ERROR; /* Failed */
753   ccid_reply[CCID_MSG_ERROR_OFFSET] = offset;
754   ccid_reply[CCID_MSG_CHAIN_OFFSET] = 0x00;
755
756   /* This is a single packet Bulk-IN transaction */
757   c->epi->buf = NULL;
758   c->epi->tx_done = 1;
759   usb_lld_write (c->epi->ep_num, ccid_reply, CCID_MSG_HEADER_SIZE);
760 }
761
762 extern void *openpgp_card_thread (void *arg);
763
764 extern uint8_t __process3_stack_base__[], __process3_stack_size__[];
765 #define STACK_ADDR_GPG ((uint32_t)__process3_stack_base__)
766 #define STACK_SIZE_GPG ((uint32_t)__process3_stack_size__)
767 #define PRIO_GPG 1
768
769
770 /* Send back ATR (Answer To Reset) */
771 static enum ccid_state
772 ccid_power_on (struct ccid *c)
773 {
774   uint8_t p[CCID_MSG_HEADER_SIZE+1]; /* >= size of historical_bytes -1 */
775   int hist_len = historical_bytes[0];
776   size_t size_atr = sizeof (ATR_head) + hist_len + 1;
777   uint8_t xor_check = 0;
778   int i;
779
780   if (c->application == 0)
781     c->application = chopstx_create (PRIO_GPG, STACK_ADDR_GPG,
782                                      STACK_SIZE_GPG, openpgp_card_thread,
783                                      (void *)&c->ccid_comm);
784
785   p[0] = CCID_DATA_BLOCK_RET;
786   p[1] = size_atr;
787   p[2] = 0x00;
788   p[3] = 0x00;
789   p[4] = 0x00;
790   p[5] = 0x00;  /* Slot */
791   p[CCID_MSG_SEQ_OFFSET] = c->ccid_header.seq;
792   p[CCID_MSG_STATUS_OFFSET] = 0x00;
793   p[CCID_MSG_ERROR_OFFSET] = 0x00;
794   p[CCID_MSG_CHAIN_OFFSET] = 0x00;
795
796   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE);
797   usb_lld_txcpy (ATR_head, c->epi->ep_num, CCID_MSG_HEADER_SIZE,
798                  sizeof (ATR_head));
799   for (i = 1; i < (int)sizeof (ATR_head); i++)
800     xor_check ^= ATR_head[i];
801   memcpy (p, historical_bytes + 1, hist_len);
802 #ifdef LIFE_CYCLE_MANAGEMENT_SUPPORT
803   if (file_selection == 255)
804     p[7] = 0x03;
805 #endif
806   for (i = 0; i < hist_len; i++)
807     xor_check ^= p[i];
808   p[i] = xor_check;
809   usb_lld_txcpy (p, c->epi->ep_num, CCID_MSG_HEADER_SIZE + sizeof (ATR_head),
810                  hist_len+1);
811
812   /* This is a single packet Bulk-IN transaction */
813   c->epi->buf = NULL;
814   c->epi->tx_done = 1;
815   usb_lld_tx_enable (c->epi->ep_num, CCID_MSG_HEADER_SIZE + size_atr);
816   DEBUG_INFO ("ON\r\n");
817
818   return CCID_STATE_WAIT;
819 }
820
821 static void
822 ccid_send_status (struct ccid *c)
823 {
824   uint8_t ccid_reply[CCID_MSG_HEADER_SIZE];
825
826   ccid_reply[0] = CCID_SLOT_STATUS_RET;
827   ccid_reply[1] = 0x00;
828   ccid_reply[2] = 0x00;
829   ccid_reply[3] = 0x00;
830   ccid_reply[4] = 0x00;
831   ccid_reply[5] = 0x00; /* Slot */
832   ccid_reply[CCID_MSG_SEQ_OFFSET] = c->ccid_header.seq;
833   if (c->ccid_state == CCID_STATE_NOCARD)
834     ccid_reply[CCID_MSG_STATUS_OFFSET] = 2; /* 2: No ICC present */
835   else if (c->ccid_state == CCID_STATE_START)
836     /* 1: ICC present but not activated */
837     ccid_reply[CCID_MSG_STATUS_OFFSET] = 1;
838   else
839     ccid_reply[CCID_MSG_STATUS_OFFSET] = 0; /* An ICC is present and active */
840   ccid_reply[CCID_MSG_ERROR_OFFSET] = 0x00;
841   ccid_reply[CCID_MSG_CHAIN_OFFSET] = 0x00;
842
843   /* This is a single packet Bulk-IN transaction */
844   c->epi->buf = NULL;
845   c->epi->tx_done = 1;
846   usb_lld_write (c->epi->ep_num, ccid_reply, CCID_MSG_HEADER_SIZE);
847
848   led_blink (LED_SHOW_STATUS);
849 #ifdef DEBUG_MORE
850   DEBUG_INFO ("St\r\n");
851 #endif
852 }
853
854 static enum ccid_state
855 ccid_power_off (struct ccid *c)
856 {
857   if (c->application)
858     {
859       eventflag_signal (&c->openpgp_comm, EV_EXIT);
860       chopstx_join (c->application, NULL);
861       c->application = 0;
862     }
863
864   c->ccid_state = CCID_STATE_START; /* This status change should be here */
865   ccid_send_status (c);
866   DEBUG_INFO ("OFF\r\n");
867   return CCID_STATE_START;
868 }
869
870 static void
871 ccid_send_data_block_internal (struct ccid *c, uint8_t status, uint8_t error)
872 {
873   int tx_size = USB_LL_BUF_SIZE;
874   uint8_t p[CCID_MSG_HEADER_SIZE];
875   size_t len;
876
877   if (status == 0)
878     len = c->a->res_apdu_data_len + 2;
879   else
880     len = 0;
881
882   p[0] = CCID_DATA_BLOCK_RET;
883   p[1] = len & 0xFF;
884   p[2] = (len >> 8)& 0xFF;
885   p[3] = (len >> 16)& 0xFF;
886   p[4] = (len >> 24)& 0xFF;
887   p[5] = 0x00;  /* Slot */
888   p[CCID_MSG_SEQ_OFFSET] = c->a->seq;
889   p[CCID_MSG_STATUS_OFFSET] = status;
890   p[CCID_MSG_ERROR_OFFSET] = error;
891   p[CCID_MSG_CHAIN_OFFSET] = 0;
892
893   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE);
894   if (len == 0)
895     {
896       usb_lld_tx_enable (c->epi->ep_num, CCID_MSG_HEADER_SIZE);
897       return;
898     }
899
900   if (CCID_MSG_HEADER_SIZE + len <= USB_LL_BUF_SIZE)
901     {
902       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
903                      CCID_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
904       usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
905                      CCID_MSG_HEADER_SIZE + c->a->res_apdu_data_len, 2);
906       c->epi->buf = NULL;
907       if (CCID_MSG_HEADER_SIZE + len < USB_LL_BUF_SIZE)
908         c->epi->tx_done = 1;
909       tx_size = CCID_MSG_HEADER_SIZE + len;
910     }
911   else if (CCID_MSG_HEADER_SIZE + len - 1 == USB_LL_BUF_SIZE)
912     {
913       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
914                      CCID_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
915       usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
916                      CCID_MSG_HEADER_SIZE + c->a->res_apdu_data_len, 1);
917       c->epi->buf = &c->sw1sw2[1];
918       c->epi->cnt = 1;
919       c->epi->buf_len = 1;
920       c->epi->next_buf = no_buf;
921     }
922   else if (CCID_MSG_HEADER_SIZE + len - 2 == USB_LL_BUF_SIZE)
923     {
924       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num,
925                      CCID_MSG_HEADER_SIZE, c->a->res_apdu_data_len);
926       c->epi->buf = &c->sw1sw2[0];
927       c->epi->cnt = 0;
928       c->epi->buf_len = 2;
929       c->epi->next_buf = no_buf;
930     }
931   else
932     {
933       usb_lld_txcpy (c->a->res_apdu_data, c->epi->ep_num, CCID_MSG_HEADER_SIZE,
934                      USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
935       c->epi->buf = c->a->res_apdu_data + USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE;
936       c->epi->cnt = USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE;
937       c->epi->buf_len = c->a->res_apdu_data_len
938         - (USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
939       c->epi->next_buf = get_sw1sw2;
940     }
941
942   usb_lld_tx_enable (c->epi->ep_num, tx_size);
943 #ifdef DEBUG_MORE
944   DEBUG_INFO ("DATA\r\n");
945 #endif
946 }
947
948 static void
949 ccid_send_data_block (struct ccid *c)
950 {
951   ccid_send_data_block_internal (c, 0, 0);
952 }
953
954 static void
955 ccid_send_data_block_time_extension (struct ccid *c)
956 {
957   ccid_send_data_block_internal (c, CCID_CMD_STATUS_TIMEEXT, 1);
958 }
959
960 static void
961 ccid_send_data_block_0x9000 (struct ccid *c)
962 {
963   uint8_t p[CCID_MSG_HEADER_SIZE+2];
964   size_t len = 2;
965
966   p[0] = CCID_DATA_BLOCK_RET;
967   p[1] = len & 0xFF;
968   p[2] = (len >> 8)& 0xFF;
969   p[3] = (len >> 16)& 0xFF;
970   p[4] = (len >> 24)& 0xFF;
971   p[5] = 0x00;  /* Slot */
972   p[CCID_MSG_SEQ_OFFSET] = c->a->seq;
973   p[CCID_MSG_STATUS_OFFSET] = 0;
974   p[CCID_MSG_ERROR_OFFSET] = 0;
975   p[CCID_MSG_CHAIN_OFFSET] = 0;
976   p[CCID_MSG_CHAIN_OFFSET+1] = 0x90;
977   p[CCID_MSG_CHAIN_OFFSET+2] = 0x00;
978
979   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE + len);
980   c->epi->buf = NULL;
981   c->epi->tx_done = 1;
982
983   usb_lld_tx_enable (c->epi->ep_num, CCID_MSG_HEADER_SIZE + len);
984 #ifdef DEBUG_MORE
985   DEBUG_INFO ("DATA\r\n");
986 #endif
987 }
988
989 /*
990  * Reply to the host for "GET RESPONSE".
991  */
992 static void
993 ccid_send_data_block_gr (struct ccid *c, size_t chunk_len)
994 {
995   int tx_size = USB_LL_BUF_SIZE;
996   uint8_t p[CCID_MSG_HEADER_SIZE];
997   size_t len = chunk_len + 2;
998
999   p[0] = CCID_DATA_BLOCK_RET;
1000   p[1] = len & 0xFF;
1001   p[2] = (len >> 8)& 0xFF;
1002   p[3] = (len >> 16)& 0xFF;
1003   p[4] = (len >> 24)& 0xFF;
1004   p[5] = 0x00;  /* Slot */
1005   p[CCID_MSG_SEQ_OFFSET] = c->a->seq;
1006   p[CCID_MSG_STATUS_OFFSET] = 0;
1007   p[CCID_MSG_ERROR_OFFSET] = 0;
1008   p[CCID_MSG_CHAIN_OFFSET] = 0;
1009
1010   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE);
1011
1012   set_sw1sw2 (c, chunk_len);
1013
1014   if (chunk_len <= USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE)
1015     {
1016       int size_for_sw;
1017
1018       if (chunk_len <= USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE - 2)
1019         size_for_sw = 2;
1020       else if (chunk_len == USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE - 1)
1021         size_for_sw = 1;
1022       else
1023         size_for_sw = 0;
1024
1025       usb_lld_txcpy (c->p, c->epi->ep_num, CCID_MSG_HEADER_SIZE, chunk_len);
1026       if (size_for_sw)
1027         usb_lld_txcpy (c->sw1sw2, c->epi->ep_num,
1028                        CCID_MSG_HEADER_SIZE + chunk_len, size_for_sw);
1029       tx_size = CCID_MSG_HEADER_SIZE + chunk_len + size_for_sw;
1030       if (size_for_sw == 2)
1031         {
1032           c->epi->buf = NULL;
1033           if (tx_size < USB_LL_BUF_SIZE)
1034             c->epi->tx_done = 1;
1035           /* Don't set epi->tx_done = 1, when it requires ZLP */
1036         }
1037       else
1038         {
1039           c->epi->buf = c->sw1sw2 + size_for_sw;
1040           c->epi->cnt = size_for_sw;
1041           c->epi->buf_len = 2 - size_for_sw;
1042           c->epi->next_buf = no_buf;
1043         }
1044     }
1045   else
1046     {
1047       usb_lld_txcpy (c->p, c->epi->ep_num, CCID_MSG_HEADER_SIZE,
1048                      USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
1049       c->epi->buf = c->p + USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE;
1050       c->epi->cnt = 0;
1051       c->epi->buf_len = chunk_len - (USB_LL_BUF_SIZE - CCID_MSG_HEADER_SIZE);
1052       c->epi->next_buf = get_sw1sw2;
1053     }
1054
1055   c->p += chunk_len;
1056   c->len -= chunk_len;
1057   usb_lld_tx_enable (c->epi->ep_num, tx_size);
1058 #ifdef DEBUG_MORE
1059   DEBUG_INFO ("DATA\r\n");
1060 #endif
1061 }
1062
1063
1064 static void
1065 ccid_send_params (struct ccid *c)
1066 {
1067   uint8_t p[CCID_MSG_HEADER_SIZE];
1068   const uint8_t params[] =  {
1069     0x11,   /* bmFindexDindex */
1070     0x11, /* bmTCCKST1 */
1071     0xFE, /* bGuardTimeT1 */
1072     0x55, /* bmWaitingIntegersT1 */
1073     0x03, /* bClockStop */
1074     0xFE, /* bIFSC */
1075     0    /* bNadValue */
1076   };
1077
1078   p[0] = CCID_PARAMS_RET;
1079   p[1] = 0x07;  /* Length = 0x00000007 */
1080   p[2] = 0;
1081   p[3] = 0;
1082   p[4] = 0;
1083   p[5] = 0x00;  /* Slot */
1084   p[CCID_MSG_SEQ_OFFSET] = c->ccid_header.seq;
1085   p[CCID_MSG_STATUS_OFFSET] = 0;
1086   p[CCID_MSG_ERROR_OFFSET] = 0;
1087   p[CCID_MSG_CHAIN_OFFSET] = 0x01;  /* ProtocolNum: T=1 */
1088
1089   usb_lld_txcpy (p, c->epi->ep_num, 0, CCID_MSG_HEADER_SIZE);
1090   usb_lld_txcpy (params, c->epi->ep_num, CCID_MSG_HEADER_SIZE, sizeof params);
1091
1092   /* This is a single packet Bulk-IN transaction */
1093   c->epi->buf = NULL;
1094   c->epi->tx_done = 1;
1095   usb_lld_tx_enable (c->epi->ep_num, CCID_MSG_HEADER_SIZE + sizeof params);
1096 #ifdef DEBUG_MORE
1097   DEBUG_INFO ("PARAMS\r\n");
1098 #endif
1099 }
1100
1101
1102 static enum ccid_state
1103 ccid_handle_data (struct ccid *c)
1104 {
1105   enum ccid_state next_state = c->ccid_state;
1106
1107   if (c->err != 0)
1108     {
1109       ccid_reset (c);
1110       ccid_error (c, CCID_OFFSET_DATA_LEN);
1111       return next_state;
1112     }
1113
1114   switch (c->ccid_state)
1115     {
1116     case CCID_STATE_NOCARD:
1117       if (c->ccid_header.msg_type == CCID_SLOT_STATUS)
1118         ccid_send_status (c);
1119       else
1120         {
1121           DEBUG_INFO ("ERR00\r\n");
1122           ccid_error (c, CCID_OFFSET_CMD_NOT_SUPPORTED);
1123         }
1124       break;
1125     case CCID_STATE_START:
1126       if (c->ccid_header.msg_type == CCID_POWER_ON)
1127         {
1128           ccid_reset (c);
1129           next_state = ccid_power_on (c);
1130         }
1131       else if (c->ccid_header.msg_type == CCID_POWER_OFF)
1132         {
1133           ccid_reset (c);
1134           next_state = ccid_power_off (c);
1135         }
1136       else if (c->ccid_header.msg_type == CCID_SLOT_STATUS)
1137         ccid_send_status (c);
1138       else
1139         {
1140           DEBUG_INFO ("ERR01\r\n");
1141           ccid_error (c, CCID_OFFSET_CMD_NOT_SUPPORTED);
1142         }
1143       break;
1144     case CCID_STATE_WAIT:
1145       if (c->ccid_header.msg_type == CCID_POWER_ON)
1146         {
1147           /* Not in the spec., but pcscd/libccid */
1148           ccid_reset (c);
1149           next_state = ccid_power_on (c);
1150         }
1151       else if (c->ccid_header.msg_type == CCID_POWER_OFF)
1152         {
1153           ccid_reset (c);
1154           next_state = ccid_power_off (c);
1155         }
1156       else if (c->ccid_header.msg_type == CCID_SLOT_STATUS)
1157         ccid_send_status (c);
1158       else if (c->ccid_header.msg_type == CCID_XFR_BLOCK)
1159         {
1160           if (c->ccid_header.param == 0)
1161             {
1162               if ((c->a->cmd_apdu_head[0] & 0x10) == 0)
1163                 {
1164                   if (c->state == APDU_STATE_COMMAND_CHAINING)
1165                     {           /* command chaining finished */
1166                       c->p += c->a->cmd_apdu_head[4];
1167                       c->a->cmd_apdu_head[4] = 0;
1168                       DEBUG_INFO ("CMD chaning finished.\r\n");
1169                     }
1170
1171                   if (c->a->cmd_apdu_head[1] == INS_GET_RESPONSE
1172                       && c->state == APDU_STATE_RESULT_GET_RESPONSE)
1173                     {
1174                       size_t len = c->a->expected_res_size;
1175
1176                       if (c->len <= c->a->expected_res_size)
1177                         len = c->len;
1178
1179                       ccid_send_data_block_gr (c, len);
1180                       if (c->len == 0)
1181                         c->state = APDU_STATE_RESULT;
1182                       c->ccid_state = CCID_STATE_WAIT;
1183                       DEBUG_INFO ("GET Response.\r\n");
1184                     }
1185                   else
1186                     {             /* Give this message to GPG thread */
1187                       c->state = APDU_STATE_COMMAND_RECEIVED;
1188
1189                       c->a->sw = 0x9000;
1190                       c->a->res_apdu_data_len = 0;
1191                       c->a->res_apdu_data = &ccid_buffer[5];
1192
1193                       eventflag_signal (&c->openpgp_comm, EV_CMD_AVAILABLE);
1194                       next_state = CCID_STATE_EXECUTE;
1195                     }
1196                 }
1197               else
1198                 {
1199                   if (c->state == APDU_STATE_WAIT_COMMAND)
1200                     {           /* command chaining is started */
1201                       c->a->cmd_apdu_head[0] &= ~0x10;
1202                       memcpy (c->chained_cls_ins_p1_p2, c->a->cmd_apdu_head, 4);
1203                       c->state = APDU_STATE_COMMAND_CHAINING;
1204                     }
1205
1206                   c->p += c->a->cmd_apdu_head[4];
1207                   c->len -= c->a->cmd_apdu_head[4];
1208                   ccid_send_data_block_0x9000 (c);
1209                   DEBUG_INFO ("CMD chaning...\r\n");
1210                 }
1211             }
1212           else
1213             {                /* ICC block chaining is not supported. */
1214               DEBUG_INFO ("ERR02\r\n");
1215               ccid_error (c, CCID_OFFSET_PARAM);
1216             }
1217         }
1218       else if (c->ccid_header.msg_type == CCID_SET_PARAMS
1219                || c->ccid_header.msg_type == CCID_GET_PARAMS
1220                || c->ccid_header.msg_type == CCID_RESET_PARAMS)
1221         ccid_send_params (c);
1222       else if (c->ccid_header.msg_type == CCID_SECURE)
1223         {
1224           if (c->p != c->a->cmd_apdu_data)
1225             {
1226               /* SECURE received in the middle of command chaining */
1227               ccid_reset (c);
1228               ccid_error (c, CCID_OFFSET_DATA_LEN);
1229               return next_state;
1230             }
1231
1232           if (c->p[10-10] == 0x00) /* PIN verification */
1233             {
1234               c->a->cmd_apdu_head[0] = c->p[25-10];
1235               c->a->cmd_apdu_head[1] = c->p[26-10];
1236               c->a->cmd_apdu_head[2] = c->p[27-10];
1237               c->a->cmd_apdu_head[3] = c->p[28-10];
1238               /**/
1239               c->a->cmd_apdu_data[0] = 0; /* bConfirmPIN */
1240               c->a->cmd_apdu_data[1] = c->p[17-10]; /* bEntryValidationCondition */
1241               c->a->cmd_apdu_data[2] = c->p[18-10]; /* bNumberMessage */
1242               c->a->cmd_apdu_data[3] = c->p[19-10]; /* wLangId L */
1243               c->a->cmd_apdu_data[4] = c->p[20-10]; /* wLangId H */
1244               c->a->cmd_apdu_data[5] = c->p[21-10]; /* bMsgIndex */
1245
1246               c->a->cmd_apdu_data_len = 6;
1247               c->a->expected_res_size = 0;
1248
1249               c->a->sw = 0x9000;
1250               c->a->res_apdu_data_len = 0;
1251               c->a->res_apdu_data = &c->p[5];
1252
1253               eventflag_signal (&c->openpgp_comm, EV_VERIFY_CMD_AVAILABLE);
1254               next_state = CCID_STATE_EXECUTE;
1255             }
1256           else if (c->p[10-10] == 0x01) /* PIN Modification */
1257             {
1258               uint8_t num_msgs = c->p[21-10];
1259
1260               if (num_msgs == 0x00)
1261                 num_msgs = 1;
1262               else if (num_msgs == 0xff)
1263                 num_msgs = 3;
1264               c->a->cmd_apdu_head[0] = c->p[27 + num_msgs-10];
1265               c->a->cmd_apdu_head[1] = c->p[28 + num_msgs-10];
1266               c->a->cmd_apdu_head[2] = c->p[29 + num_msgs-10];
1267               c->a->cmd_apdu_head[3] = c->p[30 + num_msgs-10];
1268               /**/
1269               c->a->cmd_apdu_data[0] = c->p[19-10]; /* bConfirmPIN */
1270               c->a->cmd_apdu_data[1] = c->p[20-10]; /* bEntryValidationCondition */
1271               c->a->cmd_apdu_data[2] = c->p[21-10]; /* bNumberMessage */
1272               c->a->cmd_apdu_data[3] = c->p[22-10]; /* wLangId L */
1273               c->a->cmd_apdu_data[4] = c->p[23-10]; /* wLangId H */
1274               c->a->cmd_apdu_data[5] = c->p[24-10]; /* bMsgIndex, bMsgIndex1 */
1275               if (num_msgs >= 2)
1276                 c->a->cmd_apdu_data[6] = c->p[25-10]; /* bMsgIndex2 */
1277               if (num_msgs == 3)
1278                 c->a->cmd_apdu_data[7] = c->p[26-10]; /* bMsgIndex3 */
1279
1280               c->a->cmd_apdu_data_len = 5 + num_msgs;
1281               c->a->expected_res_size = 0;
1282
1283               c->a->sw = 0x9000;
1284               c->a->res_apdu_data_len = 0;
1285               c->a->res_apdu_data = &ccid_buffer[5];
1286
1287               eventflag_signal (&c->openpgp_comm, EV_MODIFY_CMD_AVAILABLE);
1288               next_state = CCID_STATE_EXECUTE;
1289             }
1290           else
1291             ccid_error (c, CCID_MSG_DATA_OFFSET);
1292         }
1293       else
1294         {
1295           DEBUG_INFO ("ERR03\r\n");
1296           DEBUG_BYTE (c->ccid_header.msg_type);
1297           ccid_error (c, CCID_OFFSET_CMD_NOT_SUPPORTED);
1298         }
1299       break;
1300     case CCID_STATE_EXECUTE:
1301       if (c->ccid_header.msg_type == CCID_POWER_OFF)
1302         next_state = ccid_power_off (c);
1303       else if (c->ccid_header.msg_type == CCID_SLOT_STATUS)
1304         ccid_send_status (c);
1305       else
1306         {
1307           DEBUG_INFO ("ERR04\r\n");
1308           DEBUG_BYTE (c->ccid_header.msg_type);
1309           ccid_error (c, CCID_OFFSET_CMD_NOT_SUPPORTED);
1310         }
1311       break;
1312     default:
1313       next_state = CCID_STATE_START;
1314       DEBUG_INFO ("ERR10\r\n");
1315       break;
1316     }
1317
1318   return next_state;
1319 }
1320
1321 static enum ccid_state
1322 ccid_handle_timeout (struct ccid *c)
1323 {
1324   enum ccid_state next_state = c->ccid_state;
1325
1326   switch (c->ccid_state)
1327     {
1328     case CCID_STATE_EXECUTE:
1329       ccid_send_data_block_time_extension (c);
1330       break;
1331     default:
1332       break;
1333     }
1334
1335   led_blink (LED_ONESHOT);
1336   return next_state;
1337 }
1338
1339 static struct ccid ccid;
1340 enum ccid_state *const ccid_state_p = &ccid.ccid_state;
1341
1342 void
1343 ccid_card_change_signal (int how)
1344 {
1345   struct ccid *c = &ccid;
1346
1347   if (how == CARD_CHANGE_TOGGLE
1348       || (c->ccid_state == CCID_STATE_NOCARD && how == CARD_CHANGE_INSERT)
1349       || (c->ccid_state != CCID_STATE_NOCARD && how == CARD_CHANGE_REMOVE))
1350     eventflag_signal (&c->ccid_comm, EV_CARD_CHANGE);
1351 }
1352
1353 void
1354 ccid_usb_reset (int full)
1355 {
1356   struct ccid *c = &ccid;
1357
1358   eventflag_signal (&c->ccid_comm,
1359                     full ? EV_USB_DEVICE_RESET : EV_USB_SET_INTERFACE);
1360 }
1361
1362
1363 #define NOTIFY_SLOT_CHANGE 0x50
1364 static void
1365 ccid_notify_slot_change (struct ccid *c)
1366 {
1367   uint8_t msg;
1368   uint8_t notification[2];
1369
1370   if (c->ccid_state == CCID_STATE_NOCARD)
1371     msg = 0x02;
1372   else
1373     msg = 0x03;
1374
1375   notification[0] = NOTIFY_SLOT_CHANGE;
1376   notification[1] = msg;
1377   usb_lld_write (ENDP2, notification, sizeof notification);
1378   led_blink (LED_TWOSHOTS);
1379 }
1380
1381
1382 #define USB_CCID_TIMEOUT (1950*1000)
1383
1384 #define GPG_THREAD_TERMINATED 0xffff
1385
1386
1387 #define INTR_REQ_USB 20
1388
1389 extern uint32_t bDeviceState;
1390 extern void usb_device_reset (struct usb_dev *dev);
1391 extern int usb_setup (struct usb_dev *dev);
1392 extern void usb_ctrl_write_finish (struct usb_dev *dev);
1393 extern int usb_set_configuration (struct usb_dev *dev);
1394 extern int usb_set_interface (struct usb_dev *dev);
1395 extern int usb_get_interface (struct usb_dev *dev);
1396 extern int usb_get_status_interface (struct usb_dev *dev);
1397
1398 extern int usb_get_descriptor (struct usb_dev *dev);
1399
1400 static void
1401 usb_event_handle (struct usb_dev *dev)
1402 {
1403   uint8_t ep_num;
1404   int e;
1405
1406   e = usb_lld_event_handler (dev);
1407   ep_num = USB_EVENT_ENDP (e);
1408
1409   if (ep_num != 0)
1410     {
1411       if (USB_EVENT_TXRX (e))
1412         usb_tx_done (ep_num, USB_EVENT_LEN (e));
1413       else
1414         usb_rx_ready (ep_num, USB_EVENT_LEN (e));
1415     }
1416   else
1417     switch (USB_EVENT_ID (e))
1418       {
1419       case USB_EVENT_DEVICE_RESET:
1420         usb_device_reset (dev);
1421         break;
1422
1423       case USB_EVENT_DEVICE_ADDRESSED:
1424         bDeviceState = ADDRESSED;
1425         break;
1426
1427       case USB_EVENT_GET_DESCRIPTOR:
1428         if (usb_get_descriptor (dev) < 0)
1429           usb_lld_ctrl_error (dev);
1430         break;
1431
1432       case USB_EVENT_SET_CONFIGURATION:
1433         if (usb_set_configuration (dev) < 0)
1434           usb_lld_ctrl_error (dev);
1435         break;
1436
1437       case USB_EVENT_SET_INTERFACE:
1438         if (usb_set_interface (dev) < 0)
1439           usb_lld_ctrl_error (dev);
1440         break;
1441
1442       case USB_EVENT_CTRL_REQUEST:
1443         /* Device specific device request.  */
1444         if (usb_setup (dev) < 0)
1445           usb_lld_ctrl_error (dev);
1446         break;
1447
1448       case USB_EVENT_GET_STATUS_INTERFACE:
1449         if (usb_get_status_interface (dev) < 0)
1450           usb_lld_ctrl_error (dev);
1451         break;
1452
1453       case USB_EVENT_GET_INTERFACE:
1454         if (usb_get_interface (dev) < 0)
1455           usb_lld_ctrl_error (dev);
1456         break;
1457
1458       case USB_EVENT_SET_FEATURE_DEVICE:
1459       case USB_EVENT_SET_FEATURE_ENDPOINT:
1460       case USB_EVENT_CLEAR_FEATURE_DEVICE:
1461       case USB_EVENT_CLEAR_FEATURE_ENDPOINT:
1462         usb_lld_ctrl_ack (dev);
1463         break;
1464
1465       case USB_EVENT_CTRL_WRITE_FINISH:
1466         /* Control WRITE transfer finished.  */
1467         usb_ctrl_write_finish (dev);
1468         break;
1469
1470       case USB_EVENT_OK:
1471       case USB_EVENT_DEVICE_SUSPEND:
1472       default:
1473         break;
1474       }
1475 }
1476
1477 static void
1478 poll_event_intr (uint32_t *timeout, struct eventflag *ev, chopstx_intr_t *intr)
1479 {
1480   chopstx_poll_cond_t poll_desc;
1481   struct chx_poll_head *pd_array[2] = {
1482     (struct chx_poll_head *)intr,
1483     (struct chx_poll_head *)&poll_desc
1484   };
1485
1486   eventflag_prepare_poll (ev, &poll_desc);
1487   chopstx_poll (timeout, 2, pd_array);
1488 }
1489
1490 void *
1491 ccid_thread (void *arg)
1492 {
1493   chopstx_intr_t interrupt;
1494   uint32_t timeout;
1495   struct usb_dev dev;
1496   struct ccid *c = &ccid;
1497
1498   (void)arg;
1499
1500   eventflag_init (&ccid.ccid_comm);
1501   eventflag_init (&ccid.openpgp_comm);
1502
1503   usb_lld_init (&dev, USB_INITIAL_FEATURE);
1504   chopstx_claim_irq (&interrupt, INTR_REQ_USB);
1505   usb_event_handle (&dev);      /* For old SYS < 3.0 */
1506
1507  device_reset:
1508   {
1509     struct ep_in *epi = &endpoint_in;
1510     struct ep_out *epo = &endpoint_out;
1511     struct apdu *a = &apdu;
1512
1513     epi_init (epi, ENDP1, c);
1514     epo_init (epo, ENDP1, c);
1515     apdu_init (a);
1516     ccid_init (c, epi, epo, a);
1517   }
1518
1519   while (bDeviceState != CONFIGURED)
1520     {
1521       poll_event_intr (NULL, &c->ccid_comm, &interrupt);
1522       if (interrupt.ready)
1523         usb_event_handle (&dev);
1524
1525       eventflag_get (&c->ccid_comm);
1526       /* Ignore event while not-configured.  */
1527     }
1528
1529  interface_reset:
1530   timeout = USB_CCID_TIMEOUT;
1531   ccid_prepare_receive (c);
1532   ccid_notify_slot_change (c);
1533   while (1)
1534     {
1535       eventmask_t m;
1536
1537       poll_event_intr (&timeout, &c->ccid_comm, &interrupt);
1538       if (interrupt.ready)
1539         {
1540           usb_event_handle (&dev);
1541           continue;
1542         }
1543
1544       timeout = USB_CCID_TIMEOUT;
1545       m = eventflag_get (&c->ccid_comm);
1546
1547       if (m == EV_USB_DEVICE_RESET)
1548         {
1549           if (c->application)
1550             {
1551               chopstx_cancel (c->application);
1552               chopstx_join (c->application, NULL);
1553               c->application = 0;
1554             }
1555           goto device_reset;
1556         }
1557       else if (m == EV_USB_SET_INTERFACE)
1558         /* Upon receival of SET_INTERFACE, the endpoint is reset to RX_NAK.
1559          * Thus, we need to prepare receive again.
1560          */
1561         goto interface_reset;
1562       else if (m == EV_CARD_CHANGE)
1563         {
1564           if (c->ccid_state == CCID_STATE_NOCARD)
1565             /* Inserted!  */
1566             c->ccid_state = CCID_STATE_START;
1567           else
1568             { /* Removed!  */
1569               if (c->application)
1570                 {
1571                   eventflag_signal (&c->openpgp_comm, EV_EXIT);
1572                   chopstx_join (c->application, NULL);
1573                   c->application = 0;
1574                 }
1575
1576               c->ccid_state = CCID_STATE_NOCARD;
1577             }
1578
1579           ccid_notify_slot_change (c);
1580         }
1581       else if (m == EV_RX_DATA_READY)
1582         c->ccid_state = ccid_handle_data (c);
1583       else if (m == EV_EXEC_FINISHED)
1584         if (c->ccid_state == CCID_STATE_EXECUTE)
1585           {
1586             if (c->a->sw == GPG_THREAD_TERMINATED)
1587               {
1588                 c->sw1sw2[0] = 0x90;
1589                 c->sw1sw2[1] = 0x00;
1590                 c->state = APDU_STATE_RESULT;
1591                 ccid_send_data_block (c);
1592                 c->ccid_state = CCID_STATE_EXITED;
1593                 break;
1594               }
1595
1596             c->a->cmd_apdu_data_len = 0;
1597             c->sw1sw2[0] = c->a->sw >> 8;
1598             c->sw1sw2[1] = c->a->sw & 0xff;
1599
1600             if (c->a->res_apdu_data_len <= c->a->expected_res_size)
1601               {
1602                 c->state = APDU_STATE_RESULT;
1603                 ccid_send_data_block (c);
1604                 c->ccid_state = CCID_STATE_WAIT;
1605               }
1606             else
1607               {
1608                 c->state = APDU_STATE_RESULT_GET_RESPONSE;
1609                 c->p = c->a->res_apdu_data;
1610                 c->len = c->a->res_apdu_data_len;
1611                 ccid_send_data_block_gr (c, c->a->expected_res_size);
1612                 c->ccid_state = CCID_STATE_WAIT;
1613               }
1614           }
1615         else
1616           {
1617             DEBUG_INFO ("ERR07\r\n");
1618           }
1619       else if (m == EV_TX_FINISHED)
1620         {
1621           if (c->state == APDU_STATE_RESULT)
1622             {
1623               c->state = APDU_STATE_WAIT_COMMAND;
1624               c->p = c->a->cmd_apdu_data;
1625               c->len = MAX_CMD_APDU_DATA_SIZE;
1626               c->err = 0;
1627               c->a->cmd_apdu_data_len = 0;
1628               c->a->expected_res_size = 0;
1629             }
1630
1631           if (c->state == APDU_STATE_WAIT_COMMAND
1632               || c->state == APDU_STATE_COMMAND_CHAINING
1633               || c->state == APDU_STATE_RESULT_GET_RESPONSE)
1634             ccid_prepare_receive (c);
1635         }
1636       else                      /* Timeout */
1637         c->ccid_state = ccid_handle_timeout (c);
1638     }
1639
1640   if (c->application)
1641     {
1642       chopstx_join (c->application, NULL);
1643       c->application = 0;
1644     }
1645
1646   /* Loading reGNUal.  */
1647   while (bDeviceState != UNCONNECTED)
1648     {
1649       chopstx_intr_wait (&interrupt);
1650       usb_event_handle (&dev);
1651     }
1652
1653   return NULL;
1654 }
1655
1656
1657 #ifdef DEBUG
1658 #include "usb-cdc.h"
1659
1660 void
1661 stdout_init (void)
1662 {
1663   chopstx_mutex_init (&stdout.m);
1664   chopstx_mutex_init (&stdout.m_dev);
1665   chopstx_cond_init (&stdout.cond_dev);
1666   stdout.connected = 0;
1667 }
1668
1669 void
1670 _write (const char *s, int len)
1671 {
1672   int packet_len;
1673
1674   if (len == 0)
1675     return;
1676
1677   chopstx_mutex_lock (&stdout.m);
1678
1679   chopstx_mutex_lock (&stdout.m_dev);
1680   if (!stdout.connected)
1681     chopstx_cond_wait (&stdout.cond_dev, &stdout.m_dev);
1682   chopstx_mutex_unlock (&stdout.m_dev);
1683
1684   do
1685     {
1686       packet_len =
1687         (len < VIRTUAL_COM_PORT_DATA_SIZE) ? len : VIRTUAL_COM_PORT_DATA_SIZE;
1688
1689       chopstx_mutex_lock (&stdout.m_dev);
1690       usb_lld_write (ENDP3, s, packet_len);
1691       chopstx_cond_wait (&stdout.cond_dev, &stdout.m_dev);
1692       chopstx_mutex_unlock (&stdout.m_dev);
1693
1694       s += packet_len;
1695       len -= packet_len;
1696     }
1697   /* Send a Zero-Length-Packet if the last packet is full size.  */
1698   while (len != 0 || packet_len == VIRTUAL_COM_PORT_DATA_SIZE);
1699
1700   chopstx_mutex_unlock (&stdout.m);
1701 }
1702
1703 #else
1704 void
1705 _write (const char *s, int size)
1706 {
1707   (void)s;
1708   (void)size;
1709 }
1710 #endif