trunk/MyGPGME/editkey-util.c

/* editkey-util.c
 *      Copyright (C) 2001-2004 Timo Schulz
 *
 * This file is part of MyGPGME.
 *
 * MyGPGME is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * MyGPGME is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "gpgme-config.h"
#ifdef WITH_EDITKEY
#include "gpgme.h"
#include "context.h"
#include "ops.h"
#include "util.h"


gpgme_error_t
gpgme_editkey_new( gpgme_editkey_t * r_ctx )
{
    gpgme_editkey_t ctx;    
    
    if( !r_ctx )
        return mk_error( Invalid_Value );
    *r_ctx = NULL;
    ctx = calloc( 1, sizeof *ctx );
    if( !ctx )
        return mk_error( Out_Of_Core );
    *r_ctx = ctx;

    return 0;
} /* gpgme_editkey_new */


static void
revoke_release (gpgme_editkey_t ctx)
{
    safe_free (ctx->u.revoke.reason_text);
}


static void
adduid_release (gpgme_editkey_t ctx)
{
    safe_free (ctx->u.adduid.comment);
    safe_free (ctx->u.adduid.email);
    safe_free (ctx->u.adduid.name);
}


void
gpgme_editkey_release( gpgme_editkey_t ctx )
{
    if (!ctx)
        return;
    
    switch (ctx->type) {
        case GPGME_EDITKEY_REVOKE: revoke_release (ctx); break; 
        case GPGME_EDITKEY_ADDUID: adduid_release (ctx); break;
    }
    ctx->type = 0;
    safe_free (ctx);    
} /* gpgme_editkey_release */


/**
 * DELUID
 **/
void
gpgme_editkey_deluid_set_id (gpgme_editkey_t ctx, int id)
{
    if (!ctx)
        return;

    ctx->u.deluid.id = id;
    ctx->type = GPGME_EDITKEY_DELUID;
} /* gpgme_editkey_deluid_set_uid */

/**
 * DELKEY
 **/
void
gpgme_editkey_delkey_set_id( gpgme_editkey_t ctx, int id )
{
    if( !ctx )
        return;
    ctx->u.delkey.id = id;
    ctx->type = GPGME_EDITKEY_DELKEY;
} /* gpgme_editkey_delkey_set_id */


/* XXX: remove the passphrase in the _set functions and have a global
        function to set it. */

/**
 * ADDUID
 **/
void
gpgme_editkey_adduid_set( gpgme_editkey_t ctx, const char *name,
                           const char *email, const char *comment,
                            const char *passwd )
{       
    if( !ctx )
        return;
    
    /* name is a MUST field */
    ctx->u.adduid.name = strdup( name );
    ctx->u.adduid.email = strdup( email );
    if( !comment )
        ctx->u.adduid.use_comment = 0;
    else {
        ctx->u.adduid.comment = strdup( comment );
        ctx->u.adduid.use_comment = 1;
    }
    ctx->u.adduid.passwd = passwd;
    ctx->type = GPGME_EDITKEY_ADDUID; 
} /* gpgme_editkey_adduid_set */


gpgme_error_t
gpgme_editkey_addrev_set (gpgme_editkey_t ctx, const char * userid,
                          const char * passwd)
{
    if (!ctx)
        return mk_error (Invalid_Value);
    if (!userid)
        return mk_error (Invalid_Mode);
    ctx->u.addrev.passwd = passwd;
    ctx->u.addrev.uid = userid;
    ctx->type = GPGME_EDITKEY_ADDREV;
    return 0;
} /* gpgme_editkey_addrev_set */


void
gpgme_editkey_addphoto_set( gpgme_editkey_t ctx, const char *jpegfile,
                             const char * passwd )
{
    if( !ctx )
        return;
    ctx->u.addphoto.jpg = jpegfile;
    ctx->u.addphoto.passwd = passwd;
    ctx->type = GPGME_EDITKEY_ADDPHOTO;
} /* gpgme_editkey_addphoto_set */


/**
 * TRUST
 **/
