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