gpg: Update list of card vendors from master
[gnupg.git] / kbx / keybox-dump.c
1 /* keybox-dump.c - Debug helpers
2  *      Copyright (C) 2001, 2003 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 #include <config.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <errno.h>
25
26 #include "keybox-defs.h"
27 #include <gcrypt.h>
28 #include "../common/host2net.h"
29
30 /* Argg, we can't include ../common/util.h */
31 char *bin2hexcolon (const void *buffer, size_t length, char *stringbuf);
32
33 #define get32(a) buf32_to_ulong ((a))
34 #define get16(a) buf16_to_ulong ((a))
35
36
37 void
38 print_string (FILE *fp, const byte *p, size_t n, int delim)
39 {
40   for ( ; n; n--, p++ )
41     {
42       if (*p < 0x20 || (*p >= 0x7f && *p < 0xa0) || *p == delim)
43         {
44           putc('\\', fp);
45           if( *p == '\n' )
46             putc('n', fp);
47           else if( *p == '\r' )
48             putc('r', fp);
49           else if( *p == '\f' )
50             putc('f', fp);
51           else if( *p == '\v' )
52             putc('v', fp);
53           else if( *p == '\b' )
54             putc('b', fp);
55           else if( !*p )
56             putc('0', fp);
57           else
58             fprintf(fp, "x%02x", *p );
59         }
60       else
61         putc(*p, fp);
62     }
63 }
64
65
66 static int
67 print_checksum (const byte *buffer, size_t length, size_t unhashed, FILE *fp)
68 {
69   const byte *p;
70   int i;
71   int hashlen;
72   unsigned char digest[20];
73
74   fprintf (fp, "Checksum: ");
75   if (unhashed && unhashed < 20)
76     {
77       fputs ("[specified unhashed sized too short]\n", fp);
78       return 0;
79     }
80   if (!unhashed)
81     {
82       unhashed = 16;
83       hashlen = 16;
84     }
85   else
86     hashlen = 20;
87   if (length < 5+unhashed)
88     {
89       fputs ("[blob too short for a checksum]\n", fp);
90       return 0;
91     }
92
93   p = buffer + length - hashlen;
94   for (i=0; i < hashlen; p++, i++)
95     fprintf (fp, "%02x", *p);
96
97   if (hashlen == 16) /* Compatibility method.  */
98     {
99       gcry_md_hash_buffer (GCRY_MD_MD5, digest, buffer, length - 16);
100       if (!memcmp (buffer + length - 16, digest, 16))
101         fputs (" [valid]\n", fp);
102       else
103         fputs (" [bad]\n", fp);
104     }
105   else
106     {
107       gcry_md_hash_buffer (GCRY_MD_SHA1, digest, buffer, length - unhashed);
108       if (!memcmp (buffer + length - hashlen, digest, hashlen))
109         fputs (" [valid]\n", fp);
110       else
111         fputs (" [bad]\n", fp);
112     }
113   return 0;
114 }
115
116
117 static int
118 dump_header_blob (const byte *buffer, size_t length, FILE *fp)
119 {
120   unsigned long n;
121
122   if (length < 32)
123     {
124       fprintf (fp, "[blob too short]\n");
125       return -1;
126     }
127   fprintf (fp, "Version: %d\n", buffer[5]);
128
129   n = get16 (buffer + 6);
130   fprintf( fp, "Flags:   %04lX", n);
131   if (n)
132     {
133       int any = 0;
134
135       fputs (" (", fp);
136       if ((n & 2))
137         {
138           if (any)
139             putc (',', fp);
140           fputs ("openpgp", fp);
141           any++;
142         }
143       putc (')', fp);
144     }
145   putc ('\n', fp);
146
147   if ( memcmp (buffer+8, "KBXf", 4))
148     fprintf (fp, "[Error: invalid magic number]\n");
149
150   n = get32 (buffer+16);
151   fprintf( fp, "created-at: %lu\n", n );
152   n = get32 (buffer+20);
153   fprintf( fp, "last-maint: %lu\n", n );
154
155   return 0;
156 }
157
158 \f
159 /* Dump one block to FP */
160 int
161 _keybox_dump_blob (KEYBOXBLOB blob, FILE *fp)
162 {
163   const byte *buffer;
164   size_t length;
165   int type, i;
166   ulong n, nkeys, keyinfolen;
167   ulong nuids, uidinfolen;
168   ulong nsigs, siginfolen;
169   ulong rawdata_off, rawdata_len;
170   ulong nserial;
171   ulong unhashed;
172   const byte *p;
173
174   buffer = _keybox_get_blob_image (blob, &length);
175
176   if (length < 32)
177     {
178       fprintf (fp, "[blob too short]\n");
179       return -1;
180     }
181
182   n = get32( buffer );
183   if (n > length)
184     fprintf (fp, "[blob larger than length - output truncated]\n");
185   else
186     length = n;  /* ignore the rest */
187
188   fprintf (fp, "Length: %lu\n", n );
189   type = buffer[4];
190   switch (type)
191     {
192     case KEYBOX_BLOBTYPE_EMPTY:
193       fprintf (fp, "Type:   Empty\n");
194       return 0;
195
196     case KEYBOX_BLOBTYPE_HEADER:
197       fprintf (fp, "Type:   Header\n");
198       return dump_header_blob (buffer, length, fp);
199     case KEYBOX_BLOBTYPE_PGP:
200       fprintf (fp, "Type:   OpenPGP\n");
201       break;
202     case KEYBOX_BLOBTYPE_X509:
203       fprintf (fp, "Type:   X.509\n");
204       break;
205     default:
206       fprintf (fp, "Type:   %d\n", type);
207       fprintf (fp, "[can't dump this blob type]\n");
208       return 0;
209     }
210   fprintf (fp, "Version: %d\n", buffer[5]);
211
212   if (length < 40)
213     {
214       fprintf (fp, "[blob too short]\n");
215       return -1;
216     }
217
218   n = get16 (buffer + 6);
219   fprintf( fp, "Blob-Flags: %04lX", n);
220   if (n)
221     {
222       int any = 0;
223
224       fputs (" (", fp);
225       if ((n & 1))
226         {
227           fputs ("secret", fp);
228           any++;
229         }
230       if ((n & 2))
231         {
232           if (any)
233             putc (',', fp);
234           fputs ("ephemeral", fp);
235           any++;
236         }
237       putc (')', fp);
238     }
239   putc ('\n', fp);
240
241   rawdata_off = get32 (buffer + 8);
242   rawdata_len = get32 (buffer + 12);
243
244   fprintf( fp, "Data-Offset: %lu\n", rawdata_off );
245   fprintf( fp, "Data-Length: %lu\n", rawdata_len );
246   if (rawdata_off > length || rawdata_len > length
247       || rawdata_off+rawdata_len > length
248       || rawdata_len + 4 > length
249       || rawdata_off+rawdata_len + 4 > length)
250     fprintf (fp, "[Error: raw data larger than blob]\n");
251   unhashed = length - rawdata_off - rawdata_len;
252   fprintf (fp, "Unhashed: %lu\n", unhashed);
253
254   nkeys = get16 (buffer + 16);
255   fprintf (fp, "Key-Count: %lu\n", nkeys );
256   if (!nkeys)
257     fprintf (fp, "[Error: no keys]\n");
258   if (nkeys > 1 && type == KEYBOX_BLOBTYPE_X509)
259     fprintf (fp, "[Error: only one key allowed for X509]\n");
260
261   keyinfolen = get16 (buffer + 18 );
262   fprintf (fp, "Key-Info-Length: %lu\n", keyinfolen);
263   /* fixme: check bounds */
264   p = buffer + 20;
265   for (n=0; n < nkeys; n++, p += keyinfolen)
266     {
267       ulong kidoff, kflags;
268
269       fprintf (fp, "Key-Fpr[%lu]: ", n );
270       for (i=0; i < 20; i++ )
271         fprintf (fp, "%02X", p[i]);
272       kidoff = get32 (p + 20);
273       fprintf (fp, "\nKey-Kid-Off[%lu]: %lu\n", n, kidoff );
274       fprintf (fp, "Key-Kid[%lu]: ", n );
275       /* fixme: check bounds */
276       for (i=0; i < 8; i++ )
277         fprintf (fp, "%02X", buffer[kidoff+i] );
278       kflags = get16 (p + 24 );
279       fprintf( fp, "\nKey-Flags[%lu]: %04lX\n", n, kflags);
280     }
281
282   /* serial number */
283   fputs ("Serial-No: ", fp);
284   nserial = get16 (p);
285   p += 2;
286   if (!nserial)
287     fputs ("none", fp);
288   else
289     {
290       for (; nserial; nserial--, p++)
291         fprintf (fp, "%02X", *p);
292     }
293   putc ('\n', fp);
294
295   /* user IDs */
296   nuids = get16 (p);
297   fprintf (fp, "Uid-Count: %lu\n", nuids );
298   uidinfolen = get16  (p + 2);
299   fprintf (fp, "Uid-Info-Length: %lu\n", uidinfolen);
300   /* fixme: check bounds */
301   p += 4;
302   for (n=0; n < nuids; n++, p += uidinfolen)
303     {
304       ulong uidoff, uidlen, uflags;
305
306       uidoff = get32( p );
307       uidlen = get32( p+4 );
308       if (type == KEYBOX_BLOBTYPE_X509 && !n)
309         {
310           fprintf (fp, "Issuer-Off: %lu\n", uidoff );
311           fprintf (fp, "Issuer-Len: %lu\n", uidlen );
312           fprintf (fp, "Issuer: \"");
313         }
314       else if (type == KEYBOX_BLOBTYPE_X509 && n == 1)
315         {
316           fprintf (fp, "Subject-Off: %lu\n", uidoff );
317           fprintf (fp, "Subject-Len: %lu\n", uidlen );
318           fprintf (fp, "Subject: \"");
319         }
320       else
321         {
322           fprintf (fp, "Uid-Off[%lu]: %lu\n", n, uidoff );
323           fprintf (fp, "Uid-Len[%lu]: %lu\n", n, uidlen );
324           fprintf (fp, "Uid[%lu]: \"", n );
325         }
326       print_string (fp, buffer+uidoff, uidlen, '\"');
327       fputs ("\"\n", fp);
328       uflags = get16 (p + 8);
329       if (type == KEYBOX_BLOBTYPE_X509 && !n)
330         {
331           fprintf (fp, "Issuer-Flags: %04lX\n", uflags );
332           fprintf (fp, "Issuer-Validity: %d\n", p[10] );
333         }
334       else if (type == KEYBOX_BLOBTYPE_X509 && n == 1)
335         {
336           fprintf (fp, "Subject-Flags: %04lX\n", uflags );
337           fprintf (fp, "Subject-Validity: %d\n", p[10] );
338         }
339       else
340         {
341           fprintf (fp, "Uid-Flags[%lu]: %04lX\n", n, uflags );
342           fprintf (fp, "Uid-Validity[%lu]: %d\n", n, p[10] );
343         }
344     }
345
346   nsigs = get16 (p);
347   fprintf (fp, "Sig-Count: %lu\n", nsigs );
348   siginfolen = get16 (p + 2);
349   fprintf (fp, "Sig-Info-Length: %lu\n", siginfolen );
350   /* fixme: check bounds  */
351   p += 4;
352   {
353     int in_range = 0;
354     ulong first = 0;
355
356     for (n=0; n < nsigs; n++, p += siginfolen)
357       {
358         ulong sflags;
359
360         sflags = get32 (p);
361         if (!in_range && !sflags)
362           {
363             in_range = 1;
364             first = n;
365             continue;
366           }
367         if (in_range && !sflags)
368           continue;
369         if (in_range)
370           {
371             fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1);
372             in_range = 0;
373           }
374
375         fprintf (fp, "Sig-Expire[%lu]: ", n );
376         if (!sflags)
377           fputs ("[not checked]", fp);
378         else if (sflags == 1 )
379           fputs ("[missing key]", fp);
380         else if (sflags == 2 )
381           fputs ("[bad signature]", fp);
382         else if (sflags < 0x10000000)
383           fprintf (fp, "[bad flag %0lx]", sflags);
384         else if (sflags == (ulong)(-1))
385           fputs ("[good - does not expire]", fp );
386         else
387           fprintf (fp, "[good - expires at %lu]", sflags);
388         putc ('\n', fp );
389       }
390     if (in_range)
391       fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1);
392   }
393   fprintf (fp, "Ownertrust: %d\n", p[0] );
394   fprintf (fp, "All-Validity: %d\n", p[1] );
395   p += 4;
396   n = get32 (p);
397   p += 4;
398   fprintf (fp, "Recheck-After: %lu\n", n );
399   n = get32 (p );
400   p += 4;
401   fprintf( fp, "Latest-Timestamp: %lu\n", n );
402   n = get32 (p );
403   p += 4;
404   fprintf (fp, "Created-At: %lu\n", n );
405   n = get32 (p );
406   fprintf (fp, "Reserved-Space: %lu\n", n );
407
408   if (n >= 4 && unhashed >= 24)
409     {
410       n = get32 ( buffer + length - unhashed);
411       fprintf (fp, "Storage-Flags: %08lx\n", n );
412     }
413   print_checksum (buffer, length, unhashed, fp);
414   return 0;
415 }
416
417
418 /* Compute the SHA-1 checksum of the rawdata in BLOB and put it into
419    DIGEST. */
420 static int
421 hash_blob_rawdata (KEYBOXBLOB blob, unsigned char *digest)
422 {
423   const unsigned char *buffer;
424   size_t n, length;
425   int type;
426   ulong rawdata_off, rawdata_len;
427
428   buffer = _keybox_get_blob_image (blob, &length);
429
430   if (length < 32)
431     return -1;
432   n = get32 (buffer);
433   if (n < length)
434     length = n;  /* Blob larger than length in header - ignore the rest. */
435
436   type = buffer[4];
437   switch (type)
438     {
439     case KEYBOX_BLOBTYPE_PGP:
440     case KEYBOX_BLOBTYPE_X509:
441       break;
442
443     case KEYBOX_BLOBTYPE_EMPTY:
444     case KEYBOX_BLOBTYPE_HEADER:
445     default:
446       memset (digest, 0, 20);
447       return 0;
448     }
449
450   if (length < 40)
451     return -1;
452
453   rawdata_off = get32 (buffer + 8);
454   rawdata_len = get32 (buffer + 12);
455
456   if (rawdata_off > length || rawdata_len > length
457       || rawdata_off+rawdata_off > length)
458     return -1; /* Out of bounds.  */
459
460   gcry_md_hash_buffer (GCRY_MD_SHA1, digest, buffer+rawdata_off, rawdata_len);
461   return 0;
462 }
463
464
465 struct file_stats_s
466 {
467   unsigned long too_short_blobs;
468   unsigned long too_large_blobs;
469   unsigned long total_blob_count;
470   unsigned long empty_blob_count;
471   unsigned long header_blob_count;
472   unsigned long pgp_blob_count;
473   unsigned long x509_blob_count;
474   unsigned long unknown_blob_count;
475   unsigned long non_flagged;
476   unsigned long secret_flagged;
477   unsigned long ephemeral_flagged;
478   unsigned long skipped_long_blobs;
479 };
480
481 static int
482 update_stats (KEYBOXBLOB blob, struct file_stats_s *s)
483 {
484   const unsigned char *buffer;
485   size_t length;
486   int type;
487   unsigned long n;
488
489   buffer = _keybox_get_blob_image (blob, &length);
490   if (length < 32)
491     {
492       s->too_short_blobs++;
493       return -1;
494     }
495
496   n = get32( buffer );
497   if (n > length)
498     s->too_large_blobs++;
499   else
500     length = n;  /* ignore the rest */
501
502   s->total_blob_count++;
503   type = buffer[4];
504   switch (type)
505     {
506     case KEYBOX_BLOBTYPE_EMPTY:
507       s->empty_blob_count++;
508       return 0;
509     case KEYBOX_BLOBTYPE_HEADER:
510       s->header_blob_count++;
511       return 0;
512     case KEYBOX_BLOBTYPE_PGP:
513       s->pgp_blob_count++;
514       break;
515     case KEYBOX_BLOBTYPE_X509:
516       s->x509_blob_count++;
517       break;
518     default:
519       s->unknown_blob_count++;
520       return 0;
521     }
522
523   if (length < 40)
524     {
525       s->too_short_blobs++;
526       return -1;
527     }
528
529   n = get16 (buffer + 6);
530   if (n)
531     {
532       if ((n & 1))
533         s->secret_flagged++;
534       if ((n & 2))
535         s->ephemeral_flagged++;
536     }
537   else
538     s->non_flagged++;
539
540   return 0;
541 }
542
543
544 \f
545 static FILE *
546 open_file (const char **filename, FILE *outfp)
547 {
548   FILE *fp;
549
550   if (!*filename)
551     {
552       *filename = "-";
553       fp = stdin;
554     }
555   else
556     fp = fopen (*filename, "rb");
557   if (!fp)
558     {
559       int save_errno = errno;
560       fprintf (outfp, "can't open '%s': %s\n", *filename, strerror(errno));
561       gpg_err_set_errno (save_errno);
562     }
563   return fp;
564 }
565
566
567
568 int
569 _keybox_dump_file (const char *filename, int stats_only, FILE *outfp)
570 {
571   FILE *fp;
572   KEYBOXBLOB blob;
573   int rc;
574   unsigned long count = 0;
575   struct file_stats_s stats;
576
577   memset (&stats, 0, sizeof stats);
578
579   if (!(fp = open_file (&filename, outfp)))
580     return gpg_error_from_syserror ();
581
582   for (;;)
583     {
584       rc = _keybox_read_blob (&blob, fp, NULL);
585       if (gpg_err_code (rc) == GPG_ERR_TOO_LARGE
586           && gpg_err_source (rc) == GPG_ERR_SOURCE_KEYBOX)
587         {
588           if (stats_only)
589             stats.skipped_long_blobs++;
590           else
591             {
592               fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
593               fprintf (outfp, "# Record too large\nEND-RECORD\n");
594             }
595           count++;
596           continue;
597         }
598       if (rc)
599         break;
600
601       if (stats_only)
602         {
603           update_stats (blob, &stats);
604         }
605       else
606         {
607           fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
608           _keybox_dump_blob (blob, outfp);
609           fprintf (outfp, "END-RECORD\n");
610         }
611       _keybox_release_blob (blob);
612       count++;
613     }
614   if (rc == -1)
615     rc = 0;
616   if (rc)
617     fprintf (outfp, "# error reading '%s': %s\n", filename, gpg_strerror (rc));
618
619   if (fp != stdin)
620     fclose (fp);
621
622   if (stats_only)
623     {
624       fprintf (outfp,
625                "Total number of blobs: %8lu\n"
626                "               header: %8lu\n"
627                "                empty: %8lu\n"
628                "              openpgp: %8lu\n"
629                "                 x509: %8lu\n"
630                "          non flagged: %8lu\n"
631                "       secret flagged: %8lu\n"
632                "    ephemeral flagged: %8lu\n",
633                stats.total_blob_count,
634                stats.header_blob_count,
635                stats.empty_blob_count,
636                stats.pgp_blob_count,
637                stats.x509_blob_count,
638                stats.non_flagged,
639                stats.secret_flagged,
640                stats.ephemeral_flagged);
641         if (stats.skipped_long_blobs)
642           fprintf (outfp, "   skipped long blobs: %8lu\n",
643                    stats.skipped_long_blobs);
644         if (stats.unknown_blob_count)
645           fprintf (outfp, "   unknown blob types: %8lu\n",
646                    stats.unknown_blob_count);
647         if (stats.too_short_blobs)
648           fprintf (outfp, "      too short blobs: %8lu (error)\n",
649                    stats.too_short_blobs);
650         if (stats.too_large_blobs)
651           fprintf (outfp, "      too large blobs: %8lu (error)\n",
652                    stats.too_large_blobs);
653     }
654
655   return rc;
656 }
657
658
659 \f
660 struct dupitem_s
661 {
662   unsigned long recno;
663   unsigned char digest[20];
664 };
665
666
667 static int
668 cmp_dupitems (const void *arg_a, const void *arg_b)
669 {
670   struct dupitem_s *a = (struct dupitem_s *)arg_a;
671   struct dupitem_s *b = (struct dupitem_s *)arg_b;
672
673   return memcmp (a->digest, b->digest, 20);
674 }
675
676
677 int
678 _keybox_dump_find_dups (const char *filename, int print_them, FILE *outfp)
679 {
680   FILE *fp;
681   KEYBOXBLOB blob;
682   int rc;
683   unsigned long recno = 0;
684   unsigned char zerodigest[20];
685   struct dupitem_s *dupitems;
686   size_t dupitems_size, dupitems_count, lastn, n;
687   char fprbuf[3*20+1];
688
689   (void)print_them;
690
691   memset (zerodigest, 0, sizeof zerodigest);
692
693   if (!(fp = open_file (&filename, outfp)))
694     return gpg_error_from_syserror ();
695
696   dupitems_size = 1000;
697   dupitems = malloc (dupitems_size * sizeof *dupitems);
698   if (!dupitems)
699     {
700       gpg_error_t tmperr = gpg_error_from_syserror ();
701       fprintf (outfp, "error allocating array for '%s': %s\n",
702                filename, strerror(errno));
703       return tmperr;
704     }
705   dupitems_count = 0;
706
707   while ( !(rc = _keybox_read_blob (&blob, fp, NULL)) )
708     {
709       unsigned char digest[20];
710
711       if (hash_blob_rawdata (blob, digest))
712         fprintf (outfp, "error in blob %ld of '%s'\n", recno, filename);
713       else if (memcmp (digest, zerodigest, 20))
714         {
715           if (dupitems_count >= dupitems_size)
716             {
717               struct dupitem_s *tmp;
718
719               dupitems_size += 1000;
720               tmp = realloc (dupitems, dupitems_size * sizeof *dupitems);
721               if (!tmp)
722                 {
723                   gpg_error_t tmperr = gpg_error_from_syserror ();
724                   fprintf (outfp, "error reallocating array for '%s': %s\n",
725                            filename, strerror(errno));
726                   free (dupitems);
727                   return tmperr;
728                 }
729               dupitems = tmp;
730             }
731           dupitems[dupitems_count].recno = recno;
732           memcpy (dupitems[dupitems_count].digest, digest, 20);
733           dupitems_count++;
734         }
735       _keybox_release_blob (blob);
736       recno++;
737     }
738   if (rc == -1)
739     rc = 0;
740   if (rc)
741     fprintf (outfp, "error reading '%s': %s\n", filename, gpg_strerror (rc));
742   if (fp != stdin)
743     fclose (fp);
744
745   qsort (dupitems, dupitems_count, sizeof *dupitems, cmp_dupitems);
746
747   for (lastn=0, n=1; n < dupitems_count; lastn=n, n++)
748     {
749       if (!memcmp (dupitems[lastn].digest, dupitems[n].digest, 20))
750         {
751           bin2hexcolon (dupitems[lastn].digest, 20, fprbuf);
752           fprintf (outfp, "fpr=%s recno=%lu", fprbuf, dupitems[lastn].recno);
753           do
754             fprintf (outfp, " %lu", dupitems[n].recno);
755           while (++n < dupitems_count
756                  && !memcmp (dupitems[lastn].digest, dupitems[n].digest, 20));
757           putc ('\n', outfp);
758           n--;
759         }
760     }
761
762   free (dupitems);
763
764   return rc;
765 }
766
767
768 /* Print records with record numbers FROM to TO to OUTFP.  */
769 int
770 _keybox_dump_cut_records (const char *filename, unsigned long from,
771                           unsigned long to, FILE *outfp)
772 {
773   FILE *fp;
774   KEYBOXBLOB blob;
775   int rc;
776   unsigned long recno = 0;
777
778   if (!(fp = open_file (&filename, stderr)))
779     return gpg_error_from_syserror ();
780
781   while ( !(rc = _keybox_read_blob (&blob, fp, NULL)) )
782     {
783       if (recno > to)
784         break; /* Ready.  */
785       if (recno >= from)
786         {
787           if ((rc = _keybox_write_blob (blob, outfp)))
788             {
789               fprintf (stderr, "error writing output: %s\n",
790                        gpg_strerror (rc));
791               goto leave;
792             }
793         }
794       _keybox_release_blob (blob);
795       recno++;
796     }
797   if (rc == -1)
798     rc = 0;
799   if (rc)
800     fprintf (stderr, "error reading '%s': %s\n", filename, gpg_strerror (rc));
801  leave:
802   if (fp != stdin)
803     fclose (fp);
804   return rc;
805 }