void
gpgme_editkey_trust_set( gpgme_editkey_t ctx, int val )
{
    if( !ctx )
        return;
    
    switch( val ) {
    case 0: ctx->u.trust.trust_val = NULL; break;
    case GPGME_TRUST_DONTKNOW: ctx->u.trust.trust_val = "1"; break;
    case GPGME_TRUST_NEVER:    ctx->u.trust.trust_val = "2"; break;
    case GPGME_TRUST_MARGINAL: ctx->u.trust.trust_val = "3"; break;
    case GPGME_TRUST_FULLY:    ctx->u.trust.trust_val = "4";break;
    case GPGME_TRUST_ULTIMATE: ctx->u.trust.trust_val = "5"; break;
    default:                   ctx->u.trust.trust_val = "1"; break;
    }
    
    ctx->type = GPGME_EDITKEY_TRUST;
} /* gpgme_editkey_trust_set */

/**
 * SIGN
 **/
gpgme_error_t
gpgme_editkey_sign_set (gpgme_editkey_t ctx, 
                        const char * passwd, 
                        int sigclass,
                        int sigtype,
                        const char * param)
{
    if (!ctx)
        return mk_error (Invalid_Value);
    if (sigclass < 0 || sigclass > 3)
        return mk_error (Invalid_Mode);
    switch (sigtype) {
    case GPGME_EDITKEY_SIGN:
    case GPGME_EDITKEY_TSIGN:
    case GPGME_EDITKEY_NRSIGN:
    case GPGME_EDITKEY_NRLSIGN:
    case GPGME_EDITKEY_LSIGN:
        break;
    default:
        return mk_error (Invalid_Mode);
    }
    ctx->type = sigtype;
    ctx->u.sign.passwd = passwd;
    ctx->u.sign.sig_class = sigclass;
    ctx->u.sign.exp_date = param;

    return 0;
} /* gpgme_editkey_sign_set */

/**
 * ADDKEY
 **/
gpgme_error_t
gpgme_editkey_addkey_set (gpgme_editkey_t ctx, const char *passwd,
                          int algo, int size, int valid)
{
    if (!ctx)
        return mk_error (Invalid_Value);
    if (algo < 2 || algo > 6)
        return mk_error (Invalid_Mode);
    if (algo == 2 && size > 1024)
        size = 1024;
    if (size > 4096)
        size = 4096;
    
    ctx->u.addkey.algo = algo;
    ctx->u.addkey.size = size;
    ctx->u.addkey.valid = valid;
    ctx->u.addkey.passwd = passwd;
    ctx->type = GPGME_EDITKEY_ADDKEY;

    return 0;
} /* gpgme_editkey_addkey_set */


/**
 * PASSWD
 **/
void
gpgme_editkey_passwd_set( gpgme_editkey_t ctx, const char * old_passwd,
                          const char * new_passwd, int allow_empty )
{
    if( !ctx )
        return;
    if( old_passwd && new_passwd ) {
        ctx->u.passwd.old_passwd = old_passwd;    
        ctx->u.passwd.new_passwd = new_passwd;
    }
    else if( !old_passwd && new_passwd ) {
        /* this is the case when the key was unprotected before. then
           GPG only asks once for a passphrase. */
        ctx->u.passwd.old_passwd = new_passwd;
        ctx->u.passwd.new_passwd = NULL;
    }
    ctx->u.passwd.allow_empty = allow_empty;
    ctx->u.passwd.send_old = 0;
    ctx->type = GPGME_EDITKEY_PASSWD;
} /* gpgme_editkey_passwd_set */


/**
 * PRIMARY
 **/
void
gpgme_editkey_primary_set( gpgme_editkey_t ctx, int id, const char * passwd )
{
    if( !ctx )
        return;

    ctx->u.primary.id = id;
    ctx->u.primary.passwd = passwd;
    ctx->type = GPGME_EDITKEY_PRIMARY;
} /* gpgme_editkey_primary_set */


/**
 * EXPIRE 
 **/
void
gpgme_editkey_expire_set( gpgme_editkey_t ctx, int id, int days, const char *date,
                          const char *passwd )
{
    if( !ctx )
        return;
    ctx->u.expire.id = id;
    if( days && !date )
        ctx->u.expire.days = days;
    else if( date && !days ) {
        ctx->u.expire.date = date;
        ctx->u.expire.days = 0;
    }
    ctx->u.expire.passwd = passwd;
    ctx->type = GPGME_EDITKEY_EXPIRE;
} /* gpgme_editkey_expire_set */


