disconnectafter wake-up bug fix by Bob Dunlop.
[gnupg.git] / scd / pcsc-wrapper.c
1 /* pcsc-wrapper.c - Wrapper for ccessing the PC/SC service
2  *      Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 /*
23   This wrapper is required to handle problems with the libpscslite
24   library.  That library assumes that pthreads are used and fails
25   badly if one tries to use it with a procerss using Pth.
26
27   The operation model is pretty simple: It reads requests from stdin
28   and returns the answer on stdout.  There is no direct mapping to the
29   pcsc interface but to a higher level one which resembles the code
30   used in scdaemon (apdu.c) when not using Pth or while running under
31   Windows.
32   
33   The interface is binary consisting of a command tag and the length
34   of the parameter list.  The calling process needs to pass the
35   version number of the interface on the command line to make sure
36   that both agree on the same interface.  For each port a separate
37   instance of this process needs to be started.
38
39 */
40
41 #ifdef HAVE_CONFIG_H
42 #include <config.h>
43 #endif
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <stddef.h>
47 #include <string.h>
48 #include <errno.h>
49 #include <stdarg.h>
50 #include <assert.h>
51 #include <dlfcn.h>
52
53
54 #define PGM "pcsc-wrapper"
55
56 /* Allow for a standalone build. */
57 #ifdef VERSION
58 #define MYVERSION_LINE PGM " (GnuPG) " VERSION
59 #define BUGREPORT_LINE "\nReport bugs to <bug-gnupg@gnu.org>.\n"
60 #else
61 #define MYVERSION_LINE PGM 
62 #define BUGREPORT_LINE ""
63 #endif
64
65 #define DEFAULT_PCSC_DRIVER "libpcsclite.so"
66
67
68 static int verbose;
69
70
71 /* PC/SC constants and function pointer. */
72 #define PCSC_SCOPE_USER      0 
73 #define PCSC_SCOPE_TERMINAL  1 
74 #define PCSC_SCOPE_SYSTEM    2 
75 #define PCSC_SCOPE_GLOBAL    3 
76
77 #define PCSC_PROTOCOL_T0     1 
78 #define PCSC_PROTOCOL_T1     2 
79 #define PCSC_PROTOCOL_RAW    4 
80
81 #define PCSC_SHARE_EXCLUSIVE 1
82 #define PCSC_SHARE_SHARED    2
83 #define PCSC_SHARE_DIRECT    3
84
85 #define PCSC_LEAVE_CARD      0
86 #define PCSC_RESET_CARD      1
87 #define PCSC_UNPOWER_CARD    2
88 #define PCSC_EJECT_CARD      3
89
90 #define PCSC_UNKNOWN    0x0001  
91 #define PCSC_ABSENT     0x0002  /* Card is absent.  */
92 #define PCSC_PRESENT    0x0004  /* Card is present.  */
93 #define PCSC_SWALLOWED  0x0008  /* Card is present and electrical connected. */
94 #define PCSC_POWERED    0x0010  /* Card is powered.  */
95 #define PCSC_NEGOTIABLE 0x0020  /* Card is awaiting PTS.  */
96 #define PCSC_SPECIFIC   0x0040  /* Card is ready for use.  */
97
98 #define PCSC_STATE_UNAWARE     0x0000  /* Want status.  */
99 #define PCSC_STATE_IGNORE      0x0001  /* Ignore this reader.  */
100 #define PCSC_STATE_CHANGED     0x0002  /* State has changed.  */
101 #define PCSC_STATE_UNKNOWN     0x0004  /* Reader unknown.  */
102 #define PCSC_STATE_UNAVAILABLE 0x0008  /* Status unavailable.  */
103 #define PCSC_STATE_EMPTY       0x0010  /* Card removed.  */
104 #define PCSC_STATE_PRESENT     0x0020  /* Card inserted.  */
105 #define PCSC_STATE_ATRMATCH    0x0040  /* ATR matches card. */
106 #define PCSC_STATE_EXCLUSIVE   0x0080  /* Exclusive Mode.  */
107 #define PCSC_STATE_INUSE       0x0100  /* Shared mode.  */
108 #define PCSC_STATE_MUTE        0x0200  /* Unresponsive card.  */
109
110 struct pcsc_io_request_s {
111   unsigned long protocol; 
112   unsigned long pci_len;
113 };
114
115 typedef struct pcsc_io_request_s *pcsc_io_request_t;
116
117 struct pcsc_readerstate_s
118 {
119   const char *reader;
120   void *user_data;
121   unsigned long current_state;
122   unsigned long event_state;
123   unsigned long atrlen;
124   unsigned char atr[33];
125 };
126
127 typedef struct pcsc_readerstate_s *pcsc_readerstate_t;
128
129
130 static int driver_is_open;     /* True if the PC/SC driver has been
131                                   initialzied and is ready for
132                                   operations.  The following variables
133                                   are then valid. */
134 static unsigned long pcsc_context;  /* The current PC/CS context. */
135 static char *current_rdrname;
136 static unsigned long pcsc_card;
137 static unsigned long pcsc_protocol;
138 static unsigned char current_atr[33];
139 static size_t current_atrlen;
140
141 long (* pcsc_establish_context) (unsigned long scope,
142                                  const void *reserved1,
143                                  const void *reserved2,
144                                  unsigned long *r_context);
145 long (* pcsc_release_context) (unsigned long context);
146 long (* pcsc_list_readers) (unsigned long context,
147                             const char *groups,
148                             char *readers, unsigned long*readerslen);
149 long (* pcsc_get_status_change) (unsigned long context,
150                                  unsigned long timeout,
151                                  pcsc_readerstate_t readerstates,
152                                  unsigned long nreaderstates);
153 long (* pcsc_connect) (unsigned long context,
154                        const char *reader,
155                        unsigned long share_mode,
156                        unsigned long preferred_protocols,
157                        unsigned long *r_card,
158                        unsigned long *r_active_protocol);
159 long (* pcsc_reconnect) (unsigned long card,
160                          unsigned long share_mode,
161                          unsigned long preferred_protocols,
162                          unsigned long initialization,
163                          unsigned long *r_active_protocol);
164 long (* pcsc_disconnect) (unsigned long card,
165                           unsigned long disposition);
166 long (* pcsc_status) (unsigned long card,
167                       char *reader, unsigned long *readerlen,
168                       unsigned long *r_state,
169                       unsigned long *r_protocol,
170                       unsigned char *atr, unsigned long *atrlen);
171 long (* pcsc_begin_transaction) (unsigned long card);
172 long (* pcsc_end_transaction) (unsigned long card);
173 long (* pcsc_transmit) (unsigned long card,
174                         const pcsc_io_request_t send_pci,
175                         const unsigned char *send_buffer,
176                         unsigned long send_len,
177                         pcsc_io_request_t recv_pci,
178                         unsigned char *recv_buffer,
179                         unsigned long *recv_len);
180 long (* pcsc_set_timeout) (unsigned long context,
181                            unsigned long timeout);
182
183
184
185 static void
186 bad_request (const char *type)
187 {
188   fprintf (stderr, PGM ": bad `%s' request\n", type);
189   exit (1);
190 }
191
192 static void
193 request_failed (int err)
194 {
195   if (!err)
196     err = -1;
197
198   putchar (0x81); /* Simple error/success response. */
199
200   putchar (0);
201   putchar (0);
202   putchar (0);
203   putchar (4);
204
205   putchar ((err >> 24) & 0xff);
206   putchar ((err >> 16) & 0xff);
207   putchar ((err >>  8) & 0xff);
208   putchar ((err      ) & 0xff);
209
210   fflush (stdout);
211 }
212
213
214 static void
215 request_succeeded (const void *buffer, size_t buflen)
216 {
217   size_t len;
218
219   putchar (0x81); /* Simple error/success response. */
220
221   len = 4 + buflen;
222   putchar ((len >> 24) & 0xff);
223   putchar ((len >> 16) & 0xff);
224   putchar ((len >>  8) & 0xff);
225   putchar ((len      ) & 0xff);
226
227   /* Error code. */
228   putchar (0);
229   putchar (0);
230   putchar (0);
231   putchar (0);
232
233   /* Optional reponse string. */
234   if (buffer)
235     fwrite (buffer, buflen, 1, stdout);
236
237   fflush (stdout);
238 }
239   
240
241
242 static unsigned long
243 read_32 (FILE *fp)
244 {
245   int c1, c2, c3, c4;
246
247   c1 = getc (stdin);
248   c2 = getc (stdin);
249   c3 = getc (stdin);
250   c4 = getc (stdin);
251   if (c1 == EOF || c2 == EOF || c3 == EOF || c4 == EOF)
252     {
253       fprintf (stderr, PGM ": premature EOF while parsing request\n");
254       exit (1);
255     }
256   return (c1 << 24) | (c2 << 16) | (c3 << 8) | c4;
257 }
258
259
260
261 static const char *
262 pcsc_error_string (long err)
263 {
264   const char *s;
265
266   if (!err)
267     return "okay";
268   if ((err & 0x80100000) != 0x80100000)
269     return "invalid PC/SC error code";
270   err &= 0xffff;
271   switch (err)
272     {
273     case 0x0002: s = "cancelled"; break;
274     case 0x000e: s = "can't dispose"; break;
275     case 0x0008: s = "insufficient buffer"; break;   
276     case 0x0015: s = "invalid ATR"; break;
277     case 0x0003: s = "invalid handle"; break;
278     case 0x0004: s = "invalid parameter"; break; 
279     case 0x0005: s = "invalid target"; break;
280     case 0x0011: s = "invalid value"; break; 
281     case 0x0006: s = "no memory"; break;  
282     case 0x0013: s = "comm error"; break;      
283     case 0x0001: s = "internal error"; break;     
284     case 0x0014: s = "unknown error"; break; 
285     case 0x0007: s = "waited too long"; break;  
286     case 0x0009: s = "unknown reader"; break;
287     case 0x000a: s = "timeout"; break; 
288     case 0x000b: s = "sharing violation"; break;       
289     case 0x000c: s = "no smartcard"; break;
290     case 0x000d: s = "unknown card"; break;   
291     case 0x000f: s = "proto mismatch"; break;          
292     case 0x0010: s = "not ready"; break;               
293     case 0x0012: s = "system cancelled"; break;        
294     case 0x0016: s = "not transacted"; break;
295     case 0x0017: s = "reader unavailable"; break; 
296     case 0x0065: s = "unsupported card"; break;        
297     case 0x0066: s = "unresponsive card"; break;       
298     case 0x0067: s = "unpowered card"; break;          
299     case 0x0068: s = "reset card"; break;              
300     case 0x0069: s = "removed card"; break;            
301     case 0x006a: s = "inserted card"; break;           
302     case 0x001f: s = "unsupported feature"; break;     
303     case 0x0019: s = "PCI too small"; break;           
304     case 0x001a: s = "reader unsupported"; break;      
305     case 0x001b: s = "duplicate reader"; break;        
306     case 0x001c: s = "card unsupported"; break;        
307     case 0x001d: s = "no service"; break;              
308     case 0x001e: s = "service stopped"; break;      
309     default:     s = "unknown PC/SC error code"; break;
310     }
311   return s;
312 }
313
314 static void
315 load_pcsc_driver (const char *libname)
316 {
317   void *handle;
318
319   handle = dlopen (libname, RTLD_LAZY);
320   if (!handle)
321     {
322       fprintf (stderr, PGM ": failed to open driver `%s': %s",
323                libname, dlerror ());
324       exit (1);
325     }
326
327   pcsc_establish_context = dlsym (handle, "SCardEstablishContext");
328   pcsc_release_context   = dlsym (handle, "SCardReleaseContext");
329   pcsc_list_readers      = dlsym (handle, "SCardListReaders");
330   pcsc_get_status_change = dlsym (handle, "SCardGetStatusChange");
331   pcsc_connect           = dlsym (handle, "SCardConnect");
332   pcsc_reconnect         = dlsym (handle, "SCardReconnect");
333   pcsc_disconnect        = dlsym (handle, "SCardDisconnect");
334   pcsc_status            = dlsym (handle, "SCardStatus");
335   pcsc_begin_transaction = dlsym (handle, "SCardBeginTransaction");
336   pcsc_end_transaction   = dlsym (handle, "SCardEndTransaction");
337   pcsc_transmit          = dlsym (handle, "SCardTransmit");
338   pcsc_set_timeout       = dlsym (handle, "SCardSetTimeout");
339
340   if (!pcsc_establish_context
341       || !pcsc_release_context  
342       || !pcsc_list_readers     
343       || !pcsc_get_status_change
344       || !pcsc_connect          
345       || !pcsc_reconnect          
346       || !pcsc_disconnect
347       || !pcsc_status
348       || !pcsc_begin_transaction
349       || !pcsc_end_transaction
350       || !pcsc_transmit         
351       /* || !pcsc_set_timeout */)
352     {
353       /* Note that set_timeout is currently not used and also not
354          available under Windows. */
355       fprintf (stderr,
356                "apdu_open_reader: invalid PC/SC driver "
357                "(%d%d%d%d%d%d%d%d%d%d%d%d)\n",
358                !!pcsc_establish_context,
359                !!pcsc_release_context,  
360                !!pcsc_list_readers,     
361                !!pcsc_get_status_change,     
362                !!pcsc_connect,          
363                !!pcsc_reconnect,          
364                !!pcsc_disconnect,
365                !!pcsc_status,
366                !!pcsc_begin_transaction,
367                !!pcsc_end_transaction,
368                !!pcsc_transmit,         
369                !!pcsc_set_timeout );
370       dlclose (handle);
371       exit (1);
372     }
373 }
374   
375
376
377
378 /* Handle a open request.  The argument is expected to be a string
379    with the port identification.  ARGBUF is always guaranteed to be
380    terminted by a 0 which is not counted in ARGLEN.  We may modifiy
381    ARGBUF. */
382 static void
383 handle_open (unsigned char *argbuf, size_t arglen)
384 {
385   long err;
386   const char * portstr;
387   char *list = NULL;
388   unsigned long nreader, listlen, atrlen;
389   char *p;
390   unsigned long card_state, card_protocol;
391   unsigned char atr[33];
392
393   /* Make sure there is only the port string */
394   if (arglen != strlen ((char*)argbuf))
395     bad_request ("OPEN");
396   portstr = (char*)argbuf;
397
398   if (driver_is_open)
399     {
400       fprintf (stderr, PGM ": PC/SC has already been opened\n");
401       request_failed (-1);
402       return;
403     }
404
405   err = pcsc_establish_context (PCSC_SCOPE_SYSTEM, NULL, NULL, &pcsc_context);
406   if (err)
407     {
408       fprintf (stderr, PGM": pcsc_establish_context failed: %s (0x%lx)\n",
409                pcsc_error_string (err), err);
410       request_failed (err);
411       return;
412     }
413   
414   err = pcsc_list_readers (pcsc_context, NULL, NULL, &nreader);
415   if (!err)
416     {
417       list = malloc (nreader+1); /* Better add 1 for safety reasons. */
418       if (!list)
419         {
420           fprintf (stderr, PGM": error allocating memory for reader list\n");
421           exit (1);
422         }
423       err = pcsc_list_readers (pcsc_context, NULL, list, &nreader);
424     }
425   if (err)
426     {
427       fprintf (stderr, PGM": pcsc_list_readers failed: %s (0x%lx)\n",
428                pcsc_error_string (err), err);
429       pcsc_release_context (pcsc_context);
430       free (list);
431       request_failed (err);
432       return;
433     }
434
435   listlen = nreader;
436   p = list;
437   while (nreader)
438     {
439       if (!*p && !p[1])
440         break;
441       fprintf (stderr, PGM": detected reader `%s'\n", p);
442       if (nreader < (strlen (p)+1))
443         {
444           fprintf (stderr, PGM": invalid response from pcsc_list_readers\n");
445           break;
446         }
447       nreader -= strlen (p)+1;
448       p += strlen (p) + 1;
449     }
450
451   current_rdrname = malloc (strlen (portstr && *portstr? portstr:list)+1);
452   if (!current_rdrname)
453     {
454       fprintf (stderr, PGM": error allocating memory for reader name\n");
455       exit (1);
456     }
457   strcpy (current_rdrname, portstr && *portstr? portstr:list);
458   free (list);
459
460   err = pcsc_connect (pcsc_context,
461                       current_rdrname,
462                       PCSC_SHARE_EXCLUSIVE,
463                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
464                       &pcsc_card,
465                       &pcsc_protocol);
466   if (err == 0x8010000c) /* No smartcard.  */
467     {
468       pcsc_card = 0;
469     }
470   else if (err)
471     {
472       fprintf (stderr, PGM": pcsc_connect failed: %s (0x%lx)\n",
473                pcsc_error_string (err), err);
474       pcsc_release_context (pcsc_context);
475       free (current_rdrname);
476       current_rdrname = NULL;
477       pcsc_card = 0;
478       pcsc_protocol = 0;
479       request_failed (err);
480       return;
481     }      
482   
483   current_atrlen = 0;
484   if (!err)
485     {
486       char reader[250];
487       unsigned long readerlen;
488
489       atrlen = 33;
490       readerlen = sizeof reader -1;
491       err = pcsc_status (pcsc_card,
492                          reader, &readerlen,
493                          &card_state, &card_protocol,
494                          atr, &atrlen);
495       if (err)
496         fprintf (stderr, PGM": pcsc_status failed: %s (0x%lx)\n",
497                  pcsc_error_string (err), err);
498       else
499         {
500           if (atrlen >= sizeof atr || atrlen >= sizeof current_atr)
501             {
502               fprintf (stderr, PGM": ATR returned by pcsc_status"
503                        " is too large\n");
504               exit (4);
505             }
506           memcpy (current_atr, atr, atrlen);
507           current_atrlen = atrlen;
508         }
509     }
510
511   driver_is_open = 1;
512   request_succeeded (current_atr, current_atrlen);
513 }
514
515
516
517 /* Handle a close request.  We expect no arguments.  We may modifiy
518    ARGBUF. */
519 static void
520 handle_close (unsigned char *argbuf, size_t arglen)
521 {
522   if (!driver_is_open)
523     {
524       fprintf (stderr, PGM ": PC/SC has not yet been opened\n");
525       request_failed (-1);
526       return;
527     }
528
529   free (current_rdrname);
530   current_rdrname = NULL;
531   pcsc_release_context (pcsc_context);
532   pcsc_card = 0;
533   pcsc_protocol = 0;
534
535   request_succeeded (NULL, 0);
536 }
537
538
539
540 /* Handle a status request.  We expect no arguments.  We may modifiy
541    ARGBUF. */
542 static void
543 handle_status (unsigned char *argbuf, size_t arglen)
544 {
545   long err;
546   struct pcsc_readerstate_s rdrstates[1];
547   int status;
548   unsigned char buf[20];
549
550   if (!driver_is_open)
551     {
552       fprintf (stderr, PGM ": PC/SC has not yet been opened\n");
553       request_failed (-1);
554       return;
555     }
556
557   memset (rdrstates, 0, sizeof *rdrstates);
558   rdrstates[0].reader = current_rdrname;
559   rdrstates[0].current_state = PCSC_STATE_UNAWARE;
560   err = pcsc_get_status_change (pcsc_context,
561                                 0,
562                                 rdrstates, 1);
563   if (err == 0x8010000a) /* Timeout.  */
564     err = 0;
565   if (err)
566     {
567       fprintf (stderr, PGM": pcsc_get_status_change failed: %s (0x%lx)\n",
568                pcsc_error_string (err), err);
569       request_failed (err);
570       return;
571     }
572
573   status = 0;
574   if ( !(rdrstates[0].event_state & PCSC_STATE_UNKNOWN) )
575     {
576       if ( (rdrstates[0].event_state & PCSC_STATE_PRESENT) )
577         status |= 2;
578       if ( !(rdrstates[0].event_state & PCSC_STATE_MUTE) )
579         status |= 4;
580       /* We indicate a useful card if it is not in use by another
581          application.  This is because we only use exclusive access
582          mode.  */
583       if ( (status & 6) == 6
584            && !(rdrstates[0].event_state & PCSC_STATE_INUSE) )
585         status |= 1;
586     }
587
588   /* First word is identical to the one used by apdu.c. */
589   buf[0] = 0;
590   buf[1] = 0;
591   buf[2] = 0;
592   buf[3] = status;
593   /* The second word is the native PCSC state.  */
594   buf[4] = (rdrstates[0].event_state >> 24);
595   buf[5] = (rdrstates[0].event_state >> 16);
596   buf[6] = (rdrstates[0].event_state >>  8);
597   buf[7] = (rdrstates[0].event_state >>  0);
598   /* The third word is the protocol. */
599   buf[8]  = (pcsc_protocol >> 24);
600   buf[9]  = (pcsc_protocol >> 16);
601   buf[10] = (pcsc_protocol >> 8);
602   buf[11] = (pcsc_protocol);
603
604   request_succeeded (buf, 8);
605 }
606
607
608 /* Handle a reset request.  We expect no arguments.  We may modifiy
609    ARGBUF. */
610 static void
611 handle_reset (unsigned char *argbuf, size_t arglen)
612 {
613   long err;
614   char reader[250];
615   unsigned long nreader, atrlen;
616   unsigned long card_state, card_protocol;
617
618   if (!driver_is_open)
619     {
620       fprintf (stderr, PGM ": PC/SC has not yet been opened\n");
621       request_failed (-1);
622       return;
623     }
624
625   if (pcsc_card)
626     {
627       err = pcsc_disconnect (pcsc_card, PCSC_LEAVE_CARD);
628       if (err == 0x80100003)  /* Invalid handle.  (already disconnected) */
629         err = 0;
630       if (err)
631         {
632           fprintf (stderr, PGM": pcsc_disconnect failed: %s (0x%lx)\n",
633                      pcsc_error_string (err), err);
634           request_failed (err);
635           return;
636         }
637       pcsc_card = 0;
638     }
639
640   err = pcsc_connect (pcsc_context,
641                       current_rdrname,
642                       PCSC_SHARE_EXCLUSIVE,
643                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
644                       &pcsc_card,
645                       &pcsc_protocol);
646   if (err)
647     {
648       fprintf (stderr, PGM": pcsc_connect failed: %s (0x%lx)\n",
649                pcsc_error_string (err), err);
650       pcsc_card = 0;
651       request_failed (err);
652       return;
653     }      
654
655   
656   atrlen = 33;
657   nreader = sizeof reader - 1;
658   err = pcsc_status (pcsc_card,
659                      reader, &nreader,
660                      &card_state, &card_protocol,
661                      current_atr, &atrlen);
662   if (err)
663     {
664       fprintf (stderr, PGM": pcsc_status failed: %s (0x%lx)\n",
665                pcsc_error_string (err), err);
666       current_atrlen = 0;
667       request_failed (err);
668       return;
669     }
670
671   request_succeeded (current_atr, current_atrlen);
672 }
673
674
675
676 /* Handle a transmit request.  The argument is expected to be a buffer
677    with the APDU.  We may modifiy ARGBUF. */
678 static void
679 handle_transmit (unsigned char *argbuf, size_t arglen)
680 {
681   long err;
682   struct pcsc_io_request_s send_pci;
683   unsigned long recv_len;
684   unsigned char buffer[1024];
685
686   /* The apdu should at least be one byte. */
687   if (!arglen)
688     bad_request ("TRANSMIT");
689
690   if (!driver_is_open)
691     {
692       fprintf (stderr, PGM ": PC/SC has not yet been opened\n");
693       request_failed (-1);
694       return;
695     }
696   if ((pcsc_protocol & PCSC_PROTOCOL_T1))
697     send_pci.protocol = PCSC_PROTOCOL_T1;
698   else
699     send_pci.protocol = PCSC_PROTOCOL_T0;
700   send_pci.pci_len = sizeof send_pci;
701   recv_len = sizeof (buffer);
702   err = pcsc_transmit (pcsc_card, &send_pci, argbuf, arglen,
703                        NULL, buffer, &recv_len);
704   if (err)
705     {
706       if (verbose)
707         fprintf (stderr, PGM": pcsc_transmit failed: %s (0x%lx)\n",
708                  pcsc_error_string (err), err);
709       request_failed (err);
710       return;
711     }
712   request_succeeded (buffer, recv_len);
713 }
714
715
716
717 static void
718 print_version (int with_help)
719 {
720   fputs (MYVERSION_LINE "\n"
721          "Copyright (C) 2004 Free Software Foundation, Inc.\n"
722          "This program comes with ABSOLUTELY NO WARRANTY.\n"
723          "This is free software, and you are welcome to redistribute it\n"
724          "under certain conditions. See the file COPYING for details.\n",
725          stdout);
726         
727   if (with_help)
728     fputs ("\n"
729           "Usage: " PGM " [OPTIONS] API-NUMBER [LIBNAME]\n"
730           "Helper to connect scdaemon to the PC/SC library\n"
731           "\n"
732           "  --verbose   enable extra informational output\n"
733           "  --version   print version of the program and exit\n"
734           "  --help      display this help and exit\n"
735           BUGREPORT_LINE, stdout );
736   
737   exit (0);
738 }
739
740
741 int
742 main (int argc, char **argv)
743 {
744   int last_argc = -1;
745   int api_number = 0;
746   int c;
747  
748   if (argc)
749     {
750       argc--; argv++;
751     }
752   while (argc && last_argc != argc )
753     {
754       last_argc = argc;
755       if (!strcmp (*argv, "--"))
756         {
757           argc--; argv++;
758           break;
759         }
760       else if (!strcmp (*argv, "--version"))
761         print_version (0);
762       else if (!strcmp (*argv, "--help"))
763         print_version (1);
764       else if (!strcmp (*argv, "--verbose"))
765         {
766           verbose = 1;
767           argc--; argv++;
768         }
769     }          
770   if (argc != 1 && argc != 2)
771     {
772       fprintf (stderr, "usage: " PGM " API-NUMBER [LIBNAME]\n");
773       exit (1);
774     }
775
776   api_number = atoi (*argv);
777   argv++; argc--;
778   if (api_number != 1)
779     {
780       fprintf (stderr, PGM ": api-number %d is not valid\n", api_number);
781       exit (1);
782     }
783
784   load_pcsc_driver (argc? *argv : DEFAULT_PCSC_DRIVER);
785
786   while ((c = getc (stdin)) != EOF)
787     {
788       size_t arglen;
789       unsigned char argbuffer[2048];
790       
791       arglen = read_32 (stdin);
792       if (arglen >= sizeof argbuffer - 1)
793         {
794           fprintf (stderr, PGM ": request too long\n");
795           exit (1);
796         }
797       if (arglen && fread (argbuffer, arglen, 1, stdin) != 1)
798         {
799           fprintf (stderr, PGM ": error reading request: %s\n",
800                    strerror (errno));
801           exit (1);
802         }
803       argbuffer[arglen] = 0;
804       switch (c)
805         {
806         case 1:
807           handle_open (argbuffer, arglen);
808           break;
809
810         case 2:
811           handle_close (argbuffer, arglen);
812           exit (0);
813           break;
814
815         case 3:
816           handle_transmit (argbuffer, arglen);
817           break;
818
819         case 4:
820           handle_status (argbuffer, arglen);
821           break;
822
823         case 5:
824           handle_reset (argbuffer, arglen);
825           break;
826
827         default:
828           fprintf (stderr, PGM ": invalid request 0x%02X\n", c);
829           exit (1);
830         }
831     }
832   return 0;
833 }
834
835
836
837 /*
838 Local Variables:
839 compile-command: "gcc -Wall -g -o pcsc-wrapper pcsc-wrapper.c -ldl"
840 End:
841 */