Merge branch 'STABLE-BRANCH-2-2'
[gnupg.git] / tools / ccidmon.c
1 /* ccidmon.c - CCID monitor for use with the Linux usbmon facility.
2  *      Copyright (C) 2009 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 3 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, see <https://www.gnu.org/licenses/>.
18  */
19
20
21 /* This utility takes the output of usbmon, filters out the bulk data
22    and prints the CCID messages in a human friendly way.
23
24 */
25
26 #ifdef HAVE_CONFIG_H
27 #include <config.h>
28 #endif
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <stddef.h>
33 #include <string.h>
34 #include <errno.h>
35 #include <stdarg.h>
36 #include <assert.h>
37 #include <unistd.h>
38 #include <signal.h>
39
40
41 #ifndef PACKAGE_VERSION
42 # define PACKAGE_VERSION "[build on " __DATE__ " " __TIME__ "]"
43 #endif
44 #ifndef PACKAGE_BUGREPORT
45 # define PACKAGE_BUGREPORT "devnull@example.org"
46 #endif
47 #define PGM "ccidmon"
48 #ifndef GNUPG_NAME
49 # define GNUPG_NAME "GnuPG"
50 #endif
51
52 /* Option flags. */
53 static int verbose;
54 static int debug;
55 static int skip_escape;
56 static int usb_bus, usb_dev;
57 static int sniffusb;
58
59
60 /* Error counter.  */
61 static int any_error;
62
63 /* Data storage.  */
64 struct
65 {
66   int is_bi;
67   char address[50];
68   int count;
69   char data[2000];
70 } databuffer;
71
72
73 enum {
74   RDR_to_PC_NotifySlotChange= 0x50,
75   RDR_to_PC_HardwareError   = 0x51,
76
77   PC_to_RDR_SetParameters   = 0x61,
78   PC_to_RDR_IccPowerOn      = 0x62,
79   PC_to_RDR_IccPowerOff     = 0x63,
80   PC_to_RDR_GetSlotStatus   = 0x65,
81   PC_to_RDR_Secure          = 0x69,
82   PC_to_RDR_T0APDU          = 0x6a,
83   PC_to_RDR_Escape          = 0x6b,
84   PC_to_RDR_GetParameters   = 0x6c,
85   PC_to_RDR_ResetParameters = 0x6d,
86   PC_to_RDR_IccClock        = 0x6e,
87   PC_to_RDR_XfrBlock        = 0x6f,
88   PC_to_RDR_Mechanical      = 0x71,
89   PC_to_RDR_Abort           = 0x72,
90   PC_to_RDR_SetDataRate     = 0x73,
91
92   RDR_to_PC_DataBlock       = 0x80,
93   RDR_to_PC_SlotStatus      = 0x81,
94   RDR_to_PC_Parameters      = 0x82,
95   RDR_to_PC_Escape          = 0x83,
96   RDR_to_PC_DataRate        = 0x84
97 };
98
99
100 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
101 #define hexdigitp(a) (digitp (a)                     \
102                       || (*(a) >= 'A' && *(a) <= 'F')  \
103                       || (*(a) >= 'a' && *(a) <= 'f'))
104 #define ascii_isspace(a) ((a)==' ' || (a)=='\n' || (a)=='\r' || (a)=='\t')
105 #define xtoi_1(p)   ((p) <= '9'? ((p)- '0'): \
106                      (p) <= 'F'? ((p)-'A'+10):((p)-'a'+10))
107
108
109
110 /* Print diagnostic message and exit with failure. */
111 static void
112 die (const char *format, ...)
113 {
114   va_list arg_ptr;
115
116   fflush (stdout);
117   fprintf (stderr, "%s: ", PGM);
118
119   va_start (arg_ptr, format);
120   vfprintf (stderr, format, arg_ptr);
121   va_end (arg_ptr);
122   putc ('\n', stderr);
123
124   exit (1);
125 }
126
127
128 /* Print diagnostic message. */
129 static void
130 err (const char *format, ...)
131 {
132   va_list arg_ptr;
133
134   any_error = 1;
135
136   fflush (stdout);
137   fprintf (stderr, "%s: ", PGM);
138
139   va_start (arg_ptr, format);
140   vfprintf (stderr, format, arg_ptr);
141   va_end (arg_ptr);
142   putc ('\n', stderr);
143 }
144
145
146 /* Convert a little endian stored 4 byte value into an unsigned
147    integer. */
148 static unsigned int
149 convert_le_u32 (const unsigned char *buf)
150 {
151   return buf[0] | (buf[1] << 8) | (buf[2] << 16) | ((unsigned int)buf[3] << 24);
152 }
153
154
155 /* Convert a little endian stored 2 byte value into an unsigned
156    integer. */
157 static unsigned int
158 convert_le_u16 (const unsigned char *buf)
159 {
160   return buf[0] | (buf[1] << 8);
161 }
162
163
164
165
166 static void
167 print_pr_data (const unsigned char *data, size_t datalen, size_t off)
168 {
169   int needlf = 0;
170   int first = 1;
171
172   for (; off < datalen; off++)
173     {
174       if (!(off % 16) || first)
175         {
176           if (needlf)
177             putchar ('\n');
178           printf ("  [%04lu] ", (unsigned long)off);
179         }
180       printf (" %02X", data[off]);
181       needlf = 1;
182       first = 0;
183     }
184   if (needlf)
185     putchar ('\n');
186 }
187
188
189 static void
190 print_p2r_header (const char *name, const unsigned char *msg, size_t msglen)
191 {
192   printf ("%s:\n", name);
193   if (msglen < 7)
194     return;
195   printf ("  dwLength ..........: %u\n", convert_le_u32 (msg+1));
196   printf ("  bSlot .............: %u\n", msg[5]);
197   printf ("  bSeq ..............: %u\n", msg[6]);
198 }
199
200
201 static void
202 print_p2r_iccpoweron (const unsigned char *msg, size_t msglen)
203 {
204   print_p2r_header ("PC_to_RDR_IccPowerOn", msg, msglen);
205   if (msglen < 10)
206     return;
207   printf ("  bPowerSelect ......: 0x%02x (%s)\n", msg[7],
208           msg[7] == 0? "auto":
209           msg[7] == 1? "5.0 V":
210           msg[7] == 2? "3.0 V":
211           msg[7] == 3? "1.8 V":"");
212   print_pr_data (msg, msglen, 8);
213 }
214
215
216 static void
217 print_p2r_iccpoweroff (const unsigned char *msg, size_t msglen)
218 {
219   print_p2r_header ("PC_to_RDR_IccPowerOff", msg, msglen);
220   print_pr_data (msg, msglen, 7);
221 }
222
223
224 static void
225 print_p2r_getslotstatus (const unsigned char *msg, size_t msglen)
226 {
227   print_p2r_header ("PC_to_RDR_GetSlotStatus", msg, msglen);
228   print_pr_data (msg, msglen, 7);
229 }
230
231
232 static void
233 print_p2r_xfrblock (const unsigned char *msg, size_t msglen)
234 {
235   unsigned int val;
236
237   print_p2r_header ("PC_to_RDR_XfrBlock", msg, msglen);
238   if (msglen < 10)
239     return;
240   printf ("  bBWI ..............: 0x%02x\n", msg[7]);
241   val = convert_le_u16 (msg+8);
242   printf ("  wLevelParameter ...: 0x%04x%s\n", val,
243           val == 1? " (continued)":
244           val == 2? " (continues+ends)":
245           val == 3? " (continues+continued)":
246           val == 16? " (DataBlock-expected)":"");
247   print_pr_data (msg, msglen, 10);
248 }
249
250
251 static void
252 print_p2r_getparameters (const unsigned char *msg, size_t msglen)
253 {
254   print_p2r_header ("PC_to_RDR_GetParameters", msg, msglen);
255   print_pr_data (msg, msglen, 7);
256 }
257
258
259 static void
260 print_p2r_resetparameters (const unsigned char *msg, size_t msglen)
261 {
262   print_p2r_header ("PC_to_RDR_ResetParameters", msg, msglen);
263   print_pr_data (msg, msglen, 7);
264 }
265
266
267 static void
268 print_p2r_setparameters (const unsigned char *msg, size_t msglen)
269 {
270   print_p2r_header ("PC_to_RDR_SetParameters", msg, msglen);
271   if (msglen < 10)
272     return;
273   printf ("  bProtocolNum ......: 0x%02x\n", msg[7]);
274   print_pr_data (msg, msglen, 8);
275 }
276
277
278 static void
279 print_p2r_escape (const unsigned char *msg, size_t msglen)
280 {
281   if (skip_escape)
282     return;
283   print_p2r_header ("PC_to_RDR_Escape", msg, msglen);
284   print_pr_data (msg, msglen, 7);
285 }
286
287
288 static void
289 print_p2r_iccclock (const unsigned char *msg, size_t msglen)
290 {
291   print_p2r_header ("PC_to_RDR_IccClock", msg, msglen);
292   if (msglen < 10)
293     return;
294   printf ("  bClockCommand .....: 0x%02x\n", msg[7]);
295   print_pr_data (msg, msglen, 8);
296 }
297
298
299 static void
300 print_p2r_to0apdu (const unsigned char *msg, size_t msglen)
301 {
302   print_p2r_header ("PC_to_RDR_T0APDU", msg, msglen);
303   if (msglen < 10)
304     return;
305   printf ("  bmChanges .........: 0x%02x\n", msg[7]);
306   printf ("  bClassGetResponse .: 0x%02x\n", msg[8]);
307   printf ("  bClassEnvelope ....: 0x%02x\n", msg[9]);
308   print_pr_data (msg, msglen, 10);
309 }
310
311
312 static void
313 print_p2r_secure (const unsigned char *msg, size_t msglen)
314 {
315   unsigned int val;
316
317   print_p2r_header ("PC_to_RDR_Secure", msg, msglen);
318   if (msglen < 10)
319     return;
320   printf ("  bBMI ..............: 0x%02x\n", msg[7]);
321   val = convert_le_u16 (msg+8);
322   printf ("  wLevelParameter ...: 0x%04x%s\n", val,
323           val == 1? " (continued)":
324           val == 2? " (continues+ends)":
325           val == 3? " (continues+continued)":
326           val == 16? " (DataBlock-expected)":"");
327   print_pr_data (msg, msglen, 10);
328 }
329
330
331 static void
332 print_p2r_mechanical (const unsigned char *msg, size_t msglen)
333 {
334   print_p2r_header ("PC_to_RDR_Mechanical", msg, msglen);
335   if (msglen < 10)
336     return;
337   printf ("  bFunction .........: 0x%02x\n", msg[7]);
338   print_pr_data (msg, msglen, 8);
339 }
340
341
342 static void
343 print_p2r_abort (const unsigned char *msg, size_t msglen)
344 {
345   print_p2r_header ("PC_to_RDR_Abort", msg, msglen);
346   print_pr_data (msg, msglen, 7);
347 }
348
349
350 static void
351 print_p2r_setdatarate (const unsigned char *msg, size_t msglen)
352 {
353   print_p2r_header ("PC_to_RDR_SetDataRate", msg, msglen);
354   if (msglen < 10)
355     return;
356   print_pr_data (msg, msglen, 7);
357 }
358
359
360 static void
361 print_p2r_unknown (const unsigned char *msg, size_t msglen)
362 {
363   char buf[100];
364
365   snprintf (buf, sizeof buf, "Unknown PC_to_RDR command 0x%02X",
366             msglen? msg[0]:0);
367   print_p2r_header (buf, msg, msglen);
368   if (msglen < 10)
369     return;
370   print_pr_data (msg, msglen, 0);
371 }
372
373
374 static void
375 print_p2r (const unsigned char *msg, size_t msglen)
376 {
377   switch (msglen? msg[0]:0)
378     {
379     case PC_to_RDR_IccPowerOn:
380       print_p2r_iccpoweron (msg, msglen);
381       break;
382     case PC_to_RDR_IccPowerOff:
383       print_p2r_iccpoweroff (msg, msglen);
384       break;
385     case PC_to_RDR_GetSlotStatus:
386       print_p2r_getslotstatus (msg, msglen);
387       break;
388     case PC_to_RDR_XfrBlock:
389       print_p2r_xfrblock (msg, msglen);
390       break;
391     case PC_to_RDR_GetParameters:
392       print_p2r_getparameters (msg, msglen);
393       break;
394     case PC_to_RDR_ResetParameters:
395       print_p2r_resetparameters (msg, msglen);
396       break;
397     case PC_to_RDR_SetParameters:
398       print_p2r_setparameters (msg, msglen);
399       break;
400     case PC_to_RDR_Escape:
401       print_p2r_escape (msg, msglen);
402       break;
403     case PC_to_RDR_IccClock:
404       print_p2r_iccclock (msg, msglen);
405       break;
406     case PC_to_RDR_T0APDU:
407       print_p2r_to0apdu (msg, msglen);
408       break;
409     case PC_to_RDR_Secure:
410       print_p2r_secure (msg, msglen);
411       break;
412     case PC_to_RDR_Mechanical:
413       print_p2r_mechanical (msg, msglen);
414       break;
415     case PC_to_RDR_Abort:
416       print_p2r_abort (msg, msglen);
417       break;
418     case PC_to_RDR_SetDataRate:
419       print_p2r_setdatarate (msg, msglen);
420       break;
421     default:
422       print_p2r_unknown (msg, msglen);
423       break;
424     }
425 }
426
427
428 static void
429 print_r2p_header (const char *name, const unsigned char *msg, size_t msglen)
430 {
431   printf ("%s:\n", name);
432   if (msglen < 9)
433     return;
434   printf ("  dwLength ..........: %u\n", convert_le_u32 (msg+1));
435   printf ("  bSlot .............: %u\n", msg[5]);
436   printf ("  bSeq ..............: %u\n", msg[6]);
437   printf ("  bStatus ...........: %u\n", msg[7]);
438   if (msg[8])
439     printf ("  bError ............: %u\n", msg[8]);
440 }
441
442
443 static void
444 print_r2p_datablock (const unsigned char *msg, size_t msglen)
445 {
446   print_r2p_header ("RDR_to_PC_DataBlock", msg, msglen);
447   if (msglen < 10)
448     return;
449   if (msg[9])
450     printf ("  bChainParameter ...: 0x%02x%s\n", msg[9],
451             msg[9] == 1? " (continued)":
452             msg[9] == 2? " (continues+ends)":
453             msg[9] == 3? " (continues+continued)":
454             msg[9] == 16? " (XferBlock-expected)":"");
455   print_pr_data (msg, msglen, 10);
456 }
457
458
459 static void
460 print_r2p_slotstatus (const unsigned char *msg, size_t msglen)
461 {
462   print_r2p_header ("RDR_to_PC_SlotStatus", msg, msglen);
463   if (msglen < 10)
464     return;
465   printf ("  bClockStatus ......: 0x%02x%s\n", msg[9],
466           msg[9] == 0? " (running)":
467           msg[9] == 1? " (stopped-L)":
468           msg[9] == 2? " (stopped-H)":
469           msg[9] == 3? " (stopped)":"");
470   print_pr_data (msg, msglen, 10);
471 }
472
473
474 static void
475 print_r2p_parameters (const unsigned char *msg, size_t msglen)
476 {
477   print_r2p_header ("RDR_to_PC_Parameters", msg, msglen);
478   if (msglen < 10)
479     return;
480
481   printf ("  protocol ..........: T=%d\n", msg[9]);
482   if (msglen == 17 && msg[9] == 1)
483     {
484       /* Protocol T=1.  */
485       printf ("  bmFindexDindex ....: %02X\n", msg[10]);
486       printf ("  bmTCCKST1 .........: %02X\n", msg[11]);
487       printf ("  bGuardTimeT1 ......: %02X\n", msg[12]);
488       printf ("  bmWaitingIntegersT1: %02X\n", msg[13]);
489       printf ("  bClockStop ........: %02X\n", msg[14]);
490       printf ("  bIFSC .............: %d\n", msg[15]);
491       printf ("  bNadValue .........: %d\n", msg[16]);
492     }
493   else
494     print_pr_data (msg, msglen, 10);
495 }
496
497
498 static void
499 print_r2p_escape (const unsigned char *msg, size_t msglen)
500 {
501   if (skip_escape)
502     return;
503   print_r2p_header ("RDR_to_PC_Escape", msg, msglen);
504   if (msglen < 10)
505     return;
506   printf ("  buffer[9] .........: %02X\n", msg[9]);
507   print_pr_data (msg, msglen, 10);
508 }
509
510
511 static void
512 print_r2p_datarate (const unsigned char *msg, size_t msglen)
513 {
514   print_r2p_header ("RDR_to_PC_DataRate", msg, msglen);
515   if (msglen < 10)
516     return;
517   if (msglen >= 18)
518     {
519       printf ("  dwClockFrequency ..: %u\n", convert_le_u32 (msg+10));
520       printf ("  dwDataRate ..... ..: %u\n", convert_le_u32 (msg+14));
521       print_pr_data (msg, msglen, 18);
522     }
523   else
524     print_pr_data (msg, msglen, 10);
525 }
526
527
528 static void
529 print_r2p_unknown (const unsigned char *msg, size_t msglen)
530 {
531   char buf[100];
532
533   snprintf (buf, sizeof buf, "Unknown RDR_to_PC command 0x%02X",
534             msglen? msg[0]:0);
535   print_r2p_header (buf, msg, msglen);
536   if (msglen < 10)
537     return;
538   printf ("  bMessageType ......: %02X\n", msg[0]);
539   printf ("  buffer[9] .........: %02X\n", msg[9]);
540   print_pr_data (msg, msglen, 10);
541 }
542
543
544 static void
545 print_r2p (const unsigned char *msg, size_t msglen)
546 {
547   switch (msglen? msg[0]:0)
548     {
549     case RDR_to_PC_DataBlock:
550       print_r2p_datablock (msg, msglen);
551       break;
552     case RDR_to_PC_SlotStatus:
553       print_r2p_slotstatus (msg, msglen);
554       break;
555     case RDR_to_PC_Parameters:
556       print_r2p_parameters (msg, msglen);
557       break;
558     case RDR_to_PC_Escape:
559       print_r2p_escape (msg, msglen);
560       break;
561     case RDR_to_PC_DataRate:
562       print_r2p_datarate (msg, msglen);
563       break;
564     default:
565       print_r2p_unknown (msg, msglen);
566       break;
567     }
568
569 }
570
571
572 static void
573 flush_data (void)
574 {
575   if (!databuffer.count)
576     return;
577
578   if (verbose)
579     printf ("Address: %s\n", databuffer.address);
580   if (databuffer.is_bi)
581     {
582       print_r2p (databuffer.data, databuffer.count);
583       if (verbose)
584         putchar ('\n');
585     }
586   else
587     print_p2r (databuffer.data, databuffer.count);
588
589   databuffer.count = 0;
590 }
591
592 static void
593 collect_data (char *hexdata, const char *address, unsigned int lineno)
594 {
595   size_t length;
596   int is_bi;
597   char *s;
598   unsigned int value;
599
600   is_bi = (*address && address[1] == 'i');
601
602   if (databuffer.is_bi != is_bi || strcmp (databuffer.address, address))
603     flush_data ();
604   databuffer.is_bi = is_bi;
605   if (strlen (address) >= sizeof databuffer.address)
606     die ("address field too long");
607   strcpy (databuffer.address, address);
608
609   length = databuffer.count;
610   for (s=hexdata; *s; s++ )
611     {
612       if (ascii_isspace (*s))
613         continue;
614       if (!hexdigitp (s))
615         {
616           err ("invalid hex digit in line %u - line skipped", lineno);
617           break;
618         }
619       value = xtoi_1 (*s) * 16;
620       s++;
621       if (!hexdigitp (s))
622         {
623           err ("invalid hex digit in line %u - line skipped", lineno);
624           break;
625         }
626       value += xtoi_1 (*s);
627
628       if (length >= sizeof (databuffer.data))
629         {
630           err ("too much data at line %u - can handle only up to % bytes",
631                lineno, sizeof (databuffer.data));
632           break;
633         }
634       databuffer.data[length++] = value;
635     }
636   databuffer.count = length;
637 }
638
639
640 static void
641 parse_line (char *line, unsigned int lineno)
642 {
643   char *p;
644   char *event_type, *address, *data, *status, *datatag;
645
646   if (debug)
647     printf ("line[%u] ='%s'\n", lineno, line);
648
649   p = strtok (line, " ");
650   if (!p)
651     die ("invalid line %d (no URB)");
652   p = strtok (NULL, " ");
653   if (!p)
654     die ("invalid line %d (no timestamp)");
655   event_type = strtok (NULL, " ");
656   if (!event_type)
657     die ("invalid line %d (no event type)");
658   address = strtok (NULL, " ");
659   if (!address)
660     die ("invalid line %d (no address");
661   if (usb_bus || usb_dev)
662     {
663       int bus, dev;
664
665       p = strchr (address, ':');
666       if (!p)
667         die ("invalid line %d (invalid address");
668       p++;
669       bus = atoi (p);
670       p = strchr (p, ':');
671       if (!p)
672         die ("invalid line %d (invalid address");
673       p++;
674       dev = atoi (p);
675
676       if ((usb_bus && usb_bus != bus) || (usb_dev && usb_dev != dev))
677         return;  /* We don't want that one.  */
678     }
679   if (*address != 'B' || (address[1] != 'o' && address[1] != 'i'))
680     return; /* We only want block in and block out.  */
681   status = strtok (NULL, " ");
682   if (!status)
683     return;
684   if (!strchr ("-0123456789", *status))
685     return; /* Setup packet.  */
686   /* We don't support "Z[io]" types thus we don't need to check here.  */
687   p = strtok (NULL, " ");
688   if (!p)
689     return; /* No data length.  */
690
691   datatag = strtok (NULL, " ");
692   if (datatag && *datatag == '=')
693     {
694       data = strtok (NULL, "");
695       collect_data (data?data:"", address, lineno);
696     }
697 }
698
699
700 static void
701 parse_line_sniffusb (char *line, unsigned int lineno)
702 {
703   char *p;
704
705   if (debug)
706     printf ("line[%u] ='%s'\n", lineno, line);
707
708   p = strtok (line, " \t");
709   if (!p)
710     return;
711   p = strtok (NULL, " \t");
712   if (!p)
713     return;
714   p = strtok (NULL, " \t");
715   if (!p)
716     return;
717
718   if (hexdigitp (p+0) && hexdigitp (p+1)
719       && hexdigitp (p+2) && hexdigitp (p+3)
720       && p[4] == ':' && !p[5])
721     {
722       size_t length;
723       unsigned int value;
724
725       length = databuffer.count;
726       while ((p=strtok (NULL, " \t")))
727         {
728           if (!hexdigitp (p+0) || !hexdigitp (p+1))
729             {
730               err ("invalid hex digit in line %u (%s)", lineno,p);
731               break;
732             }
733           value = xtoi_1 (p[0]) * 16 + xtoi_1 (p[1]);
734
735           if (length >= sizeof (databuffer.data))
736             {
737               err ("too much data at line %u - can handle only up to % bytes",
738                    lineno, sizeof (databuffer.data));
739               break;
740             }
741           databuffer.data[length++] = value;
742         }
743       databuffer.count = length;
744
745     }
746   else if (!strcmp (p, "TransferFlags"))
747     {
748       flush_data ();
749
750       *databuffer.address = 0;
751       while ((p=strtok (NULL, " \t(,)")))
752         {
753           if (!strcmp (p, "USBD_TRANSFER_DIRECTION_IN"))
754             {
755               databuffer.is_bi = 1;
756               break;
757             }
758           else if (!strcmp (p, "USBD_TRANSFER_DIRECTION_OUT"))
759             {
760               databuffer.is_bi = 0;
761               break;
762             }
763         }
764     }
765
766 }
767
768
769 static void
770 parse_input (FILE *fp)
771 {
772   char line[2000];
773   size_t length;
774   unsigned int lineno = 0;
775
776   while (fgets (line, sizeof (line), fp))
777     {
778       lineno++;
779       length = strlen (line);
780       if (length && line[length - 1] == '\n')
781         line[--length] = 0;
782       else
783         err ("line number %u too long or last line not terminated", lineno);
784       if (length && line[length - 1] == '\r')
785         line[--length] = 0;
786       if (sniffusb)
787         parse_line_sniffusb (line, lineno);
788       else
789         parse_line (line, lineno);
790     }
791   flush_data ();
792   if (ferror (fp))
793     err ("error reading input at line %u: %s", lineno, strerror (errno));
794 }
795
796
797 int
798 main (int argc, char **argv)
799 {
800   int last_argc = -1;
801
802   if (argc)
803     {
804       argc--; argv++;
805     }
806   while (argc && last_argc != argc )
807     {
808       last_argc = argc;
809       if (!strcmp (*argv, "--"))
810         {
811           argc--; argv++;
812           break;
813         }
814       else if (!strcmp (*argv, "--version"))
815         {
816           fputs (PGM " (" GNUPG_NAME ") " PACKAGE_VERSION "\n", stdout);
817           exit (0);
818         }
819       else if (!strcmp (*argv, "--help"))
820         {
821           puts ("Usage: " PGM " [BUS:DEV]\n"
822                 "Parse the output of usbmod assuming it is CCID compliant.\n\n"
823                 "  --skip-escape  do not show escape packets\n"
824                 "  --sniffusb     Assume output from Sniffusb.exe\n"
825                 "  --verbose      enable extra informational output\n"
826                 "  --debug        enable additional debug output\n"
827                 "  --help         display this help and exit\n\n"
828                 "Report bugs to " PACKAGE_BUGREPORT ".");
829           exit (0);
830         }
831       else if (!strcmp (*argv, "--verbose"))
832         {
833           verbose = 1;
834           argc--; argv++;
835         }
836       else if (!strcmp (*argv, "--debug"))
837         {
838           verbose = debug = 1;
839           argc--; argv++;
840         }
841       else if (!strcmp (*argv, "--skip-escape"))
842         {
843           skip_escape = 1;
844           argc--; argv++;
845         }
846       else if (!strcmp (*argv, "--sniffusb"))
847         {
848           sniffusb = 1;
849           argc--; argv++;
850         }
851     }
852
853   if (argc && sniffusb)
854     die ("no arguments expected when using --sniffusb\n");
855   else if (argc > 1)
856     die ("usage: " PGM " [BUS:DEV]  (try --help for more information)\n");
857
858   if (argc == 1)
859     {
860       const char *s = strchr (argv[0], ':');
861
862       usb_bus = atoi (argv[0]);
863       if (s)
864         usb_dev =  atoi (s+1);
865       if (usb_bus < 1 || usb_bus > 999 || usb_dev < 1 || usb_dev > 999)
866         die ("invalid bus:dev specified");
867     }
868
869
870   signal (SIGPIPE, SIG_IGN);
871
872   parse_input (stdin);
873
874   return any_error? 1:0;
875 }
876
877
878 /*
879 Local Variables:
880 compile-command: "gcc -Wall -Wno-pointer-sign -g -o ccidmon ccidmon.c"
881 End:
882 */