/**
 * REVSIG
 **/
void 
gpgme_editkey_revsig_set( gpgme_editkey_t ctx, int id, const char *passwd )
{
    if( !ctx )
        return;
    ctx->u.revsig.id = id;
    ctx->u.revsig.passwd = passwd;
    ctx->type = GPGME_EDITKEY_REVSIG;
} /* gpgme_editkey_revsig_set */


/**
 * REVKEY
 **/
void
gpgme_editkey_revkey_set( gpgme_editkey_t ctx, int id, int reason, 
                          const char * passwd )
{
    if( !ctx )
        return;
    ctx->u.revkey.id = id;
    ctx->u.revkey.reason = reason;
    ctx->u.revkey.passwd = passwd;
    ctx->type = GPGME_EDITKEY_REVKEY;
}

/**
 * DELSIG
 **/
void
gpgme_editkey_delsig_set (gpgme_editkey_t ctx, int uid, int signo)
{
    if (!ctx)
        return;
    ctx->u.delsig.currno = 0;
    ctx->u.delsig.signo = signo;
    ctx->u.delsig.uid = uid;
    ctx->type = GPGME_EDITKEY_DELSIG;
}


/**
 * ENABLE
 **/
void
gpgme_editkey_enable_set( gpgme_editkey_t ctx )
{
    if( ctx )
        ctx->type = GPGME_EDITKEY_ENABLE;
}


/**
 * DISABLE
 **/
void
gpgme_editkey_disable_set( gpgme_editkey_t ctx )
{
    if( ctx )
        ctx->type = GPGME_EDITKEY_DISABLE;
}


/**
 * SETPREF
 **/
void 
gpgme_editkey_setpref_set (gpgme_editkey_t ctx, const char * new_prefs, 
                           int uid_idx, const char * passwd)
{
    if (!ctx)
        return;
    ctx->u.pref.id = 0;
    ctx->u.pref.uid_idx = uid_idx;
    ctx->u.pref.passwd = passwd;
    ctx->u.pref.new_prefs = new_prefs;
    ctx->type = GPGME_EDITKEY_SETPREF;
}


/**
 * KEYSERVER
 **/
void
gpgme_editkey_keyserver_set (gpgme_editkey_t ctx, const char *url,
                             int uid_idx, const char * passwd)
{
    if (!ctx)
        return;
    ctx->u.keyserv.uid_idx = uid_idx;
    ctx->u.keyserv.url = url;
    ctx->u.keyserv.passwd = passwd;
    ctx->type = GPGME_EDITKEY_KEYSERV;
}

void
gpgme_editkey_make_invalid (gpgme_editkey_t ctx)
{
    if( !ctx )
        return;
    ctx->type = 0;
} /* gpgme_editkey_make_invalid */


int
gpgme_editkey_is_valid( gpgme_editkey_t ctx )
{
    return ctx && ctx->type > 0 ? 1 : 0;
} /* gpgme_editkey_is_valid */


