Fix problems where the parser is used interactively, and continues to

	* daemon/pk/gkr-pk-cert.c:
	* daemon/pk/gkr-pk-import.c:
	* daemon/pk/gkr-pk-netscape-trust.c:
	* daemon/pk/gkr-pk-object-storage.c:
	* daemon/pk/gkr-pk-root-storage.c:
	* daemon/pkcs11/gkr-pkcs11-daemon-session.c:
	* daemon/pkix/gkr-pkix-parser.c:
	* daemon/pkix/gkr-pkix-parser.h:
	* daemon/pkix/gkr-pkix-types.h: 
	* daemon/pkix/tests/unit-test-pkix-parser.c:
	* daemon/pkix/tests/unit-test-pkix-serialize.c: Fix problems where
	the parser is used interactively, and continues to prompt the user
	after they've cancelled the operation.

svn path=/trunk/; revision=1230

12 files changed, 143 insertions, 54 deletions

diff --git a/ChangeLog b/ChangeLog
index 638b8307..07b9cffe 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,21 @@
 2008-08-09  Stef Walter  <stef@memberwebs.com>
 
+	* daemon/pk/gkr-pk-cert.c:
+	* daemon/pk/gkr-pk-import.c:
+	* daemon/pk/gkr-pk-netscape-trust.c:
+	* daemon/pk/gkr-pk-object-storage.c:
+	* daemon/pk/gkr-pk-root-storage.c:
+	* daemon/pkcs11/gkr-pkcs11-daemon-session.c:
+	* daemon/pkix/gkr-pkix-parser.c:
+	* daemon/pkix/gkr-pkix-parser.h:
+	* daemon/pkix/gkr-pkix-types.h: 
+	* daemon/pkix/tests/unit-test-pkix-parser.c:
+	* daemon/pkix/tests/unit-test-pkix-serialize.c: Fix problems where
+	the parser is used interactively, and continues to prompt the user
+	after they've cancelled the operation.
+	
+2008-08-09  Stef Walter  <stef@memberwebs.com>
+
 	* conifgure.in:
 	* Makefile.am:
 	* tool/gkr-tool.c: (added)
diff --git a/daemon/pk/gkr-pk-cert.c b/daemon/pk/gkr-pk-cert.c
index c83b009d..ac7c9db8 100644
--- a/daemon/pk/gkr-pk-cert.c
+++ b/daemon/pk/gkr-pk-cert.c
@@ -165,7 +165,8 @@ get_public_key (GkrPkCert *cert)
 	g_free (data);
 	
 	if (res != GKR_PKIX_SUCCESS) {
-		g_warning ("invalid public-key in certificate: %s", g_quark_to_string (obj->location));
+		if (res != GKR_PKIX_CANCELLED)
+			g_warning ("invalid public-key in certificate: %s", g_quark_to_string (obj->location));
 		return NULL;
 	}
 	
@@ -266,7 +267,8 @@ lookup_certificate_purposes (GkrPkCert *cert, GQuark **oids)
 		g_free (extension);
 	
 		if (res != GKR_PKIX_SUCCESS) {
-			g_warning ("invalid enhanced usage in certificate");
+			if (res != GKR_PKIX_CANCELLED)
+				g_warning ("invalid enhanced usage in certificate");
 			return CKR_GENERAL_ERROR;
 		}
 	}
@@ -475,6 +477,8 @@ gkr_pk_cert_get_attribute (GkrPkObject* obj, CK_ATTRIBUTE_PTR attr)
 
 			res = gkr_pkix_der_read_basic_constraints (data, n_data, &is_ca, NULL);
 			g_free (data);
+			if (res == GKR_PKIX_CANCELLED)
+				return CKR_FUNCTION_CANCELED;
 			if (res != GKR_PKIX_SUCCESS)
 				return CKR_FUNCTION_FAILED;
 			if (is_ca)
