Bug fixes and ssh support for the BELPIC.
[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       request_failed (err);
478       return;
479     }      
480   
481   current_atrlen = 0;
482   if (!err)
483     {
484       char reader[250];
485       unsigned long readerlen;
486
487       atrlen = 33;
488       readerlen = sizeof reader -1;
489       err = pcsc_status (pcsc_card,
490                          reader, &readerlen,
491                          &card_state, &card_protocol,
492                          atr, &atrlen);
493       if (err)
494         fprintf (stderr, PGM": pcsc_status failed: %s (0x%lx)\n",
495                  pcsc_error_string (err), err);
496       else
497         {
498           if (atrlen >= sizeof atr || atrlen >= sizeof current_atr)
499             {
500               fprintf (stderr, PGM": ATR returned by pcsc_status"
501                        " is too large\n");
502               exit (4);
503             }
504           memcpy (current_atr, atr, atrlen);
505           current_atrlen = atrlen;
506         }
507     }
508
509   driver_is_open = 1;
510   request_succeeded (current_atr, current_atrlen);
511 }
512
513
514
515 /* Handle a close request.  We expect no arguments.  We may modifiy
516    ARGBUF. */
517 static void
518 handle_close (unsigned char *argbuf, size_t arglen)
519 {
520   if (!driver_is_open)
521     {
522       fprintf (stderr, PGM ": PC/SC has not yet been opened\n");
523       request_failed (-1);
524       return;
525     }
526
527   free (current_rdrname);
528   current_rdrname = NULL;
529   pcsc_release_context (pcsc_context);
530
531   request_succeeded (NULL, 0);
532 }
533
534
535
536 /* Handle a status request.  We expect no arguments.  We may modifiy
537    ARGBUF. */
538 static void
539 handle_status (unsigned char *argbuf, size_t arglen)
540 {
541   long err;
542   struct pcsc_readerstate_s rdrstates[1];
543   int status;
544   unsigned char buf[20];
545
546   if (!driver_is_open)
547     {
548       fprintf (stderr, PGM ": PC/SC has not yet been opened\n");
549       request_failed (-1);
550       return;
551     }
552
553   memset (rdrstates, 0, sizeof *rdrstates);
554   rdrstates[0].reader = current_rdrname;
555   rdrstates[0].current_state = PCSC_STATE_UNAWARE;
556   err = pcsc_get_status_change (pcsc_context,
557                                 0,
558                                 rdrstates, 1);
559   if (err == 0x8010000a) /* Timeout.  */
560     err = 0;
561   if (err)
562     {
563       fprintf (stderr, PGM": pcsc_get_status_change failed: %s (0x%lx)\n",
564                pcsc_error_string (err), err);
565       request_failed (err);
566       return;
567     }
568
569   status = 0;
570   if ( (rdrstates[0].event_state & PCSC_STATE_PRESENT) )
571     status |= 2;
572   if ( !(rdrstates[0].event_state & PCSC_STATE_MUTE) )
573     status |= 4;
574   /* We indicate a useful card if it is not in use by another
575      application.  This is because we only use exclusive access
576      mode.  */
577   if ( (status & 6) == 6
578        && !(rdrstates[0].event_state & PCSC_STATE_INUSE) )
579     status |= 1;
580   
581   /* First word is identical to the one used by apdu.c. */
582   buf[0] = 0;
583   buf[1] = 0;
584   buf[2] = 0;
585   buf[3] = status;
586   /* The second word is the native PCSC state.  */
587   buf[4] = (rdrstates[0].event_state >> 24);
588   buf[5] = (rdrstates[0].event_state >> 16);
589   buf[6] = (rdrstates[0].event_state >>  8);
590   buf[7] = (rdrstates[0].event_state >>  0);
591   /* The third word is the protocol. */
592   buf[8]  = (pcsc_protocol >> 24);
593   buf[9]  = (pcsc_protocol >> 16);
594   buf[10] = (pcsc_protocol >> 8);
595   buf[11] = (pcsc_protocol);
596
597   request_succeeded (buf, 8);
598 }
599
600
601 /* Handle a reset request.  We expect no arguments.  We may modifiy
602    ARGBUF. */
603 static void
604 handle_reset (unsigned char *argbuf, size_t arglen)
605 {
606   long err;
607   char reader[250];
608   unsigned long nreader, atrlen;
609   unsigned long card_state, card_protocol;
610
611   if (!driver_is_open)
612     {
613       fprintf (stderr, PGM ": PC/SC has not yet been opened\n");
614       request_failed (-1);
615       return;
616     }
617
618   if (pcsc_card)
619     {
620       err = pcsc_disconnect (pcsc_card, PCSC_LEAVE_CARD);
621       if (err)
622         {
623           fprintf (stderr, PGM": pcsc_disconnect failed: %s (0x%lx)\n",
624                      pcsc_error_string (err), err);
625           request_failed (err);
626           return;
627         }
628       pcsc_card = 0;
629     }
630
631   err = pcsc_connect (pcsc_context,
632                       current_rdrname,
633                       PCSC_SHARE_EXCLUSIVE,
634                       PCSC_PROTOCOL_T0|PCSC_PROTOCOL_T1,
635                       &pcsc_card,
636                       &pcsc_protocol);
637   if (err)
638     {
639       fprintf (stderr, PGM": pcsc_connect failed: %s (0x%lx)\n",
640                pcsc_error_string (err), err);
641       pcsc_card = 0;
642       request_failed (err);
643       return;
644     }      
645
646   
647   atrlen = 33;
648   nreader = sizeof reader - 1;
649   err = pcsc_status (pcsc_card,
650                      reader, &nreader,
651                      &card_state, &card_protocol,
652                      current_atr, &atrlen);
653   if (err)
654     {
655       fprintf (stderr, PGM": pcsc_status failed: %s (0x%lx)\n",
656                pcsc_error_string (err), err);
657       current_atrlen = 0;
658       request_failed (err);
659       return;
660     }
661
662   request_succeeded (current_atr, current_atrlen);
663 }
664
665
666
667 /* Handle a transmit request.  The argument is expected to be a buffer
668    with the APDU.  We may modifiy ARGBUF. */
669 static void
670 handle_transmit (unsigned char *argbuf, size_t arglen)
671 {
672   long err;
673   struct pcsc_io_request_s send_pci;
674   unsigned long recv_len;
675   unsigned char buffer[1024];
676
677   /* The apdu should at least be one byte. */
678   if (!arglen)
679     bad_request ("TRANSMIT");
680
681   if (!driver_is_open)
682     {
683       fprintf (stderr, PGM ": PC/SC has not yet been opened\n");
684       request_failed (-1);
685       return;
686     }
687   if ((pcsc_protocol & PCSC_PROTOCOL_T1))
688     send_pci.protocol = PCSC_PROTOCOL_T1;
689   else
690     send_pci.protocol = PCSC_PROTOCOL_T0;
691   send_pci.pci_len = sizeof send_pci;
692   recv_len = sizeof (buffer);
693   err = pcsc_transmit (pcsc_card, &send_pci, argbuf, arglen,
694                        NULL, buffer, &recv_len);
695   if (err)
696     {
697       if (verbose)
698         fprintf (stderr, PGM": pcsc_transmit failed: %s (0x%lx)\n",
699                  pcsc_error_string (err), err);
700       request_failed (err);
701       return;
702     }
703   request_succeeded (buffer, recv_len);
704 }
705
706
707
708 static void
709 print_version (int with_help)
710 {
711   fputs (MYVERSION_LINE "\n"
712          "Copyright (C) 2004 Free Software Foundation, Inc.\n"
713          "This program comes with ABSOLUTELY NO WARRANTY.\n"
714          "This is free software, and you are welcome to redistribute it\n"
715          "under certain conditions. See the file COPYING for details.\n",
716          stdout);
717         
718   if (with_help)
719     fputs ("\n"
720           "Usage: " PGM " [OPTIONS] API-NUMBER [LIBNAME]\n"
721           "Helper to connect scdaemon to the PC/SC library\n"
722           "\n"
723           "  --verbose   enable extra informational output\n"
724           "  --version   print version of the program and exit\n"
725           "  --help      display this help and exit\n"
726           BUGREPORT_LINE, stdout );
727   
728   exit (0);
729 }
730
731
732 int
733 main (int argc, char **argv)
734 {
735   int last_argc = -1;
736   int api_number = 0;
737   int c;
738  
739   if (argc)
740     {
741       argc--; argv++;
742     }
743   while (argc && last_argc != argc )
744     {
745       last_argc = argc;
746       if (!strcmp (*argv, "--"))
747         {
748           argc--; argv++;
749           break;
750         }
751       else if (!strcmp (*argv, "--version"))
752         print_version (0);
753       else if (!strcmp (*argv, "--help"))
754         print_version (1);
755       else if (!strcmp (*argv, "--verbose"))
756         {
757           verbose = 1;
758           argc--; argv++;
759         }
760     }          
761   if (argc != 1 && argc != 2)
762     {
763       fprintf (stderr, "usage: " PGM " API-NUMBER [LIBNAME]\n");
764       exit (1);
765     }
766
767   api_number = atoi (*argv);
768   argv++; argc--;
769   if (api_number != 1)
770     {
771       fprintf (stderr, PGM ": api-number %d is not valid\n", api_number);
772       exit (1);
773     }
774
775   load_pcsc_driver (argc? *argv : DEFAULT_PCSC_DRIVER);
776
777   while ((c = getc (stdin)) != EOF)
778     {
779       size_t arglen;
780       unsigned char argbuffer[2048];
781       
782       arglen = read_32 (stdin);
783       if (arglen >= sizeof argbuffer - 1)
784         {
785           fprintf (stderr, PGM ": request too long\n");
786           exit (1);
787         }
788       if (arglen && fread (argbuffer, arglen, 1, stdin) != 1)
789         {
790           fprintf (stderr, PGM ": error reading request: %s\n",
791                    strerror (errno));
792           exit (1);
793         }
794       argbuffer[arglen] = 0;
795       switch (c)
796         {
797         case 1:
798           handle_open (argbuffer, arglen);
799           break;
800
801         case 2:
802           handle_close (argbuffer, arglen);
803           exit (0);
804           break;
805
806         case 3:
807           handle_transmit (argbuffer, arglen);
808           break;
809
810         case 4:
811           handle_status (argbuffer, arglen);
812           break;
813
814         case 5:
815           handle_reset (argbuffer, arglen);
816           break;
817
818         default:
819           fprintf (stderr, PGM ": invalid request 0x%02X\n", c);
820           exit (1);
821         }
822     }
823   return 0;
824 }
825
826
827
828 /*
829 Local Variables:
830 compile-command: "gcc -Wall -g -o pcsc-wrapper pcsc-wrapper.c -ldl"
831 End:
832 */