int
gpgme_editkey_is_secret( gpgme_editkey_t ctx, int val )
{
    if( ctx && val ) {
        ctx->key_pair = val;
        return 0;
    }
    return ctx && ctx->key_pair;
} /* gpgme_editkey_is_secret */
#endif /* WITH_EDITKEY */
1	twoaday	2	/* editkey-util.c
2			* Copyright (C) 2001-2004 Timo Schulz
3			*
4			* This file is part of MyGPGME.
5			*
6			* MyGPGME 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			* MyGPGME 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 <stdio.h>
22			#include <string.h>
23			#include <stdlib.h>
24
25			#include "gpgme-config.h"
26			#ifdef WITH_EDITKEY
27			#include "gpgme.h"
28			#include "context.h"
29			#include "ops.h"
30			#include "util.h"
31
32
33			gpgme_error_t
34			gpgme_editkey_new( gpgme_editkey_t * r_ctx )
35			{
36			gpgme_editkey_t ctx;
37
38			if( !r_ctx )
39			return mk_error( Invalid_Value );
40			*r_ctx = NULL;
41			ctx = calloc( 1, sizeof *ctx );
42			if( !ctx )
43			return mk_error( Out_Of_Core );
44			*r_ctx = ctx;
45
46			return 0;
47			} /* gpgme_editkey_new */
48
49
50			static void
51			revoke_release (gpgme_editkey_t ctx)
52			{
53			safe_free (ctx->u.revoke.reason_text);
54			}
55
56
57			static void
58			adduid_release (gpgme_editkey_t ctx)
59			{
60			safe_free (ctx->u.adduid.comment);
61			safe_free (ctx->u.adduid.email);
62			safe_free (ctx->u.adduid.name);
63			}
64
65
66			void
67			gpgme_editkey_release( gpgme_editkey_t ctx )
68			{
69			if (!ctx)
70			return;
71
72			switch (ctx->type) {
73			case GPGME_EDITKEY_REVOKE: revoke_release (ctx); break;
74			case GPGME_EDITKEY_ADDUID: adduid_release (ctx); break;
75			}
76			ctx->type = 0;
77			safe_free (ctx);
78			} /* gpgme_editkey_release */
79
80
81			/**
82			* DELUID
83			**/
84			void
85			gpgme_editkey_deluid_set_id (gpgme_editkey_t ctx, int id)
86			{
87			if (!ctx)
88			return;
89
90			ctx->u.deluid.id = id;
91			ctx->type = GPGME_EDITKEY_DELUID;
92			} /* gpgme_editkey_deluid_set_uid */
93
94			/**
95			* DELKEY
96			**/
97			void
98			gpgme_editkey_delkey_set_id( gpgme_editkey_t ctx, int id )
99			{
100			if( !ctx )
101			return;
102			ctx->u.delkey.id = id;
103			ctx->type = GPGME_EDITKEY_DELKEY;
104			} /* gpgme_editkey_delkey_set_id */
105
106
107	twoaday	21	/* XXX: remove the passphrase in the _set functions and have a global
108			function to set it. */
109
110	twoaday	2	/**
111			* ADDUID
112			**/
113			void
114			gpgme_editkey_adduid_set( gpgme_editkey_t ctx, const char *name,
115			const char email, const char comment,
116			const char *passwd )
117			{
118			if( !ctx )
119			return;
120
121			/* name is a MUST field */
122			ctx->u.adduid.name = strdup( name );
123			ctx->u.adduid.email = strdup( email );
124			if( !comment )
125			ctx->u.adduid.use_comment = 0;
126			else {
127			ctx->u.adduid.comment = strdup( comment );
128			ctx->u.adduid.use_comment = 1;
129			}
130			ctx->u.adduid.passwd = passwd;
131			ctx->type = GPGME_EDITKEY_ADDUID;
132			} /* gpgme_editkey_adduid_set */
133
134
135			gpgme_error_t
136			gpgme_editkey_addrev_set (gpgme_editkey_t ctx, const char * userid,
137			const char * passwd)
138			{
139			if (!ctx)
140			return mk_error (Invalid_Value);
141			if (!userid)
142			return mk_error (Invalid_Mode);
143			ctx->u.addrev.passwd = passwd;
144			ctx->u.addrev.uid = userid;
145			ctx->type = GPGME_EDITKEY_ADDREV;
146			return 0;
147			} /* gpgme_editkey_addrev_set */
148
149
150			void
151			gpgme_editkey_addphoto_set( gpgme_editkey_t ctx, const char *jpegfile,
152			const char * passwd )
153			{
154			if( !ctx )
155			return;
156			ctx->u.addphoto.jpg = jpegfile;
157			ctx->u.addphoto.passwd = passwd;
158			ctx->type = GPGME_EDITKEY_ADDPHOTO;
159			} /* gpgme_editkey_addphoto_set */
160
161
162			/**
163			* TRUST
164			**/
165			void
166			gpgme_editkey_trust_set( gpgme_editkey_t ctx, int val )
167			{
168			if( !ctx )
169			return;
170
171			switch( val ) {
172			case 0: ctx->u.trust.trust_val = NULL; break;
173			case GPGME_TRUST_DONTKNOW: ctx->u.trust.trust_val = "1"; break;
174			case GPGME_TRUST_NEVER: ctx->u.trust.trust_val = "2"; break;
175			case GPGME_TRUST_MARGINAL: ctx->u.trust.trust_val = "3"; break;
176			case GPGME_TRUST_FULLY: ctx->u.trust.trust_val = "4";break;
177			case GPGME_TRUST_ULTIMATE: ctx->u.trust.trust_val = "5"; break;
178			default: ctx->u.trust.trust_val = "1"; break;
179			}
180
181			ctx->type = GPGME_EDITKEY_TRUST;
182			} /* gpgme_editkey_trust_set */
183
184			/**
185			* SIGN
186			**/
187			gpgme_error_t
188			gpgme_editkey_sign_set (gpgme_editkey_t ctx,
189			const char * passwd,
190			int sigclass,
191			int sigtype,
192			const char * param)
193			{
194			if (!ctx)
195			return mk_error (Invalid_Value);
196			if (sigclass < 0 \|\| sigclass > 3)
197			return mk_error (Invalid_Mode);
198			switch (sigtype) {
199			case GPGME_EDITKEY_SIGN:
200			case GPGME_EDITKEY_TSIGN:
201			case GPGME_EDITKEY_NRSIGN:
202			case GPGME_EDITKEY_NRLSIGN:
203			case GPGME_EDITKEY_LSIGN:
204			break;
205			default:
206			return mk_error (Invalid_Mode);
207			}
208			ctx->type = sigtype;
209			ctx->u.sign.passwd = passwd;
210			ctx->u.sign.sig_class = sigclass;
211			ctx->u.sign.exp_date = param;
212
213			return 0;
214			} /* gpgme_editkey_sign_set */
215
216			/**
217			* ADDKEY
218			**/
219			gpgme_error_t
220			gpgme_editkey_addkey_set (gpgme_editkey_t ctx, const char *passwd,
221			int algo, int size, int valid)
222			{
223			if (!ctx)
224			return mk_error (Invalid_Value);
225			if (algo < 2 \|\| algo > 6)
226			return mk_error (Invalid_Mode);
227			if (algo == 2 && size > 1024)
228			size = 1024;
229			if (size > 4096)
230			size = 4096;
231
232			ctx->u.addkey.algo = algo;
233			ctx->u.addkey.size = size;
234			ctx->u.addkey.valid = valid;
235			ctx->u.addkey.passwd = passwd;
236			ctx->type = GPGME_EDITKEY_ADDKEY;
237
238			return 0;
239			} /* gpgme_editkey_addkey_set */
240
241
242			/**
243			* PASSWD
244			**/
245			void
246			gpgme_editkey_passwd_set( gpgme_editkey_t ctx, const char * old_passwd,
247			const char * new_passwd, int allow_empty )
248			{
249			if( !ctx )
250			return;
251			if( old_passwd && new_passwd ) {
252			ctx->u.passwd.old_passwd = old_passwd;
253			ctx->u.passwd.new_passwd = new_passwd;
254			}
255			else if( !old_passwd && new_passwd ) {
256			/* this is the case when the key was unprotected before. then
257			GPG only asks once for a passphrase. */
258			ctx->u.passwd.old_passwd = new_passwd;
259			ctx->u.passwd.new_passwd = NULL;
260			}
261			ctx->u.passwd.allow_empty = allow_empty;
262			ctx->u.passwd.send_old = 0;
263			ctx->type = GPGME_EDITKEY_PASSWD;
264			} /* gpgme_editkey_passwd_set */
265
266
267			/**
268			* PRIMARY
269			**/
270			void
271			gpgme_editkey_primary_set( gpgme_editkey_t ctx, int id, const char * passwd )
272			{
273			if( !ctx )
274			return;
275
276			ctx->u.primary.id = id;
277			ctx->u.primary.passwd = passwd;
278			ctx->type = GPGME_EDITKEY_PRIMARY;
279			} /* gpgme_editkey_primary_set */
280
281
282			/**
283			* EXPIRE
284			**/
285			void
286			gpgme_editkey_expire_set( gpgme_editkey_t ctx, int id, int days, const char *date,
287			const char *passwd )
288			{
289			if( !ctx )
290			return;
291			ctx->u.expire.id = id;
292			if( days && !date )
293			ctx->u.expire.days = days;
294			else if( date && !days ) {
295			ctx->u.expire.date = date;
296			ctx->u.expire.days = 0;
297			}
298			ctx->u.expire.passwd = passwd;
299			ctx->type = GPGME_EDITKEY_EXPIRE;
300			} /* gpgme_editkey_expire_set */
301
302
303			/**
304			* REVSIG
305			**/
306			void
307			gpgme_editkey_revsig_set( gpgme_editkey_t ctx, int id, const char *passwd )
308			{
309			if( !ctx )
310			return;
311			ctx->u.revsig.id = id;
312			ctx->u.revsig.passwd = passwd;
313			ctx->type = GPGME_EDITKEY_REVSIG;
314			} /* gpgme_editkey_revsig_set */
315
316
317			/**
318			* REVKEY
319			**/
320			void
321			gpgme_editkey_revkey_set( gpgme_editkey_t ctx, int id, int reason,
322			const char * passwd )
323			{
324			if( !ctx )
325			return;
326			ctx->u.revkey.id = id;
327			ctx->u.revkey.reason = reason;
328			ctx->u.revkey.passwd = passwd;
329			ctx->type = GPGME_EDITKEY_REVKEY;
330			}
331
332			/**
333			* DELSIG
334			**/
335			void
336			gpgme_editkey_delsig_set (gpgme_editkey_t ctx, int uid, int signo)
337			{
338			if (!ctx)
339			return;
340			ctx->u.delsig.currno = 0;
341			ctx->u.delsig.signo = signo;
342			ctx->u.delsig.uid = uid;
343			ctx->type = GPGME_EDITKEY_DELSIG;
344			}
345
346
347			/**
348			* ENABLE
349			**/
350			void
351			gpgme_editkey_enable_set( gpgme_editkey_t ctx )
352			{
353			if( ctx )
354			ctx->type = GPGME_EDITKEY_ENABLE;
355			}
356
357
358			/**
359			* DISABLE
360			**/
361			void
362			gpgme_editkey_disable_set( gpgme_editkey_t ctx )
363			{
364			if( ctx )
365			ctx->type = GPGME_EDITKEY_DISABLE;
366			}
367
368
369			/**
370			* SETPREF
371			**/
372			void
373			gpgme_editkey_setpref_set (gpgme_editkey_t ctx, const char * new_prefs,
374			int uid_idx, const char * passwd)
375			{
376			if (!ctx)
377			return;
378			ctx->u.pref.id = 0;
379			ctx->u.pref.uid_idx = uid_idx;
380			ctx->u.pref.passwd = passwd;
381			ctx->u.pref.new_prefs = new_prefs;
382			ctx->type = GPGME_EDITKEY_SETPREF;
383			}
384
385
386			/**
387			* KEYSERVER
388			**/
389			void
390			gpgme_editkey_keyserver_set (gpgme_editkey_t ctx, const char *url,
391	twoaday	21	int uid_idx, const char * passwd)
392	twoaday	2	{
393			if (!ctx)
394			return;
395	twoaday	21	ctx->u.keyserv.uid_idx = uid_idx;
396	twoaday	2	ctx->u.keyserv.url = url;
397			ctx->u.keyserv.passwd = passwd;
398			ctx->type = GPGME_EDITKEY_KEYSERV;
399			}
400
401			void
402	twoaday	21	gpgme_editkey_make_invalid (gpgme_editkey_t ctx)
403	twoaday	2	{
404			if( !ctx )
405			return;
406			ctx->type = 0;
407			} /* gpgme_editkey_make_invalid */
408
409
410			int
411			gpgme_editkey_is_valid( gpgme_editkey_t ctx )
412			{
413			return ctx && ctx->type > 0 ? 1 : 0;
414			} /* gpgme_editkey_is_valid */
415
416
417			int
418			gpgme_editkey_is_secret( gpgme_editkey_t ctx, int val )
419			{
420			if( ctx && val ) {
421			ctx->key_pair = val;
422			return 0;
423			}
424			return ctx && ctx->key_pair;
425			} /* gpgme_editkey_is_secret */
426			#endif /* WITH_EDITKEY */