trunk/MyGPGME/delete.c

/* delete.c -  delete a key 
 *      Copyright (C) 2001 Werner Koch (dd9jn), g10 Code GmbH
 *      Copyright (C) 2001-2005 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 <stdlib.h>
#include <string.h>
#include <time.h>
#include <assert.h>

#include "util.h"
#include "context.h"
#include "ops.h"
#include "key.h"


enum delete_problem {
    No_Such_Key         = 1,
    Delete_Seckey_First = 2,
    Ambigiuous_Specs    = 3
};


static void
delete_status_handler (gpgme_ctx_t ctx, gpg_status_code_t code, char * args)
{
    if (ctx->out_of_core)
        return;
    
    switch (code) {
    case STATUS_EOF:        
        break;
        
    case STATUS_DELETE_PROBLEM:
        ctx->problem = atol (args);
        break;
        
    default:        
        break; /* ignore all other codes */
    }
} /* delete_status_handler */


static const char *
delete_command_handler (void * opaque, gpg_status_code_t code, const char * key)
{
    gpgme_ctx_t ctx = opaque;
    
    if( !code )
        return NULL;
    
    if (code == STATUS_GET_BOOL && !strcmp ("delete_key.secret.okay", key)
        || code == STATUS_GET_BOOL && !strcmp ("delete_key.okay", key))
        return "Y";
    
    return NULL;
} /* delete_command_handler */


static gpgme_error_t
delete_start (gpgme_ctx_t ctx, const gpgme_key_t key, 
              const char *pattern, int allow_secret)
{
    gpgme_error_t rc = 0;
    const char *s;
    
    if (!key && !pattern) {
        rc = mk_error (Invalid_Value);
        goto leave;
    }

    fail_on_pending_request (ctx);
    ctx->pending = 1;

    _gpgme_gpg_release (&ctx->gpg);
    rc = _gpgme_gpg_new (&ctx->gpg);
    if( rc )
        goto leave;
    
    _gpgme_gpg_set_status_handler ( ctx->gpg, delete_status_handler, ctx );
    _gpgme_gpg_set_command_handler( ctx->gpg, delete_command_handler, ctx );
    if( ctx->use_logging )
        _gpgme_gpg_set_logging_handler( ctx->gpg, ctx );
    
    /* build the commandline */
    _gpgme_gpg_add_arg ( ctx->gpg, allow_secret? 
                         "--delete-secret-and-public-key" : "--delete-key" );
    
    _gpgme_gpg_add_arg ( ctx->gpg, "--" );
    if (key != NULL) {
        s = gpgme_key_get_string_attr (key, GPGME_ATTR_KEYID, NULL, 0);
        if(!s) {
            rc = mk_error (Invalid_Key);
            goto leave;
        }
    }
    else
        s = pattern;
    _gpgme_gpg_add_arg (ctx->gpg, s);
    rc = _gpgme_gpg_spawn( ctx->gpg, ctx ); /* do it */

leave:
    if( rc ) {
        ctx->pending = 0; 
        _gpgme_gpg_release( &ctx->gpg );
    }
    return rc;
} /* delete_start */


static gpgme_error_t
get_delete_result (gpgme_ctx_t ctx)
{
    gpgme_error_t err = 0;

    if (ctx->problem == No_Such_Key)
        err = mk_error (Invalid_Key);
    else if (ctx->problem == Delete_Seckey_First)
        err = mk_error( Conflict );
    else if (gpgme_get_process_rc (ctx))
        err = mk_error (General_Error);
    return err;
}


gpgme_error_t
gpgme_op_delete (gpgme_ctx_t ctx, const gpgme_key_t key, int allow_secret)
{
    gpgme_error_t err;
    
    err = delete_start (ctx, key, NULL, allow_secret);
    if (!err) {
        gpgme_wait (ctx, 1);
        ctx->pending = 0;
        err = get_delete_result (ctx);
    }
    return err;
} /* gpgme_op_delete */


