gpg: No need to create a trustdb when encrypting with --always-trust.
[gnupg.git] / sm / import.c
1 /* import.c - Import certificates
2  * Copyright (C) 2001, 2003, 2004, 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 <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <time.h>
26 #include <assert.h>
27 #include <unistd.h>
28
29 #include "gpgsm.h"
30 #include <gcrypt.h>
31 #include <ksba.h>
32
33 #include "keydb.h"
34 #include "exechelp.h"
35 #include "i18n.h"
36 #include "sysutils.h"
37 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
38
39
40 struct stats_s {
41   unsigned long count;
42   unsigned long imported;
43   unsigned long unchanged;
44   unsigned long not_imported;
45   unsigned long secret_read;
46   unsigned long secret_imported;
47   unsigned long secret_dups;
48  };
49
50
51 static gpg_error_t parse_p12 (ctrl_t ctrl, ksba_reader_t reader, FILE **retfp,
52                               struct stats_s *stats);
53
54
55
56 static void
57 print_imported_status (ctrl_t ctrl, ksba_cert_t cert, int new_cert)
58 {
59   char *fpr;
60      
61   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
62   if (new_cert)
63     gpgsm_status2 (ctrl, STATUS_IMPORTED, fpr, "[X.509]", NULL);
64
65   gpgsm_status2 (ctrl, STATUS_IMPORT_OK, 
66                  new_cert? "1":"0",  fpr, NULL);
67
68   xfree (fpr);
69 }
70
71
72 /* Print an IMPORT_PROBLEM status.  REASON is one of:
73    0 := "No specific reason given".
74    1 := "Invalid Certificate".
75    2 := "Issuer Certificate missing".
76    3 := "Certificate Chain too long".
77    4 := "Error storing certificate".
78 */
79 static void
80 print_import_problem (ctrl_t ctrl, ksba_cert_t cert, int reason)
81 {
82   char *fpr = NULL;
83   char buf[25];
84   int i;
85
86   sprintf (buf, "%d", reason);
87   if (cert)
88     {
89       fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
90       /* detetect an error (all high) value */
91       for (i=0; fpr[i] == 'F'; i++)
92         ;
93       if (!fpr[i])
94         {
95           xfree (fpr);
96           fpr = NULL;
97         }
98     }
99   gpgsm_status2 (ctrl, STATUS_IMPORT_PROBLEM, buf, fpr, NULL);
100   xfree (fpr);
101 }
102
103
104 void
105 print_imported_summary (ctrl_t ctrl, struct stats_s *stats)
106 {
107   char buf[14*25];
108
109   if (!opt.quiet)
110     {
111       log_info (_("total number processed: %lu\n"), stats->count);
112       if (stats->imported) 
113         {
114           log_info (_("              imported: %lu"), stats->imported );
115           log_printf ("\n");
116         }
117       if (stats->unchanged)
118         log_info (_("             unchanged: %lu\n"), stats->unchanged);
119       if (stats->secret_read)
120         log_info (_("      secret keys read: %lu\n"), stats->secret_read );
121       if (stats->secret_imported)
122         log_info (_("  secret keys imported: %lu\n"), stats->secret_imported );
123       if (stats->secret_dups)
124         log_info (_(" secret keys unchanged: %lu\n"), stats->secret_dups );
125       if (stats->not_imported)
126         log_info (_("          not imported: %lu\n"), stats->not_imported);
127     }
128
129   sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
130           stats->count,
131           0l /*stats->no_user_id*/,
132           stats->imported,
133           0l /*stats->imported_rsa*/,
134           stats->unchanged,
135           0l /*stats->n_uids*/,
136           0l /*stats->n_subk*/,
137           0l /*stats->n_sigs*/,
138           0l /*stats->n_revoc*/,
139           stats->secret_read,
140           stats->secret_imported,
141           stats->secret_dups,
142           0l /*stats->skipped_new_keys*/,
143           stats->not_imported
144           );
145   gpgsm_status (ctrl, STATUS_IMPORT_RES, buf);
146 }
147
148
149
150 static void
151 check_and_store (ctrl_t ctrl, struct stats_s *stats,
152                  ksba_cert_t cert, int depth)
153 {
154   int rc;
155
156   if (stats)
157     stats->count++;
158   if ( depth >= 50 )
159     {
160       log_error (_("certificate chain too long\n"));
161       if (stats)
162         stats->not_imported++;
163       print_import_problem (ctrl, cert, 3);
164       return;
165     }
166
167   /* Some basic checks, but don't care about missing certificates;
168      this is so that we are able to import entire certificate chains
169      w/o requiring a special order (i.e. root-CA first).  This used
170      to be different but because gpgsm_verify even imports
171      certificates without any checks, it doesn't matter much and the
172      code gets much cleaner.  A housekeeping function to remove
173      certificates w/o an anchor would be nice, though. 
174      
175      Optionally we do a full validation in addition to the basic test.
176   */
177   rc = gpgsm_basic_cert_check (ctrl, cert);
178   if (!rc && ctrl->with_validation)
179     rc = gpgsm_validate_chain (ctrl, cert, "", NULL, 0, NULL, 0, NULL);
180   if (!rc || (!ctrl->with_validation
181               && (gpg_err_code (rc) == GPG_ERR_MISSING_CERT
182                   || gpg_err_code (rc) == GPG_ERR_MISSING_ISSUER_CERT)))
183     {
184       int existed;
185
186       if (!keydb_store_cert (cert, 0, &existed))
187         {
188           ksba_cert_t next = NULL;
189
190           if (!existed)
191             {
192               print_imported_status (ctrl, cert, 1);
193               if (stats)
194                 stats->imported++;
195             }
196           else
197             {
198               print_imported_status (ctrl, cert, 0);
199               if (stats)
200                 stats->unchanged++;
201             }
202             
203           if (opt.verbose > 1 && existed)
204             {
205               if (depth)
206                 log_info ("issuer certificate already in DB\n");
207               else
208                 log_info ("certificate already in DB\n");
209             }
210           else if (opt.verbose && !existed)
211             {
212               if (depth)
213                 log_info ("issuer certificate imported\n");
214               else
215                 log_info ("certificate imported\n");
216             }
217
218           /* Now lets walk up the chain and import all certificates up
219              the chain.  This is required in case we already stored
220              parent certificates in the ephemeral keybox.  Do not
221              update the statistics, though. */
222           if (!gpgsm_walk_cert_chain (ctrl, cert, &next))
223             {
224               check_and_store (ctrl, NULL, next, depth+1);
225               ksba_cert_release (next);
226             }
227         }
228       else
229         {
230           log_error (_("error storing certificate\n"));
231           if (stats)
232             stats->not_imported++;
233           print_import_problem (ctrl, cert, 4);
234         }
235     }
236   else
237     {
238       log_error (_("basic certificate checks failed - not imported\n"));
239       if (stats)
240         stats->not_imported++;
241       /* We keep the test for GPG_ERR_MISSING_CERT only in case
242          GPG_ERR_MISSING_CERT has been used instead of the newer
243          GPG_ERR_MISSING_ISSUER_CERT.  */
244       print_import_problem 
245         (ctrl, cert,
246          gpg_err_code (rc) == GPG_ERR_MISSING_ISSUER_CERT? 2 :
247          gpg_err_code (rc) == GPG_ERR_MISSING_CERT? 2 :
248          gpg_err_code (rc) == GPG_ERR_BAD_CERT?     1 : 0);
249     }
250 }
251
252
253 \f
254
255 static int
256 import_one (ctrl_t ctrl, struct stats_s *stats, int in_fd)
257 {
258   int rc;
259   Base64Context b64reader = NULL;
260   ksba_reader_t reader;
261   ksba_cert_t cert = NULL;
262   ksba_cms_t cms = NULL;
263   FILE *fp = NULL;
264   ksba_content_type_t ct;
265   int any = 0;
266
267   fp = fdopen ( dup (in_fd), "rb");
268   if (!fp)
269     {
270       rc = gpg_error (gpg_err_code_from_errno (errno));
271       log_error ("fdopen() failed: %s\n", strerror (errno));
272       goto leave;
273     }
274
275   rc = gpgsm_create_reader (&b64reader, ctrl, fp, 1, &reader);
276   if (rc)
277     {
278       log_error ("can't create reader: %s\n", gpg_strerror (rc));
279       goto leave;
280     }
281   
282   
283   /* We need to loop here to handle multiple PEM objects in one
284      file. */
285   do
286     {
287       ksba_cms_release (cms); cms = NULL;
288       ksba_cert_release (cert); cert = NULL;
289       
290       ct = ksba_cms_identify (reader);
291       if (ct == KSBA_CT_SIGNED_DATA)
292         { /* This is probably a signed-only message - import the certs */
293           ksba_stop_reason_t stopreason;
294           int i;
295           
296           rc = ksba_cms_new (&cms);
297           if (rc)
298             goto leave;
299           
300           rc = ksba_cms_set_reader_writer (cms, reader, NULL);
301           if (rc)
302             {
303               log_error ("ksba_cms_set_reader_writer failed: %s\n",
304                          gpg_strerror (rc));
305               goto leave;
306             }
307
308           do 
309             {
310               rc = ksba_cms_parse (cms, &stopreason);
311               if (rc)
312                 {
313                   log_error ("ksba_cms_parse failed: %s\n", gpg_strerror (rc));
314                   goto leave;
315                 }
316
317               if (stopreason == KSBA_SR_BEGIN_DATA)
318                 log_info ("not a certs-only message\n");
319             }
320           while (stopreason != KSBA_SR_READY);   
321       
322           for (i=0; (cert=ksba_cms_get_cert (cms, i)); i++)
323             {
324               check_and_store (ctrl, stats, cert, 0);
325               ksba_cert_release (cert); 
326               cert = NULL;
327             }
328           if (!i)
329             log_error ("no certificate found\n");
330           else
331             any = 1;
332         }
333       else if (ct == KSBA_CT_PKCS12)
334         { /* This seems to be a pkcs12 message.  We use an external
335              tool to parse the message and to store the private keys.
336              We need to use a another reader here to parse the
337              certificate we included in the p12 file; then we continue
338              to look for other pkcs12 files (works only if they are in
339              PEM format. */
340           FILE *certfp;
341           Base64Context b64p12rdr;
342           ksba_reader_t p12rdr;
343           
344           rc = parse_p12 (ctrl, reader, &certfp, stats);
345           if (!rc)
346             {
347               any = 1;
348               
349               rewind (certfp);
350               rc = gpgsm_create_reader (&b64p12rdr, ctrl, certfp, 1, &p12rdr);
351               if (rc)
352                 {
353                   log_error ("can't create reader: %s\n", gpg_strerror (rc));
354                   fclose (certfp);
355                   goto leave;
356                 }
357
358               do
359                 {
360                   ksba_cert_release (cert); cert = NULL;
361                   rc = ksba_cert_new (&cert);
362                   if (!rc)
363                     {
364                       rc = ksba_cert_read_der (cert, p12rdr);
365                       if (!rc)
366                         check_and_store (ctrl, stats, cert, 0);
367                     }
368                   ksba_reader_clear (p12rdr, NULL, NULL);
369                 }
370               while (!rc && !gpgsm_reader_eof_seen (b64p12rdr));
371
372               if (gpg_err_code (rc) == GPG_ERR_EOF)
373                 rc = 0;
374               gpgsm_destroy_reader (b64p12rdr);
375               fclose (certfp);
376               if (rc)
377                 goto leave;
378             }
379         }
380       else if (ct == KSBA_CT_NONE)
381         { /* Failed to identify this message - assume a certificate */
382
383           rc = ksba_cert_new (&cert);
384           if (rc)
385             goto leave;
386
387           rc = ksba_cert_read_der (cert, reader);
388           if (rc)
389             goto leave;
390
391           check_and_store (ctrl, stats, cert, 0);
392           any = 1;
393         }
394       else
395         {
396           log_error ("can't extract certificates from input\n");
397           rc = gpg_error (GPG_ERR_NO_DATA);
398         }
399       
400       ksba_reader_clear (reader, NULL, NULL);
401     }
402   while (!gpgsm_reader_eof_seen (b64reader));
403
404  leave:
405   if (any && gpg_err_code (rc) == GPG_ERR_EOF)
406     rc = 0;
407   ksba_cms_release (cms);
408   ksba_cert_release (cert);
409   gpgsm_destroy_reader (b64reader);
410   if (fp)
411     fclose (fp);
412   return rc;
413 }
414
415
416 \f
417 /* Re-import certifciates.  IN_FD is a list of linefeed delimited
418    fingerprints t re-import.  The actual re-import is done by clearing
419    the ephemeral flag.  */
420 static int
421 reimport_one (ctrl_t ctrl, struct stats_s *stats, int in_fd)
422 {
423   gpg_error_t err = 0;
424   estream_t fp = NULL;
425   char line[100];  /* Sufficient for a fingerprint.  */
426   KEYDB_HANDLE kh;
427   KEYDB_SEARCH_DESC desc;
428   ksba_cert_t cert = NULL;
429   unsigned int flags;
430
431   kh = keydb_new (0);
432   if (!kh)
433     {
434       err = gpg_error (GPG_ERR_ENOMEM);;
435       log_error (_("failed to allocate keyDB handle\n"));
436       goto leave;
437     }
438   keydb_set_ephemeral (kh, 1);
439    
440   fp = es_fdopen_nc (in_fd, "r");
441   if (!fp)
442     {
443       err = gpg_error_from_syserror ();
444       log_error ("es_fdopen(%d) failed: %s\n", in_fd, gpg_strerror (err));
445       goto leave;
446     }
447
448   while (es_fgets (line, DIM(line)-1, fp) )
449     {
450       if (*line && line[strlen(line)-1] != '\n')
451         {
452           err = gpg_error (GPG_ERR_LINE_TOO_LONG);
453           goto leave;
454         }
455       trim_spaces (line);
456       if (!*line)
457         continue;
458     
459       stats->count++;
460
461       err = keydb_classify_name (line, &desc);
462       if (err)
463         {
464           print_import_problem (ctrl, NULL, 0);
465           stats->not_imported++;
466           continue;
467         }
468
469       keydb_search_reset (kh);
470       err = keydb_search (kh, &desc, 1);
471       if (err)
472         {
473           print_import_problem (ctrl, NULL, 0);
474           stats->not_imported++;
475           continue;
476         }
477
478       ksba_cert_release (cert);
479       cert = NULL;
480       err = keydb_get_cert (kh, &cert);
481       if (err)
482         {
483           log_error ("keydb_get_cert() failed: %s\n", gpg_strerror (err));
484           print_import_problem (ctrl, NULL, 1);
485           stats->not_imported++;
486           continue;
487         }
488
489       err = keydb_get_flags (kh, KEYBOX_FLAG_BLOB, 0, &flags);
490       if (err)
491         {
492           log_error (_("error getting stored flags: %s\n"), gpg_strerror (err));
493           print_imported_status (ctrl, cert, 0);
494           stats->not_imported++;
495           continue;
496         }
497       if ( !(flags & KEYBOX_FLAG_BLOB_EPHEMERAL) )
498         {
499           print_imported_status (ctrl, cert, 0);
500           stats->unchanged++;
501           continue;
502         }
503
504       err = keydb_set_cert_flags (cert, 1, KEYBOX_FLAG_BLOB, 0,
505                                   KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
506       if (err)
507         {
508           log_error ("clearing ephemeral flag failed: %s\n",
509                      gpg_strerror (err)); 
510           print_import_problem (ctrl, cert, 0);
511           stats->not_imported++;
512           continue;
513         }
514
515       print_imported_status (ctrl, cert, 1);
516       stats->imported++;
517     }
518   err = 0;
519   if (es_ferror (fp))
520     {
521       err = gpg_error_from_syserror ();
522       log_error ("error reading fd %d: %s\n", in_fd, gpg_strerror (err));
523       goto leave;
524     }
525
526  leave:
527   ksba_cert_release (cert);
528   keydb_release (kh);
529   es_fclose (fp);
530   return err;
531 }
532
533
534 \f
535 int
536 gpgsm_import (ctrl_t ctrl, int in_fd, int reimport_mode)
537 {
538   int rc;
539   struct stats_s stats;
540
541   memset (&stats, 0, sizeof stats);
542   if (reimport_mode)
543     rc = reimport_one (ctrl, &stats, in_fd);
544   else
545     rc = import_one (ctrl, &stats, in_fd);
546   print_imported_summary (ctrl, &stats);
547   /* If we never printed an error message do it now so that a command
548      line invocation will return with an error (log_error keeps a
549      global errorcount) */
550   if (rc && !log_get_errorcount (0))
551     log_error (_("error importing certificate: %s\n"), gpg_strerror (rc));
552   return rc;
553 }
554
555
556 int
557 gpgsm_import_files (ctrl_t ctrl, int nfiles, char **files,
558                     int (*of)(const char *fname))
559 {
560   int rc = 0;
561   struct stats_s stats;
562
563   memset (&stats, 0, sizeof stats);
564   
565   if (!nfiles)
566     rc = import_one (ctrl, &stats, 0);
567   else
568     {
569       for (; nfiles && !rc ; nfiles--, files++)
570         {
571           int fd = of (*files);
572           rc = import_one (ctrl, &stats, fd);
573           close (fd);
574           if (rc == -1)
575             rc = 0;
576         }
577     }
578   print_imported_summary (ctrl, &stats);
579   /* If we never printed an error message do it now so that a command
580      line invocation will return with an error (log_error keeps a
581      global errorcount) */
582   if (rc && !log_get_errorcount (0))
583     log_error (_("error importing certificate: %s\n"), gpg_strerror (rc));
584   return rc;
585 }
586
587
588 /* Fork and exec the protecttool, connect the file descriptor of
589    INFILE to stdin, return a new stream in STATUSFILE, write the
590    output to OUTFILE and the pid of the process in PID.  Returns 0 on
591    success or an error code. */
592 static gpg_error_t
593 popen_protect_tool (ctrl_t ctrl, const char *pgmname,
594                     FILE *infile, FILE *outfile, FILE **statusfile, pid_t *pid)
595 {
596   const char *argv[22];
597   int i=0;
598
599   /* Make sure that the agent is running so that the protect tool is
600      able to ask for a passphrase.  This has only an effect under W32
601      where the agent is started on demand; sending a NOP does not harm
602      on other platforms.  This is not really necessary anymore because
603      the protect tool does this now by itself; it does not harm either. */
604   gpgsm_agent_send_nop (ctrl);
605
606   argv[i++] = "--homedir";
607   argv[i++] = opt.homedir;
608   argv[i++] = "--p12-import";
609   argv[i++] = "--store";
610   argv[i++] = "--no-fail-on-exist";
611   argv[i++] = "--enable-status-msg";
612   if (opt.fixed_passphrase)
613     {
614       argv[i++] = "--passphrase";
615       argv[i++] = opt.fixed_passphrase;
616     }
617   if (opt.agent_program)
618     {
619       argv[i++] = "--agent-program";
620       argv[i++] = opt.agent_program;
621     }
622   argv[i++] = "--",
623   argv[i] = NULL;
624   assert (i < sizeof argv);
625
626   return gnupg_spawn_process (pgmname, argv, infile, outfile,
627                               setup_pinentry_env, (128 | 64),
628                               statusfile, pid);
629 }
630
631
632 /* Assume that the reader is at a pkcs#12 message and try to import
633    certificates from that stupid format.  We will also store secret
634    keys.  All of the pkcs#12 parsing and key storing is handled by the
635    gpg-protect-tool, we merely have to take care of receiving the
636    certificates. On success RETFP returns a temporary file with
637    certificates. */
638 static gpg_error_t
639 parse_p12 (ctrl_t ctrl, ksba_reader_t reader,
640            FILE **retfp, struct stats_s *stats)
641 {
642   const char *pgmname;
643   gpg_error_t err = 0, child_err = 0;
644   int c, cont_line;
645   unsigned int pos;
646   FILE *tmpfp, *certfp = NULL, *fp = NULL;
647   char buffer[1024];
648   size_t nread;
649   pid_t pid = -1;
650   int bad_pass = 0;
651
652   if (!opt.protect_tool_program || !*opt.protect_tool_program)
653     pgmname = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
654   else
655     pgmname = opt.protect_tool_program;
656
657   *retfp = NULL;
658
659   /* To avoid an extra feeder process or doing selects and because
660      gpg-protect-tool will anyway parse the entire pkcs#12 message in
661      memory, we simply use tempfiles here and pass them to
662      the gpg-protect-tool. */
663   tmpfp = gnupg_tmpfile ();
664   if (!tmpfp)
665     {
666       err = gpg_error_from_syserror ();
667       log_error (_("error creating temporary file: %s\n"), strerror (errno));
668       goto cleanup;
669     }
670   while (!(err = ksba_reader_read (reader, buffer, sizeof buffer, &nread)))
671     {
672       if (nread && fwrite (buffer, nread, 1, tmpfp) != 1)
673         {
674           err = gpg_error_from_syserror ();
675           log_error (_("error writing to temporary file: %s\n"),
676                      strerror (errno));
677           goto cleanup;
678         }
679     }
680   if (gpg_err_code (err) == GPG_ERR_EOF)
681     err = 0;
682   if (err)
683     {
684       log_error (_("error reading input: %s\n"), gpg_strerror (err));
685       goto cleanup;
686     }
687
688   certfp = gnupg_tmpfile ();
689   if (!certfp)
690     {
691       err = gpg_error_from_syserror ();
692       log_error (_("error creating temporary file: %s\n"), strerror (errno));
693       goto cleanup;
694     }
695
696   err = popen_protect_tool (ctrl, pgmname, tmpfp, certfp, &fp, &pid);
697   if (err)
698     {
699       pid = -1;
700       goto cleanup;
701     }
702   fclose (tmpfp);
703   tmpfp = NULL;
704
705   /* Read stderr of the protect tool. */
706   pos = 0;
707   cont_line = 0;
708   while ((c=getc (fp)) != EOF)
709     {
710       /* fixme: We could here grep for status information of the
711          protect tool to figure out better error codes for
712          CHILD_ERR. */
713       buffer[pos++] = c;
714       if (pos >= sizeof buffer - 5 || c == '\n')
715         {
716           buffer[pos - (c == '\n')] = 0;
717           if (cont_line)
718             log_printf ("%s", buffer);
719           else
720             {
721               if (!strncmp (buffer, "gpg-protect-tool: [PROTECT-TOOL:] ",34))
722                 {
723                   char *p, *pend;
724
725                   p = buffer + 34;
726                   pend = strchr (p, ' ');
727                   if (pend)
728                     *pend = 0;
729                   if ( !strcmp (p, "secretkey-stored"))
730                     {
731                       stats->count++;
732                       stats->secret_read++;
733                       stats->secret_imported++;
734                     }
735                   else if ( !strcmp (p, "secretkey-exists"))
736                     {
737                       stats->count++;
738                       stats->secret_read++;
739                       stats->secret_dups++;
740                     }
741                   else if ( !strcmp (p, "bad-passphrase"))
742                     {
743
744                     }
745                 }
746               else 
747                 {
748                   log_info ("%s", buffer);
749                   if (!strncmp (buffer, "gpg-protect-tool: "
750                                 "possibly bad passphrase given",46))
751                     bad_pass++;
752                 }
753             }
754           pos = 0;
755           cont_line = (c != '\n');
756         }
757     }
758
759   if (pos)
760     {
761       buffer[pos] = 0;
762       if (cont_line)
763         log_printf ("%s\n", buffer);
764       else
765         log_info ("%s\n", buffer);
766     }
767
768
769   /* If we found no error in the output of the child, setup a suitable
770      error code, which will later be reset if the exit status of the
771      child is 0. */
772   if (!child_err)
773     child_err = gpg_error (GPG_ERR_DECRYPT_FAILED);
774
775  cleanup:
776   if (tmpfp)
777     fclose (tmpfp);
778   if (fp)
779     fclose (fp);
780   if (pid != -1)
781     {
782       if (!gnupg_wait_process (pgmname, pid, NULL))
783         child_err = 0;
784     }
785   if (!err)
786     err = child_err;
787   if (err)
788     {
789       if (certfp)
790         fclose (certfp);
791     }
792   else
793     *retfp = certfp;
794
795   if (bad_pass)
796     {
797       /* We only write a plain error code and not direct
798          BAD_PASSPHRASE because the pkcs12 parser might issue this
799          message multiple times, BAD_PASSPHRASE in general requires a
800          keyID and parts of the import might actually succeed so that
801          IMPORT_PROBLEM is also not appropriate. */
802       gpgsm_status_with_err_code (ctrl, STATUS_ERROR,
803                                   "import.parsep12", GPG_ERR_BAD_PASSPHRASE);
804     }
805   
806   return err;
807 }