doc/
[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   if (!err)
134     err = _gpgme_engine_start (ctx->engine, ctx);
135
136  leave:
137   if (err)
138     {
139       ctx->pending = 0; 
140       _gpgme_engine_release (ctx->engine);
141       ctx->engine = NULL;
142     }
143   return err;
144 }
145
146
147 /**
148  * gpgme_op_genkey:
149  * @c: the context
150  * @parms: XML string with the key parameters
151  * @pubkey: Returns the public key
152  * @seckey: Returns the secret key
153  * 
154  * Generate a new key and store the key in the default keyrings if
155  * both @pubkey and @seckey are NULL.  If @pubkey and @seckey are
156  * given, the newly created key will be returned in these data
157  * objects.  This function just starts the gheneration and does not
158  * wait for completion.
159  *
160  * Here is an example on how @parms should be formatted; for deatils
161  * see the file doc/DETAILS from the GnuPG distribution.
162  *
163  * <literal>
164  * <![CDATA[
165  * <GnupgKeyParms format="internal">
166  * Key-Type: DSA
167  * Key-Length: 1024
168  * Subkey-Type: ELG-E
169  * Subkey-Length: 1024
170  * Name-Real: Joe Tester
171  * Name-Comment: with stupid passphrase
172  * Name-Email: joe@foo.bar
173  * Expire-Date: 0
174  * Passphrase: abc
175  * </GnupgKeyParms>
176  * ]]>
177  * </literal> 
178  *
179  * Strings should be given in UTF-8 encoding.  The format we support
180  * for now is only "internal".  The content of the
181  * &lt;GnupgKeyParms&gt; container is passed verbatim to GnuPG.
182  * Control statements are not allowed.
183  * 
184  * Return value: 0 for success or an error code
185  **/
186 GpgmeError
187 gpgme_op_genkey_start (GpgmeCtx ctx, const char *parms,
188                        GpgmeData pubkey, GpgmeData seckey)
189 {
190   return _gpgme_op_genkey_start (ctx, 0, parms, pubkey, seckey);
191 }
192
193
194 /**
195  * gpgme_op_genkey:
196  * @c: the context
197  * @parms: XML string with the key parameters
198  * @pubkey: Returns the public key
199  * @seckey: Returns the secret key
200  * @fpr: Returns the fingerprint of the key.
201  *
202  * Generate a new key and store the key in the default keyrings if both
203  * @pubkey and @seckey are NULL.  If @pubkey and @seckey are given, the newly
204  * created key will be returned in these data objects.
205  * See gpgme_op_genkey_start() for a description of @parms.
206  * 
207  * Return value: 0 for success or an error code
208  **/
209 GpgmeError
210 gpgme_op_genkey (GpgmeCtx ctx, const char *parms,
211                  GpgmeData pubkey, GpgmeData seckey,
212                  char **fpr)
213 {
214   GpgmeError err = _gpgme_op_genkey_start (ctx, 1, parms, pubkey, seckey);
215   if (!err)
216     err = _gpgme_wait_one (ctx);
217   if (!err && fpr)
218     {
219       if (ctx->result.genkey->fpr)
220         {
221           *fpr = strdup (ctx->result.genkey->fpr);
222           if (!*fpr)
223             return mk_error (Out_Of_Core);
224         }
225       else
226         *fpr = NULL;
227     }
228   return err;
229 }