diff --git a/daemon/pk/gkr-pk-import.c b/daemon/pk/gkr-pk-import.c
index 882db54b..e7a304b3 100644
--- a/daemon/pk/gkr-pk-import.c
+++ b/daemon/pk/gkr-pk-import.c
@@ -144,7 +144,7 @@ parser_ask_password (GkrPkixParser *parser, GQuark loc, gkrconstid digest,
 {
 	GkrAskRequest *ask;
 	gchar *secondary;
-	gboolean ret;
+	gboolean ret = TRUE;
 	GkrPkIndex *index;
 	guint flags;
 	
@@ -168,7 +168,7 @@ parser_ask_password (GkrPkixParser *parser, GQuark loc, gkrconstid digest,
 		return TRUE;
 	}
 	
-	if (!label) 
+	if (!label || !label[0]) 
 		label = import->import_label;
 		
 	/* Build up the prompt */
@@ -245,14 +245,14 @@ process_parsed (GkrPkImport *import, GQuark location, gkrconstid digest,
 	if (!gkr_pk_object_has_label (object) && import->import_label)
 		g_object_set (object, "label", import->import_label, NULL);
 	
+	import->import_objects = g_slist_prepend (import->import_objects, object);
+	g_object_weak_ref (G_OBJECT (object), object_disappeared, import);
+
 	if (created) {
 		gkr_pk_storage_store (import->import_storage, object, &pv->error);
 		g_object_unref (object);
 	}
 	
-	import->import_objects = g_slist_prepend (import->import_objects, object);
-	g_object_weak_ref (G_OBJECT (object), object_disappeared, import);
-	
 	return TRUE;
 }
 
@@ -525,10 +525,14 @@ gkr_pk_import_create (GkrPkManager* manager, GkrPkSession *session,
 		g_object_unref (*object);
 		*object = NULL;
 
-		if (err->domain == GKR_PKIX_PARSE_ERROR)
-			ret = CKR_DATA_INVALID;
-		else
+		if (err->domain == GKR_PKIX_PARSE_ERROR) {
+			if (err->code == GKR_PKIX_CANCELLED)
+				ret = CKR_FUNCTION_CANCELED;
+			else
+				ret = CKR_DATA_INVALID;
+		} else {
 			ret = CKR_FUNCTION_FAILED;
+		}
 
 		g_message ("couldn't import data: %s", err && err->message ? err->message : "");
 		g_clear_error (&err);
@@ -559,7 +563,7 @@ gkr_pk_import_perform (GkrPkImport *import, const guchar *data, gsize n_data, GE
 	
  	g_return_val_if_fail (GKR_IS_PK_IMPORT (import), FALSE);
  	
-	parser = gkr_pkix_parser_new ();
+	parser = gkr_pkix_parser_new (TRUE);
 	g_signal_connect (parser, "parsed-asn1", G_CALLBACK (parser_parsed_asn1), import);
 	g_signal_connect (parser, "parsed-sexp", G_CALLBACK (parser_parsed_sexp), import);
  	g_signal_connect (parser, "ask-password", G_CALLBACK (parser_ask_password), import);
diff --git a/daemon/pk/gkr-pk-netscape-trust.c b/daemon/pk/gkr-pk-netscape-trust.c
index 547a1f84..072fe797 100644
--- a/daemon/pk/gkr-pk-netscape-trust.c
+++ b/daemon/pk/gkr-pk-netscape-trust.c
@@ -101,6 +101,8 @@ has_key_usage (GkrPkNetscapeTrust *trust, guint check, CK_ULONG *val)
 	res = gkr_pkix_der_read_key_usage (extension, n_extension, &usage);
 	g_free (extension);
 	
+	if (res != GKR_PKIX_CANCELLED)
+		return CKR_FUNCTION_CANCELED;
 	if (res != GKR_PKIX_SUCCESS) {
 		g_warning ("invalid key usage in certificate");
 		return CKR_GENERAL_ERROR;
diff --git a/daemon/pk/gkr-pk-object-storage.c b/daemon/pk/gkr-pk-object-storage.c
index e5269b91..99ccc5c3 100644
--- a/daemon/pk/gkr-pk-object-storage.c
+++ b/daemon/pk/gkr-pk-object-storage.c
@@ -244,7 +244,7 @@ load_objects_at_location (GkrPkObjectStorage *storage, GQuark loc, GError **err)
 	ctx.checks = gkr_pk_storage_checks_prepare (GKR_PK_STORAGE (storage), loc);
 
 	/* TODO: Try and use a shared parser? */
-	parser = gkr_pkix_parser_new ();
+	parser = gkr_pkix_parser_new (FALSE);
 	g_signal_connect (parser, "parsed-asn1", G_CALLBACK (parser_parsed_asn1), &ctx);
 	g_signal_connect (parser, "parsed-sexp", G_CALLBACK (parser_parsed_sexp), &ctx);
 	g_signal_connect (parser, "parsed-partial", G_CALLBACK (parser_parsed_partial), &ctx);
@@ -367,11 +367,11 @@ gkr_pk_object_storage_store (GkrPkStorage *stor, GkrPkObject *obj, GError **err)
 	if (gtype == GKR_TYPE_PK_PRIVKEY) {
 		type = GKR_PKIX_PRIVATE_KEY;
 		g_object_get (obj, "gcrypt-sexp", &what, NULL);
-	} else if (gtype == GKR_PKIX_PUBLIC_KEY) {
-		type = GKR_TYPE_PK_PUBKEY;
+	} else if (gtype == GKR_TYPE_PK_PUBKEY) {
+		type = GKR_PKIX_PUBLIC_KEY;
 		g_object_get (obj, "gcrypt-sexp", &what, NULL);
-	} else if (gtype == GKR_PKIX_CERTIFICATE) {
-		type = GKR_TYPE_PK_CERT;
+	} else if (gtype == GKR_TYPE_PK_CERT) {
+		type = GKR_PKIX_CERTIFICATE;
 		g_object_get (obj, "asn1-tree", &what, NULL);
 	} else {
 		g_return_val_if_reached (FALSE);
@@ -513,7 +513,7 @@ gkr_pk_object_storage_initialize (void)
 	GkrPkStorage *storage;
 	
 	storage = g_object_new (GKR_TYPE_PK_OBJECT_STORAGE, NULL);
-	gkr_pk_storage_register (storage, FALSE);
+	gkr_pk_storage_register (storage, TRUE);
 	g_object_unref (storage);
 	
 	return TRUE;
diff --git a/daemon/pk/gkr-pk-root-storage.c b/daemon/pk/gkr-pk-root-storage.c
index 39994d0b..9a5c22e9 100644
--- a/daemon/pk/gkr-pk-root-storage.c
+++ b/daemon/pk/gkr-pk-root-storage.c
@@ -141,7 +141,7 @@ storage_load_certificate (GkrPkRootStorage *storage, GQuark loc, GError **err)
 	ctx.checks = gkr_pk_storage_checks_prepare (GKR_PK_STORAGE (storage), loc);
 
 	/* TODO: Try and use a shared parser? */
-	parser = gkr_pkix_parser_new ();
+	parser = gkr_pkix_parser_new (FALSE);
 	g_signal_connect (parser, "parsed-asn1", G_CALLBACK (parser_parsed_asn1), &ctx);
 	ret = gkr_pkix_parser_parse_location (parser, loc, err);
 	g_object_unref (parser);
diff --git a/daemon/pkcs11/gkr-pkcs11-daemon-session.c b/daemon/pkcs11/gkr-pkcs11-daemon-session.c
index 49b24990..44d0ec86 100644
--- a/daemon/pkcs11/gkr-pkcs11-daemon-session.c
+++ b/daemon/pkcs11/gkr-pkcs11-daemon-session.c
@@ -421,7 +421,7 @@ session_C_CreateObject (SessionInfo *sinfo, GkrPkcs11Message *req,
                         GkrPkcs11Message *resp)
 {
 	CK_OBJECT_CLASS cls;
-	GkrPkObject *object;
+	GkrPkObject *object = NULL;
 	GArray *attrs = NULL;
 	CK_BBOOL token;
 	CK_RV ret;
@@ -466,7 +466,8 @@ session_C_CreateObject (SessionInfo *sinfo, GkrPkcs11Message *req,
 	ret = CKR_OK;
 	
 done:
-	g_object_unref (object);
+	if (object)
+		g_object_unref (object);
 	gkr_pk_attributes_free (attrs);
 	return ret;
 }
diff --git a/daemon/pkix/gkr-pkix-parser.c b/daemon/pkix/gkr-pkix-parser.c
index ed8b3be8..1f313451 100644
--- a/daemon/pkix/gkr-pkix-parser.c
+++ b/daemon/pkix/gkr-pkix-parser.c
@@ -122,6 +122,11 @@ typedef struct {
 } GkrPkixParserPrivate;
 
 enum {
+	PROP_0,
+	PROP_INTERACTIVE
+};
+
+enum {
 	PARSED_PARTIAL,
 	PARSED_SEXP,
 	PARSED_ASN1,
@@ -218,19 +223,22 @@ enum_next_password (GkrPkixParser *parser, GQuark loc, gkrid digest,
 	return FALSE;
 }
 
-static void
+static GkrPkixResult
 fire_parsed_partial (GkrPkixParser *parser, GQuark location, 
                      gkrconstid digest, GQuark type)
 {
 	gboolean owned = FALSE;
 	
-	g_assert (location);
+	g_assert (digest);
 	
-	if (!gkr_async_is_stopping ())
-		g_signal_emit (parser, signals[PARSED_PARTIAL], 0, location, digest, type, &owned);
+	if (gkr_async_is_stopping ())
+		return GKR_PKIX_CANCELLED;
+	
+	g_signal_emit (parser, signals[PARSED_PARTIAL], 0, location, digest, type, &owned);	
+	return GKR_PKIX_SUCCESS;
 }
 
-static void
+static GkrPkixResult
 fire_parsed_sexp (GkrPkixParser *parser, GQuark location, gkrconstid digest, 
                   GQuark type, gcry_sexp_t sexp)
 {
@@ -238,14 +246,19 @@ fire_parsed_sexp (GkrPkixParser *parser, GQuark location, gkrconstid digest,
 	
 	g_assert (sexp);
 	g_assert (type);
+	g_assert (digest);
+
+	if (gkr_async_is_stopping ())
+		return GKR_PKIX_CANCELLED;
 	
-	if (!gkr_async_is_stopping ())
-		g_signal_emit (parser, signals[PARSED_SEXP], 0, location, digest, type, sexp, &owned);
+	g_signal_emit (parser, signals[PARSED_SEXP], 0, location, digest, type, sexp, &owned);
 	if (!owned)
 		gcry_sexp_release (sexp);
+	
+	return GKR_PKIX_SUCCESS;	
 }
 
-static void
+static GkrPkixResult
 fire_parsed_asn1 (GkrPkixParser *parser, GQuark location, gkrconstid digest, 
                   GQuark type, ASN1_TYPE asn1)
 {
@@ -253,11 +266,16 @@ fire_parsed_asn1 (GkrPkixParser *parser, GQuark location, gkrconstid digest,
 	
 	g_assert (asn1);
 	g_assert (type);
-	
-	if (!gkr_async_is_stopping ())
-		g_signal_emit (parser, signals[PARSED_ASN1], 0, location, digest, type, asn1, &owned);
+	g_assert (digest);
+
+	if (gkr_async_is_stopping ())
+		return GKR_PKIX_CANCELLED;
+
+	g_signal_emit (parser, signals[PARSED_ASN1], 0, location, digest, type, asn1, &owned);
 	if (!owned)
 		asn1_delete_structure (&asn1);
+	
+	return GKR_PKIX_SUCCESS;
 }
 
 /* -----------------------------------------------------------------------------
@@ -271,6 +289,32 @@ gkr_pkix_parser_init (GkrPkixParser *parser)
 	pv->seen_passwords = NULL;	
 }
 
+static void
+gkr_pkix_parser_get_property (GObject *obj, guint prop_id, GValue *value, 
+                              GParamSpec *pspec)
+{
+	GkrPkixParser *parser = GKR_PKIX_PARSER (obj);
+
+	switch (prop_id) {
+	case PROP_INTERACTIVE:
+		g_value_set_boolean (value, parser->interactive);
+		break;
+	}
+}
+
+static void
+gkr_pkix_parser_set_property (GObject *obj, guint prop_id, const GValue *value, 
+                              GParamSpec *pspec)
+{
+	GkrPkixParser *parser = GKR_PKIX_PARSER (obj);
+	
+	switch (prop_id) {
+	case PROP_INTERACTIVE:
+		parser->interactive = g_value_get_boolean (value);
+		break;
+	};
+}
+
 static gboolean 
 gkr_pkix_parser_parsed_partial (GkrPkixParser *parser, GQuark loc, gkrconstid digest, 
                                 GQuark type)
@@ -333,6 +377,12 @@ gkr_pkix_parser_class_init (GkrPkixParserClass *klass)
 	klass->ask_password = gkr_pkix_parser_ask_password;
 	
 	gobject_class->finalize = gkr_pkix_parser_finalize;
+	gobject_class->get_property = gkr_pkix_parser_get_property;
+	gobject_class->set_property = gkr_pkix_parser_set_property;
+
+	g_object_class_install_property (gobject_class, PROP_INTERACTIVE,
+		g_param_spec_boolean ("interactive", "Interactive", "Is this parser acting upon user actions directly",
+		                      FALSE, G_PARAM_READWRITE));
 
 	signals[PARSED_PARTIAL] = g_signal_new ("parsed-partial", GKR_TYPE_PKIX_PARSER, 
 			G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GkrPkixParserClass, parsed_partial),
@@ -362,9 +412,9 @@ gkr_pkix_parser_class_init (GkrPkixParserClass *klass)
  */
 
 GkrPkixParser*
-gkr_pkix_parser_new (void)
+gkr_pkix_parser_new (gboolean interactive)
 {
-	return g_object_new (GKR_TYPE_PKIX_PARSER, NULL);
+	return g_object_new (GKR_TYPE_PKIX_PARSER, "interactive", interactive, NULL);
 }
 
 GQuark
@@ -398,6 +448,10 @@ gkr_pkix_parser_parse (GkrPkixParser *parser, GQuark loc, const guchar *data,
 		return TRUE;
 		
 	switch (ret) {
+	case GKR_PKIX_CANCELLED:
+		g_set_error (err, GKR_PKIX_PARSE_ERROR, ret, "%s",
+		             _("The operation was cancelled"));
+		return FALSE;
 	case GKR_PKIX_UNRECOGNIZED:
 		g_set_error (err, GKR_PKIX_PARSE_ERROR, ret, "%s",
 		             _("Unrecognized or unsupported file."));
@@ -509,7 +563,7 @@ gkr_pkix_parser_der_private_key (GkrPkixParser *parser, GQuark loc,
 	if (ret == GKR_PKIX_UNRECOGNIZED)
 		ret = gkr_pkix_der_read_private_key_dsa (data, n_data, &s_key);
 	if (ret == GKR_PKIX_SUCCESS)
-		fire_parsed_sexp (parser, loc, digest, GKR_PKIX_PRIVATE_KEY, s_key);
+		ret = fire_parsed_sexp (parser, loc, digest, GKR_PKIX_PRIVATE_KEY, s_key);
 		
 	gkr_id_free (digest);
 	
@@ -584,7 +638,7 @@ done:
 		};
 		
 		if (ret == GKR_PKIX_SUCCESS)
-			fire_parsed_sexp (parser, loc, digest, GKR_PKIX_PRIVATE_KEY, s_key);
+			ret = fire_parsed_sexp (parser, loc, digest, GKR_PKIX_PRIVATE_KEY, s_key);
 		
 	} else if (ret == GKR_PKIX_FAILURE) {
 		g_message ("invalid PKCS#8 key");
@@ -647,8 +701,10 @@ parse_der_pkcs8_encrypted (GkrPkixParser *parser, GQuark location,
 		
     	/* If no password is available, we still know it's a key, so 'partial' parse */
         if (!enum_next_password (parser, location, digest, GKR_PKIX_PRIVATE_KEY, NULL, &pstate, &password)) {
-        	fire_parsed_partial (parser, location, digest, GKR_PKIX_PRIVATE_KEY);
-        	ret = GKR_PKIX_SUCCESS;
+        	if (parser->interactive)
+        		ret = GKR_PKIX_CANCELLED;
+        	else 
+        		ret = fire_parsed_partial (parser, location, digest, GKR_PKIX_PRIVATE_KEY);
         	goto done; 
         }
 	        
@@ -752,7 +808,7 @@ gkr_pkix_parser_der_certificate (GkrPkixParser *parser, GQuark loc,
 
 	ret = gkr_pkix_der_read_certificate (data, n_data, &asn1);	
 	if(ret == GKR_PKIX_SUCCESS)
-		fire_parsed_asn1 (parser, loc, digest, GKR_PKIX_CERTIFICATE, asn1);
+		ret = fire_parsed_asn1 (parser, loc, digest, GKR_PKIX_CERTIFICATE, asn1);
 	gkr_id_free (digest);
 	
 	return ret;
@@ -793,7 +849,7 @@ parse_pkcs12_cert_bag (GkrPkixParser *parser, GQuark loc, gkrid digest, const gu
 	
 	ret = gkr_pkix_der_read_certificate (certificate, n_certificate, &casn);
 	if(ret == GKR_PKIX_SUCCESS)
-		fire_parsed_asn1 (parser, loc, digest, GKR_PKIX_CERTIFICATE, casn);
+		ret = fire_parsed_asn1 (parser, loc, digest, GKR_PKIX_CERTIFICATE, casn);
 		
 done:
 	if (asn)
@@ -862,7 +918,7 @@ parse_pkcs12_bag (GkrPkixParser *parser, GQuark loc, gkrid digest, const guchar
 			r = GKR_PKIX_UNRECOGNIZED;
 		}
 		 
-		if (r == GKR_PKIX_FAILURE) {
+		if (r == GKR_PKIX_FAILURE || r == GKR_PKIX_CANCELLED) {
 			ret = r;
 			goto done;
 		}
@@ -916,8 +972,10 @@ parse_pkcs12_encrypted_bag (GkrPkixParser *parser, GQuark loc, gkrid digest,
 		g_assert (cih == NULL);
 		
 	        if (!enum_next_password (parser, loc, digest, 0, NULL, &pstate, &password)) {
-	        	fire_parsed_partial (parser, loc, digest, 0);
-	        	ret = GKR_PKIX_SUCCESS;
+	        	if (parser->interactive)
+	        		ret = GKR_PKIX_CANCELLED;
+	        	else 
+	        		ret = fire_parsed_partial (parser, loc, digest, 0);
 	        	goto done; 
 	        }
 	        
@@ -1039,7 +1097,7 @@ parse_pkcs12_safe (GkrPkixParser *parser, GQuark loc, const guchar *data, gsize
 			r = GKR_PKIX_UNRECOGNIZED;
 		}
 		
-		if (r == GKR_PKIX_FAILURE) {
+		if (r == GKR_PKIX_FAILURE || r == GKR_PKIX_CANCELLED) {
 			ret = r;
 			goto done;
 		}
@@ -1133,7 +1191,7 @@ parse_pkcs7_signed_data (GkrPkixParser *parser, GQuark loc, gkrid digest,
 	
 		ret = gkr_pkix_der_read_certificate (certificate, n_certificate, &casn);
 		if (ret == GKR_PKIX_SUCCESS)
-			fire_parsed_asn1 (parser, loc, digest, GKR_PKIX_CERTIFICATE, casn);
+			ret = fire_parsed_asn1 (parser, loc, digest, GKR_PKIX_CERTIFICATE, casn);
 		if (ret == GKR_PKIX_FAILURE)
 			goto done;
 	}
@@ -1273,9 +1331,9 @@ parse_plain_pem (GkrPkixParser *parser, GQuark location, gkrid digest,
 		g_assert (parsed);
 		
 		if (s_key)
-			fire_parsed_sexp (parser, location, digest, parsed, s_key);
+			res = fire_parsed_sexp (parser, location, digest, parsed, s_key);
 		else
-			fire_parsed_asn1 (parser, location, digest, parsed, asn1);
+			res = fire_parsed_asn1 (parser, location, digest, parsed, asn1);
 	}
 
 	return res;
@@ -1311,11 +1369,13 @@ parse_encrypted_pem (GkrPkixParser *parser, GQuark location, gkrid digest,
 		
 	while (!gkr_async_is_stopping ()) {
 
-    	/* If no password is available, we still know what it was, so 'partial' parse */
+		/* If no password is available, we still know what it was, so 'partial' parse */
 		if (!enum_next_password (parser, location, digest, parsed, NULL, &pstate, &password)) {
-        	fire_parsed_partial (parser, location, digest, parsed);
-        	return GKR_PKIX_SUCCESS;
-        }
+	        	if (parser->interactive)
+	        		return GKR_PKIX_CANCELLED;
+	        	else 
+	        		return fire_parsed_partial (parser, location, digest, parsed);
+		}
 		
 		decrypted = NULL;
 		n_decrypted = 0;
diff --git a/daemon/pkix/gkr-pkix-parser.h b/daemon/pkix/gkr-pkix-parser.h
index 1e04a7a4..65ce2874 100644
--- a/daemon/pkix/gkr-pkix-parser.h
+++ b/daemon/pkix/gkr-pkix-parser.h
@@ -50,6 +50,7 @@ typedef struct _GkrPkixParserClass GkrPkixParserClass;
 
 struct _GkrPkixParser {
 	 GObject parent;
+	 gboolean interactive;
 };
 
 struct _GkrPkixParserClass {
@@ -80,7 +81,7 @@ GType               gkr_pkix_parser_get_type                (void) G_GNUC_CONST;
 
 GQuark 	            gkr_pkix_parser_get_error_domain        (void) G_GNUC_CONST;
 
-GkrPkixParser*      gkr_pkix_parser_new                     (void);
+GkrPkixParser*      gkr_pkix_parser_new                     (gboolean interactive);
 
 gboolean            gkr_pkix_parser_parse                   (GkrPkixParser *parser, GQuark loc,
                                                              const guchar *data, gsize n_data, 
diff --git a/daemon/pkix/gkr-pkix-types.h b/daemon/pkix/gkr-pkix-types.h
index f22f12ea..dd29e3f1 100644
--- a/daemon/pkix/gkr-pkix-types.h
+++ b/daemon/pkix/gkr-pkix-types.h
@@ -2,7 +2,8 @@
 #define GKRPKIXTYPES_H_
 
 typedef enum _GkrPkixResult {
-	GKR_PKIX_FAILURE = -1,
+	GKR_PKIX_FAILURE = -2,
+	GKR_PKIX_CANCELLED = -1,
 	GKR_PKIX_UNRECOGNIZED = 0,
 	GKR_PKIX_SUCCESS = 1
 } GkrPkixResult;
diff --git a/daemon/pkix/tests/unit-test-pkix-parser.c b/daemon/pkix/tests/unit-test-pkix-parser.c
index 698dc336..80504252 100644
--- a/daemon/pkix/tests/unit-test-pkix-parser.c
+++ b/daemon/pkix/tests/unit-test-pkix-parser.c
@@ -185,7 +185,7 @@ read_file (CuTest *cu, const gchar *filename, GQuark *location, guchar **content
 
 void unit_test_start_parser (CuTest *cu)
 {
-	parser = gkr_pkix_parser_new ();
+	parser = gkr_pkix_parser_new (FALSE);
 	g_signal_connect (parser, "parsed-partial", G_CALLBACK (parsed_partial), NULL);
 	g_signal_connect (parser, "parsed-sexp", G_CALLBACK (parsed_sexp), NULL);
 	g_signal_connect (parser, "parsed-asn1", G_CALLBACK (parsed_asn1), NULL);
diff --git a/daemon/pkix/tests/unit-test-pkix-serialize.c b/daemon/pkix/tests/unit-test-pkix-serialize.c
index a7ee445a..13cf13fd 100644
--- a/daemon/pkix/tests/unit-test-pkix-serialize.c
+++ b/daemon/pkix/tests/unit-test-pkix-serialize.c
@@ -126,7 +126,7 @@ void unit_test_serialize_pkcs8 (CuTest* cu)
 	/* Serializes as PKCS8 */
 	output = gkr_pkix_serialize_to_data (GKR_PKIX_PRIVATE_KEY, key, "booo", &n_output);
 	
-	parser = gkr_pkix_parser_new ();
+	parser = gkr_pkix_parser_new (FALSE);
 	g_signal_connect (parser, "ask-password", G_CALLBACK (ask_password), cu);
 
 	result = gkr_pkix_parser_der_pkcs8 (parser, 0, output, n_output);