2004-06-23 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / genkey.c
1 /* genkey.c - Key generation.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003 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 <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27
28 #include "gpgme.h"
29 #include "context.h"
30 #include "ops.h"
31
32 \f
33 typedef struct
34 {
35   struct _gpgme_op_genkey_result result;
36
37   /* The key parameters passed to the crypto engine.  */
38   gpgme_data_t key_parameter;
39 } *op_data_t;
40
41
42 static void
43 release_op_data (void *hook)
44 {
45   op_data_t opd = (op_data_t) hook;
46   
47   if (opd->result.fpr)
48     free (opd->result.fpr);
49   if (opd->key_parameter)
50     gpgme_data_release (opd->key_parameter);
51 }
52
53
54 gpgme_genkey_result_t
55 gpgme_op_genkey_result (gpgme_ctx_t ctx)
56 {
57   void *hook;
58   op_data_t opd;
59   gpgme_error_t err;
60
61   err = _gpgme_op_data_lookup (ctx, OPDATA_GENKEY, &hook, -1, NULL);
62   opd = hook;
63   if (err || !opd)
64     return NULL;
65
66   return &opd->result;
67 }
68
69 \f
70 static gpgme_error_t
71 genkey_status_handler (void *priv, gpgme_status_code_t code, char *args)
72 {
73   gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
74   gpgme_error_t err;
75   void *hook;
76   op_data_t opd;
77
78   /* Pipe the status code through the progress status handler.  */
79   err = _gpgme_progress_status_handler (ctx, code, args);
80   if (err)
81     return err;
82
83   err = _gpgme_op_data_lookup (ctx, OPDATA_GENKEY, &hook, -1, NULL);
84   opd = hook;
85   if (err)
86     return err;
87
88   switch (code)
89     {
90     case GPGME_STATUS_KEY_CREATED:
91       if (args && *args)
92         {
93           if (*args == 'B' || *args == 'P')
94             opd->result.primary = 1;
95           if (*args == 'B' || *args == 'S')
96             opd->result.sub = 1;
97           if (args[1] == ' ')
98             {
99               if (opd->result.fpr)
100                 free (opd->result.fpr);
101               opd->result.fpr = strdup (&args[2]);
102               if (!opd->result.fpr)
103                 return gpg_error_from_errno (errno);
104             }
105         }
106       break;
107
108     case GPGME_STATUS_EOF:
109       /* FIXME: Should return some more useful error value.  */
110       if (!opd->result.primary && !opd->result.sub)
111         return gpg_error (GPG_ERR_GENERAL);
112       break;
113
114     default:
115       break;
116     }
117   return 0;
118 }
119
120
121 static gpgme_error_t
122 get_key_parameter (const char *parms, gpgme_data_t *key_parameter)
123 {
124   const char *content;
125   const char *attrib;
126   const char *endtag;
127
128   /* Extract the key parameter from the XML structure.  */
129   parms = strstr (parms, "<GnupgKeyParms ");
130   if (!parms)
131     return gpg_error (GPG_ERR_INV_VALUE);
132
133   content = strchr (parms, '>');
134   if (!content)
135     return gpg_error (GPG_ERR_INV_VALUE);
136   content++;
137
138   attrib = strstr (parms, "format=\"internal\"");
139   if (!attrib || attrib >= content)
140     return gpg_error (GPG_ERR_INV_VALUE);
141
142   endtag = strstr (content, "</GnupgKeyParms>");
143   /* FIXME: Check that there are no control statements inside.  */
144   while (*content == '\n')
145     content++;
146
147   return gpgme_data_new_from_mem (key_parameter, content,
148                                   endtag - content, 1);
149 }
150
151
152 static gpgme_error_t
153 genkey_start (gpgme_ctx_t ctx, int synchronous, const char *parms,
154               gpgme_data_t pubkey, gpgme_data_t seckey)
155 {
156   gpgme_error_t err;
157   void *hook;
158   op_data_t opd;
159   err = _gpgme_op_reset (ctx, synchronous);
160   if (err)
161     return err;
162   
163   err = _gpgme_op_data_lookup (ctx, OPDATA_GENKEY, &hook,
164                                sizeof (*opd), release_op_data);
165   opd = hook;
166   if (err)
167     return err;
168
169   err = get_key_parameter (parms, &opd->key_parameter);
170   if (err)
171     return err;
172
173   _gpgme_engine_set_status_handler (ctx->engine, genkey_status_handler, ctx);
174
175   return _gpgme_engine_op_genkey (ctx->engine, opd->key_parameter,
176                                   ctx->use_armor, pubkey, seckey);
177 }
178
179
180 /* Generate a new keypair and add it to the keyring.  PUBKEY and
181    SECKEY should be null for now.  PARMS specifies what keys should be
182    generated.  */
183 gpgme_error_t
184 gpgme_op_genkey_start (gpgme_ctx_t ctx, const char *parms,
185                        gpgme_data_t pubkey, gpgme_data_t seckey)
186 {
187   return genkey_start (ctx, 0, parms, pubkey, seckey);
188 }
189
190
191 /* Generate a new keypair and add it to the keyring.  PUBKEY and
192    SECKEY should be null for now.  PARMS specifies what keys should be
193    generated.  */
194 gpgme_error_t
195 gpgme_op_genkey (gpgme_ctx_t ctx, const char *parms, gpgme_data_t pubkey,
196                  gpgme_data_t seckey)
197 {
198   gpgme_error_t err;
199
200   err = genkey_start (ctx, 1, parms, pubkey, seckey);
201   if (!err)
202     err = _gpgme_wait_one (ctx);
203   return err;
204 }