We have reached a state where we are able to import certs and
[gnupg.git] / sm / import.c
1 /* import.c - Import certificates
2  *      Copyright (C) 2001 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h> 
27 #include <time.h>
28 #include <assert.h>
29
30 #include <gcrypt.h>
31 #include <ksba.h>
32
33 #include "gpgsm.h"
34 #include "keydb.h"
35 #include "i18n.h"
36
37 struct reader_cb_parm_s {
38   FILE *fp;
39 };
40
41
42 static int
43 reader_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
44 {
45   struct reader_cb_parm_s *parm = cb_value;
46   size_t n;
47   int c = 0;
48
49   *nread = 0;
50   if (!buffer)
51     return -1; /* not supported */
52
53   for (n=0; n < count; n++)
54     {
55       c = getc (parm->fp);
56       if (c == EOF)
57         {
58           if ( ferror (parm->fp) )
59             return -1;
60           if (n)
61             break; /* return what we have before an EOF */
62           return -1;
63         }
64       *(byte *)buffer++ = c;
65     }
66
67   *nread = n;
68   return 0;
69 }
70
71
72 static void
73 store_cert (KsbaCert cert)
74 {
75   KEYDB_HANDLE kh;
76   int rc;
77
78   kh = keydb_new (0);
79   if (!kh)
80     {
81       log_error (_("failed to allocated keyDB handle\n"));
82       return;
83     }
84   rc = keydb_locate_writable (kh, 0);
85   if (rc)
86       log_error (_("error finding writable keyDB: %s\n"), gpgsm_strerror (rc));
87
88   rc = keydb_insert_cert (kh, cert);
89   if (rc)
90     {
91       log_error (_("error storing certificate: %s\n"), gpgsm_strerror (rc));
92     }
93   keydb_release (kh);               
94 }
95
96
97
98 \f
99 int
100 gpgsm_import (int in_fd)
101 {
102   int rc;
103   KsbaReader reader = NULL;
104   KsbaCert cert = NULL;
105   struct reader_cb_parm_s rparm;
106
107   memset (&rparm, 0, sizeof rparm);
108
109   rparm.fp = fdopen ( dup (in_fd), "rb");
110   if (!rparm.fp)
111     {
112       log_error ("fdopen() failed: %s\n", strerror (errno));
113       rc = seterr (IO_Error);
114       goto leave;
115     }
116
117   /* setup a skaba reader which uses a callback function so that we can 
118      strip off a base64 encoding when necessary */
119   reader = ksba_reader_new ();
120   if (!reader)
121     {
122       rc = seterr (Out_Of_Core);
123       goto leave;
124     }
125
126   rc = ksba_reader_set_cb (reader, reader_cb, &rparm );
127   if (rc)
128     {
129       ksba_reader_release (reader);
130       rc = map_ksba_err (rc);
131       goto leave;
132     }
133
134   cert = ksba_cert_new ();
135   if (!cert)
136     {
137       rc = seterr (Out_Of_Core);
138       goto leave;
139     }
140
141   rc = ksba_cert_read_der (cert, reader);
142   if (rc)
143     {
144       rc = map_ksba_err (rc);
145       goto leave;
146     }
147
148   if ( !gpgsm_validate_path (cert) )
149     store_cert (cert);
150
151  leave:
152   ksba_cert_release (cert);
153   ksba_reader_release (reader);
154   if (rparm.fp)
155     fclose (rparm.fp);
156   return rc;
157 }
158
159