/* interface */
gpgme_error_t
gpgme_op_delete_key (const char *keyid, int allow_secret)
{
    gpgme_error_t err = 0;
    gpgme_key_t key = NULL;
    gpgme_ctx_t ctx;

    if (!keyid)
        return mk_error (Invalid_Value);
    
    err = gpgme_new(&ctx);
    if (!err)
        key = _gpgme_key_new_fromkeyid (keyid);
    if (!err && key)
        err = gpgme_op_delete (ctx, key, allow_secret);

    gpgme_release (ctx);
    gpgme_key_release (key);
    return err;
} /* gpgme_op_key_delete */


gpgme_error_t
gpgme_op_delete_keys (gpgme_recipients_t recp, int allow_secret)
{       
    gpgme_error_t err;
    gpgme_ctx_t ctx;
    struct user_id_s * u;
    char *list;
    size_t n=0;
    
    if (!recp)
        return mk_error (Invalid_Value);

    for  (u=recp->list; u; u=u->next)
        n += strlen (u->name) + 1 + 2;
    list = calloc (1, n+1);
    if (!list)
        mk_error (Out_Of_Core);

    for (u = recp->list; u; u = u->next) {
        strcat (list, u->name);
        strcat (list, " ");
    }

    /*DEBUG1 ("delete_keys: '%s'\r\n", list);*/
    err = gpgme_new (&ctx);
    if (err)
        return err;
    err = delete_start (ctx, NULL, list, allow_secret);
    if (!err) {
        gpgme_wait (ctx, 1);
        ctx->pending = 0;
        err = get_delete_result (ctx);
    }
    
    gpgme_release (ctx);
    safe_free (list);
    return err;
} /* gpgme_op_delete_keys */
1	/* delete.c - delete a key
2	* Copyright (C) 2001 Werner Koch (dd9jn), g10 Code GmbH
3	* Copyright (C) 2001-2005 Timo Schulz
4	*
5	* This file is part of MyGPGME.
6	*
7	* MyGPGME is free software; you can redistribute it and/or modify
8	* it 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	* MyGPGME is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20	*/
21
22	#include <stdio.h>
23	#include <stdlib.h>
24	#include <string.h>
25	#include <time.h>
26	#include <assert.h>
27
28	#include "util.h"
29	#include "context.h"
30	#include "ops.h"
31	#include "key.h"
32
33
34	enum delete_problem {
35	No_Such_Key = 1,
36	Delete_Seckey_First = 2,
37	Ambigiuous_Specs = 3
38	};
39
40
41	static void
42	delete_status_handler (gpgme_ctx_t ctx, gpg_status_code_t code, char * args)
43	{
44	if (ctx->out_of_core)
45	return;
46
47	switch (code) {
48	case STATUS_EOF:
49	break;
50
51	case STATUS_DELETE_PROBLEM:
52	ctx->problem = atol (args);
53	break;
54
55	default:
56	break; /* ignore all other codes */
57	}
58	} /* delete_status_handler */
59
60
61	static const char *
62	delete_command_handler (void * opaque, gpg_status_code_t code, const char * key)
63	{
64	gpgme_ctx_t ctx = opaque;
65
66	if( !code )
67	return NULL;
68
69	if (code == STATUS_GET_BOOL && !strcmp ("delete_key.secret.okay", key)
70	\|\| code == STATUS_GET_BOOL && !strcmp ("delete_key.okay", key))
71	return "Y";
72
73	return NULL;
74	} /* delete_command_handler */
75
76
77	static gpgme_error_t
78	delete_start (gpgme_ctx_t ctx, const gpgme_key_t key,
79	const char *pattern, int allow_secret)
80	{
81	gpgme_error_t rc = 0;
82	const char *s;
83
84	if (!key && !pattern) {
85	rc = mk_error (Invalid_Value);
86	goto leave;
87	}
88
89	fail_on_pending_request (ctx);
90	ctx->pending = 1;
91
92	_gpgme_gpg_release (&ctx->gpg);
93	rc = _gpgme_gpg_new (&ctx->gpg);
94	if( rc )
95	goto leave;
96
97	_gpgme_gpg_set_status_handler ( ctx->gpg, delete_status_handler, ctx );
98	_gpgme_gpg_set_command_handler( ctx->gpg, delete_command_handler, ctx );
99	if( ctx->use_logging )
100	_gpgme_gpg_set_logging_handler( ctx->gpg, ctx );
101
102	/* build the commandline */
103	_gpgme_gpg_add_arg ( ctx->gpg, allow_secret?
104	"--delete-secret-and-public-key" : "--delete-key" );
105
106	_gpgme_gpg_add_arg ( ctx->gpg, "--" );
107	if (key != NULL) {
108	s = gpgme_key_get_string_attr (key, GPGME_ATTR_KEYID, NULL, 0);
109	if(!s) {
110	rc = mk_error (Invalid_Key);
111	goto leave;
112	}
113	}
114	else
115	s = pattern;
116	_gpgme_gpg_add_arg (ctx->gpg, s);
117	rc = _gpgme_gpg_spawn( ctx->gpg, ctx ); /* do it */
118
119	leave:
120	if( rc ) {
121	ctx->pending = 0;
122	_gpgme_gpg_release( &ctx->gpg );
123	}
124	return rc;
125	} /* delete_start */
126
127
128	static gpgme_error_t
129	get_delete_result (gpgme_ctx_t ctx)
130	{
131	gpgme_error_t err = 0;
132
133	if (ctx->problem == No_Such_Key)
134	err = mk_error (Invalid_Key);
135	else if (ctx->problem == Delete_Seckey_First)
136	err = mk_error( Conflict );
137	else if (gpgme_get_process_rc (ctx))
138	err = mk_error (General_Error);
139	return err;
140	}
141
142
143	gpgme_error_t
144	gpgme_op_delete (gpgme_ctx_t ctx, const gpgme_key_t key, int allow_secret)
145	{
146	gpgme_error_t err;
147
148	err = delete_start (ctx, key, NULL, allow_secret);
149	if (!err) {
150	gpgme_wait (ctx, 1);
151	ctx->pending = 0;
152	err = get_delete_result (ctx);
153	}
154	return err;
155	} /* gpgme_op_delete */
156
157
158	/* interface */
159	gpgme_error_t
160	gpgme_op_delete_key (const char *keyid, int allow_secret)
161	{
162	gpgme_error_t err = 0;
163	gpgme_key_t key = NULL;
164	gpgme_ctx_t ctx;
165
166	if (!keyid)
167	return mk_error (Invalid_Value);
168
169	err = gpgme_new(&ctx);
170	if (!err)
171	key = _gpgme_key_new_fromkeyid (keyid);
172	if (!err && key)
173	err = gpgme_op_delete (ctx, key, allow_secret);
174
175	gpgme_release (ctx);
176	gpgme_key_release (key);
177	return err;
178	} /* gpgme_op_key_delete */
179
180
181	gpgme_error_t
182	gpgme_op_delete_keys (gpgme_recipients_t recp, int allow_secret)
183	{
184	gpgme_error_t err;
185	gpgme_ctx_t ctx;
186	struct user_id_s * u;
187	char *list;
188	size_t n=0;
189
190	if (!recp)
191	return mk_error (Invalid_Value);
192
193	for (u=recp->list; u; u=u->next)
194	n += strlen (u->name) + 1 + 2;
195	list = calloc (1, n+1);
196	if (!list)
197	mk_error (Out_Of_Core);
198
199	for (u = recp->list; u; u = u->next) {
200	strcat (list, u->name);
201	strcat (list, " ");
202	}
203
204	/DEBUG1 ("delete_keys: '%s'\r\n", list);/
205	err = gpgme_new (&ctx);
206	if (err)
207	return err;
208	err = delete_start (ctx, NULL, list, allow_secret);
209	if (!err) {
210	gpgme_wait (ctx, 1);
211	ctx->pending = 0;
212	err = get_delete_result (ctx);
213	}
214
215	gpgme_release (ctx);
216	safe_free (list);
217	return err;
218	} /* gpgme_op_delete_keys */