* certdump.c (print_dn_part): Always print a leading slash,
[gnupg.git] / sm / export.c
1 /* export.c
2  * Copyright (C) 2002 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
36 static void print_short_info (KsbaCert cert, FILE *fp);
37
38
39
40 /* Export all certificates or just those given in NAMES. */
41 void
42 gpgsm_export (CTRL ctrl, STRLIST names, FILE *fp)
43 {
44   KEYDB_HANDLE hd;
45   KEYDB_SEARCH_DESC *desc = NULL;
46   int ndesc;
47   Base64Context b64writer = NULL;
48   KsbaWriter writer;
49   STRLIST sl;
50   KsbaCert cert = NULL;
51   int rc=0;
52   int count = 0;
53   int i;
54
55   hd = keydb_new (0);
56   if (!hd)
57     {
58       log_error ("keydb_new failed\n");
59       goto leave;
60     }
61
62   if (!names)
63     ndesc = 1;
64   else
65     {
66       for (sl=names, ndesc=0; sl; sl = sl->next, ndesc++) 
67         ;
68     }
69
70   desc = xtrycalloc (ndesc, sizeof *desc);
71   if (!ndesc)
72     {
73       log_error ("%s\n", gnupg_strerror (GNUPG_Out_Of_Core));
74       goto leave;
75     }
76
77   if (!names)
78     desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
79   else 
80     {
81       for (ndesc=0, sl=names; sl; sl = sl->next) 
82         {
83           rc = keydb_classify_name (sl->d, desc+ndesc);
84           if (rc)
85             {
86               log_error ("key `%s' not found: %s\n",
87                          sl->d, gnupg_strerror (rc));
88               rc = 0;
89             }
90           else
91             ndesc++;
92         }
93     }
94
95   /* If all specifications are done by fingerprint, we switch to
96      ephemeral mode so that _all_ currently available and matching
97      certificates are exported. 
98
99      fixme: we should in this case keep a list of certificates to
100      avoid accidential export of duplicate certificates. */
101   if (names && ndesc)
102     {
103       for (i=0; (i < ndesc
104                  && (desc[i].mode == KEYDB_SEARCH_MODE_FPR
105                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR20
106                      || desc[i].mode == KEYDB_SEARCH_MODE_FPR16)); i++)
107         ;
108       if (i == ndesc)
109         keydb_set_ephemeral (hd, 1);
110     }
111       
112   while (!(rc = keydb_search (hd, desc, ndesc)))
113     {
114       const unsigned char *image;
115       size_t imagelen;
116
117       if (!names) 
118         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
119
120       rc = keydb_get_cert (hd, &cert);
121       if (rc) 
122         {
123           log_error ("keydb_get_cert failed: %s\n", gnupg_strerror (rc));
124           goto leave;
125         }
126
127       image = ksba_cert_get_image (cert, &imagelen);
128       if (!image)
129         {
130           log_error ("ksba_cert_get_image failed\n");
131           goto leave;
132         }
133
134       if (ctrl->create_pem)
135         {
136           if (count)
137             putc ('\n', fp);
138           print_short_info (cert, fp);
139           putc ('\n', fp);
140         }
141       count++;
142
143       if (!b64writer)
144         {
145           ctrl->pem_name = "CERTIFICATE";
146           rc = gpgsm_create_writer (&b64writer, ctrl, fp, &writer);
147           if (rc)
148             {
149               log_error ("can't create writer: %s\n", gnupg_strerror (rc));
150               goto leave;
151             }
152         }
153
154       rc = ksba_writer_write (writer, image, imagelen);
155       if (rc)
156         {
157           log_error ("write error: %s\n", ksba_strerror (rc));
158           goto leave;
159         }
160
161       if (ctrl->create_pem)
162         {
163           /* We want one certificate per PEM block */
164           rc = gpgsm_finish_writer (b64writer);
165           if (rc) 
166             {
167               log_error ("write failed: %s\n", gnupg_strerror (rc));
168               goto leave;
169             }
170           gpgsm_destroy_writer (b64writer);
171           b64writer = NULL;
172         }
173       
174       ksba_cert_release (cert); 
175       cert = NULL;
176     }
177   if (rc && rc != -1)
178     log_error ("keydb_search failed: %s\n", gnupg_strerror (rc));
179   else if (b64writer)
180     {
181       rc = gpgsm_finish_writer (b64writer);
182       if (rc) 
183         {
184           log_error ("write failed: %s\n", gnupg_strerror (rc));
185           goto leave;
186         }
187     }
188   
189  leave:
190   gpgsm_destroy_writer (b64writer);
191   ksba_cert_release (cert);
192   xfree (desc);
193   keydb_release (hd);
194 }
195
196
197 /* Print some info about the certifciate CERT to FP */
198 static void
199 print_short_info (KsbaCert cert, FILE *fp)
200 {
201   char *p;
202   KsbaSexp sexp;
203   int idx;
204
205   for (idx=0; (p = ksba_cert_get_issuer (cert, idx)); idx++)
206     {
207       fputs (!idx?   "Issuer ...: "
208                  : "\n   aka ...: ", fp); 
209       gpgsm_print_name (fp, p);
210       xfree (p);
211     }
212   putc ('\n', fp);
213
214   fputs ("Serial ...: ", fp); 
215   sexp = ksba_cert_get_serial (cert);
216   if (sexp)
217     {
218       int len;
219       const unsigned char *s = sexp;
220       
221       if (*s == '(')
222         {
223           s++;
224           for (len=0; *s && *s != ':' && digitp (s); s++)
225             len = len*10 + atoi_1 (s);
226           if (*s == ':')
227             for (s++; len; len--, s++)
228               fprintf (fp, "%02X", *s);
229         }
230       xfree (sexp);
231     }
232   putc ('\n', fp);
233
234   for (idx=0; (p = ksba_cert_get_subject (cert, idx)); idx++)
235     {
236       fputs (!idx?   "Subject ..: "
237                  : "\n    aka ..: ", fp); 
238       gpgsm_print_name (fp, p);
239       xfree (p);
240     }
241   putc ('\n', fp);
242 }
243
244
245
246
247
248