2003-01-19 Miguel Coca <mcoca@gnu.org>
[gpgme.git] / gpgme / genkey.c
1 /* genkey.c - Key generation.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002 g10 Code GmbH
4
5    This file is part of GPGME.
6  
7    GPGME is free software; you can redistribute it and/or modify it
8    under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11  
12    GPGME is distributed in the hope that it will be useful, but
13    WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    General Public License for more details.
16  
17    You should have received a copy of the GNU General Public License
18    along with GPGME; if not, write to the Free Software Foundation,
19    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
21 #if HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28
29 #include "util.h"
30 #include "context.h"
31 #include "ops.h"
32
33
34 struct genkey_result_s
35 {
36   int created_primary : 1;
37   int created_sub : 1;
38   char *fpr;
39 };
40
41
42 void
43 _gpgme_release_genkey_result (GenKeyResult result)
44 {
45   if (!result)
46     return;
47   if (result->fpr)
48     free (result->fpr);
49   free (result);
50 }
51
52
53 static void
54 genkey_status_handler (GpgmeCtx ctx, GpgmeStatusCode code, char *args)
55 {
56   _gpgme_progress_status_handler (ctx, code, args);
57
58   if (ctx->error)
59     return;
60   test_and_allocate_result (ctx, genkey);
61
62   switch (code)
63     {
64     case GPGME_STATUS_KEY_CREATED:
65       if (args && *args)
66         {
67           if (*args == 'B' || *args == 'P')
68             ctx->result.genkey->created_primary = 1;
69           if (*args == 'B' || *args == 'S')
70             ctx->result.genkey->created_sub = 1;
71           if (args[1] == ' ')
72             {
73               if (ctx->result.genkey->fpr)
74                 free (ctx->result.genkey->fpr);
75               ctx->result.genkey->fpr = strdup (&args[2]);
76               if (!ctx->result.genkey->fpr)
77                 ctx->error = mk_error (Out_Of_Core);
78             }
79         }
80       break;
81
82     case GPGME_STATUS_EOF:
83       /* FIXME: Should return some more useful error value.  */
84       if (!ctx->result.genkey->created_primary
85           && !ctx->result.genkey->created_sub)
86         ctx->error = mk_error (General_Error);
87       break;
88
89     default:
90       break;
91     }
92 }
93
94
95 static GpgmeError
96 _gpgme_op_genkey_start (GpgmeCtx ctx, int synchronous, const char *parms,
97                         GpgmeData pubkey, GpgmeData seckey)
98 {
99   int err = 0;
100   const char *s, *s2, *sx;
101
102   err = _gpgme_op_reset (ctx, synchronous);
103   if (err)
104     goto leave;
105
106   gpgme_data_release (ctx->help_data_1);
107   ctx->help_data_1 = NULL;
108
109   if ((parms = strstr (parms, "<GnupgKeyParms ")) 
110       && (s = strchr (parms, '>'))
111       && (sx = strstr (parms, "format=\"internal\""))
112       && sx < s
113       && (s2 = strstr (s+1, "</GnupgKeyParms>")))
114     {
115       /* FIXME: Check that there are no control statements inside.  */
116       s++;  /* Skip '>'.  */
117       while (*s == '\n')
118         s++;
119       err = gpgme_data_new_from_mem (&ctx->help_data_1, s, s2-s, 1);
120     }
121   else 
122     err = mk_error (Invalid_Value);
123
124   if (err)
125     goto leave;
126
127   _gpgme_engine_set_status_handler (ctx->engine, genkey_status_handler, ctx);
128   _gpgme_engine_set_verbosity (ctx->engine, ctx->verbosity);
129
130   err = _gpgme_engine_op_genkey (ctx->engine, ctx->help_data_1, ctx->use_armor,
131                                  pubkey, seckey);
132
133  leave:
134   if (err)
135     {
136       ctx->pending = 0; 
137       _gpgme_engine_release (ctx->engine);
138       ctx->engine = NULL;
139     }
140   return err;
141 }
142
143
144 /**
145  * gpgme_op_genkey:
146  * @c: the context
147  * @parms: XML string with the key parameters
148  * @pubkey: Returns the public key
149  * @seckey: Returns the secret key
150  * 
151  * Generate a new key and store the key in the default keyrings if
152  * both @pubkey and @seckey are NULL.  If @pubkey and @seckey are
153  * given, the newly created key will be returned in these data
154  * objects.  This function just starts the gheneration and does not
155  * wait for completion.
156  *
157  * Here is an example on how @parms should be formatted; for deatils
158  * see the file doc/DETAILS from the GnuPG distribution.
159  *
160  * <literal>
161  * <![CDATA[
162  * <GnupgKeyParms format="internal">
163  * Key-Type: DSA
164  * Key-Length: 1024
165  * Subkey-Type: ELG-E
166  * Subkey-Length: 1024
167  * Name-Real: Joe Tester
168  * Name-Comment: with stupid passphrase
169  * Name-Email: joe@foo.bar
170  * Expire-Date: 0
171  * Passphrase: abc
172  * </GnupgKeyParms>
173  * ]]>
174  * </literal> 
175  *
176  * Strings should be given in UTF-8 encoding.  The format we support
177  * for now is only "internal".  The content of the
178  * &lt;GnupgKeyParms&gt; container is passed verbatim to GnuPG.
179  * Control statements are not allowed.
180  * 
181  * Return value: 0 for success or an error code
182  **/
183 GpgmeError
184 gpgme_op_genkey_start (GpgmeCtx ctx, const char *parms,
185                        GpgmeData pubkey, GpgmeData seckey)
186 {
187   return _gpgme_op_genkey_start (ctx, 0, parms, pubkey, seckey);
188 }
189
190
191 /**
192  * gpgme_op_genkey:
193  * @c: the context
194  * @parms: XML string with the key parameters
195  * @pubkey: Returns the public key
196  * @seckey: Returns the secret key
197  * @fpr: Returns the fingerprint of the key.
198  *
199  * Generate a new key and store the key in the default keyrings if both
200  * @pubkey and @seckey are NULL.  If @pubkey and @seckey are given, the newly
201  * created key will be returned in these data objects.
202  * See gpgme_op_genkey_start() for a description of @parms.
203  * 
204  * Return value: 0 for success or an error code
205  **/
206 GpgmeError
207 gpgme_op_genkey (GpgmeCtx ctx, const char *parms,
208                  GpgmeData pubkey, GpgmeData seckey,
209                  char **fpr)
210 {
211   GpgmeError err = _gpgme_op_genkey_start (ctx, 1, parms, pubkey, seckey);
212   if (!err)
213     err = _gpgme_wait_one (ctx);
214   if (!err && fpr)
215     {
216       if (ctx->result.genkey->fpr)
217         {
218           *fpr = strdup (ctx->result.genkey->fpr);
219           if (!*fpr)
220             return mk_error (Out_Of_Core);
221         }
222       else
223         *fpr = NULL;
224     }
225   return err;
226 }