[gmime] Moved get/set_retrieve_session_key into the base GMimeCryptoContext class

[Jeffrey Stedfast <fejj src gnome org>]

commit 44b5d28080d086bcc8f7c344e6f187f13bd19bc9
Author: Jeffrey Stedfast <jestedfa microsoft com>
Date:   Fri Dec 9 10:35:36 2016 -0500

    Moved get/set_retrieve_session_key into the base GMimeCryptoContext class
    
    2016-12-09  Jeffrey Stedfast  <fejj gnome org>
    
        * gmime/gmime-crypto-context.c (g_mime_crypto_context_set_retrieve_session_key):
        Moved here from GMimeGpgContext.
        (g_mime_crypto_context_get_retrieve_session_key): Same.
    
        Thanks to Daniel Kahn Gillmor for this patch.

 ChangeLog                    |    8 +++++
 gmime/gmime-crypto-context.c |   70 +++++++++++++++++++++++++++++++++++++++++-
 gmime/gmime-crypto-context.h |   12 +++++++
 gmime/gmime-gpg-context.c    |   50 +++++++++++++++---------------
 gmime/gmime-gpg-context.h    |    3 --
 tests/test-pgpmime.c         |   13 +++++++-
 tests/test-smime.c           |    9 +++++
 7 files changed, 135 insertions(+), 30 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index a219032..586cf82 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2016-12-09  Jeffrey Stedfast  <fejj gnome org>
+
+       * gmime/gmime-crypto-context.c (g_mime_crypto_context_set_retrieve_session_key):
+       Moved here from GMimeGpgContext.
+       (g_mime_crypto_context_get_retrieve_session_key): Same.
+
+       Thanks to Daniel Kahn Gillmor for this patch.
+
 2016-12-05  Jeffrey Stedfast  <fejj gnome org>
 
        * gmime/gmime-multipart-encrypted.c
diff --git a/gmime/gmime-crypto-context.c b/gmime/gmime-crypto-context.c
index ef160cc..9da02b7 100644
--- a/gmime/gmime-crypto-context.c
+++ b/gmime/gmime-crypto-context.c
@@ -54,6 +54,10 @@ static const char *crypto_get_encryption_protocol (GMimeCryptoContext *ctx);
 
 static const char *crypto_get_key_exchange_protocol (GMimeCryptoContext *ctx);
 
+static int crypto_set_retrieve_session_key (GMimeCryptoContext *ctx, gboolean retrieve_session_key,
+                                           GError **err);
+static gboolean crypto_get_retrieve_session_key (GMimeCryptoContext *ctx);
+
 static int crypto_sign (GMimeCryptoContext *ctx, const char *userid,
                        GMimeDigestAlgo digest, GMimeStream *istream,
                        GMimeStream *ostream, GError **err);
@@ -130,6 +134,8 @@ g_mime_crypto_context_class_init (GMimeCryptoContextClass *klass)
        klass->get_signature_protocol = crypto_get_signature_protocol;
        klass->get_encryption_protocol = crypto_get_encryption_protocol;
        klass->get_key_exchange_protocol = crypto_get_key_exchange_protocol;
+       klass->get_retrieve_session_key = crypto_get_retrieve_session_key;
+       klass->set_retrieve_session_key = crypto_set_retrieve_session_key;
 }
 
 static void
@@ -162,6 +168,68 @@ g_mime_crypto_context_set_request_password (GMimeCryptoContext *ctx, GMimePasswo
 }
 
 
+static gboolean
+crypto_get_retrieve_session_key (GMimeCryptoContext *ctx)
+{
+       return FALSE;
+}
+
+/**
+ * g_mime_crypto_context_get_retrieve_session_key:
+ * @ctx: a #GMimeCryptoContext
+ *
+ * Returns: an indication of whether @ctx is configured to retrieve a
+ * session key during decryption (see g_mime_decrypt_result_get_session_key()).
+ **/
+gboolean
+g_mime_crypto_context_get_retrieve_session_key (GMimeCryptoContext *ctx)
+{
+       g_return_val_if_fail (GMIME_IS_CRYPTO_CONTEXT (ctx), FALSE);
+       
+       return GMIME_CRYPTO_CONTEXT_GET_CLASS (ctx)->get_retrieve_session_key (ctx);
+}
+
+static int
+crypto_set_retrieve_session_key (GMimeCryptoContext *ctx, gboolean retrieve_session_key,
+                                GError **err)
+{
+       if (!retrieve_session_key)
+               return 0;
+       
+       g_set_error (err, GMIME_ERROR, GMIME_ERROR_NOT_SUPPORTED,
+                    "Session key retrieval is not supported by this crypto context");
+       
+       return -1;
+}
+
+/**
+ * g_mime_crypto_context_set_retrieve_session_key:
+ * @ctx: a #GMimeCryptoContext
+ * @retrieve_session_key: whether to retrieve session keys during decryption
+ * @err: a #GError
+ *
+ * Configures whether @ctx should produce a session key during future
+ * decryption operations (see
+ * g_mime_decrypt_result_get_session_key()).
+ *
+ * Returns: %0 on success or %-1 on fail.
+ **/
+int
+g_mime_crypto_context_set_retrieve_session_key (GMimeCryptoContext *ctx,
+                                               gboolean retrieve_session_key,
+                                               GError **err)
+{
+       if (!GMIME_IS_CRYPTO_CONTEXT (ctx)) {
+               g_set_error (err, GMIME_ERROR, GMIME_ERROR_NOT_SUPPORTED,
+                            "Not a GMimeCryptoContext, can't set retrieve_session_key");
+               return -1;
+       }
+       
+       return GMIME_CRYPTO_CONTEXT_GET_CLASS (ctx)->set_retrieve_session_key (ctx, retrieve_session_key, 
err);
+}
+
+
+
 static GMimeDigestAlgo
 crypto_digest_id (GMimeCryptoContext *ctx, const char *name)
 {
@@ -858,7 +926,7 @@ g_mime_decrypt_result_set_session_key (GMimeDecryptResult *result, const char *s
  * Get the session_key used for this decryption, if the underlying
  * crypto context is capable of and (configured to) retrieve session
  * keys during decryption.  See, for example,
- * g_mime_gpg_context_set_retrieve_session_key().
+ * g_mime_crypto_context_set_retrieve_session_key().
  *
  * Returns: the session_key digest algorithm used, or NULL if no
  * session key was requested or found.
diff --git a/gmime/gmime-crypto-context.h b/gmime/gmime-crypto-context.h
index 6f337c4..33bf224 100644
--- a/gmime/gmime-crypto-context.h
+++ b/gmime/gmime-crypto-context.h
@@ -117,6 +117,12 @@ struct _GMimeCryptoContextClass {
        GMimeDecryptResult *     (* decrypt_session)     (GMimeCryptoContext *ctx, const char *session_key,
                                                          GMimeStream *istream, GMimeStream *ostream,
                                                          GError **err);
+       
+       gboolean                 (* get_retrieve_session_key) (GMimeCryptoContext *ctx);
+       
+       int                      (* set_retrieve_session_key) (GMimeCryptoContext *ctx,
+                                                              gboolean retrieve_session_key,
+                                                              GError **err);
 };
 
 
@@ -124,6 +130,12 @@ GType g_mime_crypto_context_get_type (void);
 
 void g_mime_crypto_context_set_request_password (GMimeCryptoContext *ctx, GMimePasswordRequestFunc 
request_passwd);
 
+gboolean g_mime_crypto_context_get_retrieve_session_key (GMimeCryptoContext *ctx);
+
+int g_mime_crypto_context_set_retrieve_session_key (GMimeCryptoContext *ctx,
+                                                   gboolean retrieve_session_key,
+                                                   GError **err);
+
 /* digest algo mapping */
 GMimeDigestAlgo g_mime_crypto_context_digest_id (GMimeCryptoContext *ctx, const char *name);
 
diff --git a/gmime/gmime-gpg-context.c b/gmime/gmime-gpg-context.c
index e39465c..bd9e102 100644
--- a/gmime/gmime-gpg-context.c
+++ b/gmime/gmime-gpg-context.c
@@ -86,6 +86,11 @@ static GMimeDigestAlgo gpg_digest_id (GMimeCryptoContext *ctx, const char *name)
 
 static const char *gpg_digest_name (GMimeCryptoContext *ctx, GMimeDigestAlgo digest);
 
+static gboolean gpg_get_retrieve_session_key (GMimeCryptoContext *context);
+
+static int gpg_set_retrieve_session_key (GMimeCryptoContext *ctx, gboolean retrieve_session_key,
+                                        GError **err);
+
 static int gpg_sign (GMimeCryptoContext *ctx, const char *userid,
                     GMimeDigestAlgo digest, GMimeStream *istream,
                     GMimeStream *ostream, GError **err);
@@ -168,6 +173,8 @@ g_mime_gpg_context_class_init (GMimeGpgContextClass *klass)
        crypto_class->get_signature_protocol = gpg_get_signature_protocol;
        crypto_class->get_encryption_protocol = gpg_get_encryption_protocol;
        crypto_class->get_key_exchange_protocol = gpg_get_key_exchange_protocol;
+       crypto_class->get_retrieve_session_key = gpg_get_retrieve_session_key;
+       crypto_class->set_retrieve_session_key = gpg_set_retrieve_session_key;
 }
 
 static void
@@ -367,10 +374,10 @@ gpg_ctx_new (GMimeGpgContext *ctx)
        gpg->recipients = NULL;
        gpg->cipher = GMIME_CIPHER_ALGO_DEFAULT;
        gpg->digest = GMIME_DIGEST_ALGO_DEFAULT;
+       gpg->override_session_key = FALSE;
        gpg->always_trust = FALSE;
        gpg->use_agent = FALSE;
        gpg->armor = FALSE;
-       gpg->override_session_key = FALSE;
        
        gpg->stdin_fd = -1;
        gpg->stdout_fd = -1;
@@ -2099,6 +2106,7 @@ gpg_decrypt_session (GMimeCryptoContext *context, const char *session_key,
        gpg_ctx_set_use_agent (gpg, ctx->use_agent);
        gpg_ctx_set_istream (gpg, istream);
        gpg_ctx_set_ostream (gpg, ostream);
+       
        if (session_key)
                gpg->override_session_key = TRUE;
        
@@ -2404,38 +2412,30 @@ g_mime_gpg_context_set_use_agent (GMimeGpgContext *ctx, gboolean use_agent)
        ctx->use_agent = use_agent;
 }
 
-/**
- * g_mime_gpg_context_get_retrieve_session_key:
- * @ctx: a #GMimeGpgContext
- *
- * Gets the retrieve_session_key flag on the gpg context.
- *
- * Returns: the retrieve_session_key flag on the gpg context, which
- * indicates that GnuPG should attempt to retrieve the session key for
- * any encrypted message.
- **/
-gboolean
-g_mime_gpg_context_get_retrieve_session_key (GMimeGpgContext *ctx)
+static gboolean
+gpg_get_retrieve_session_key (GMimeCryptoContext *context)
 {
+       GMimeGpgContext *ctx = (GMimeGpgContext *) context;
+       
        g_return_val_if_fail (GMIME_IS_GPG_CONTEXT (ctx), FALSE);
        
        return ctx->retrieve_session_key;
 }
 
 
-/**
- * g_mime_gpg_context_set_retrieve_session_key:
- * @ctx: a #GMimeGpgContext
- * @retrieve_session_key: retrieve session key flag
- *
- * Sets the @retrieve_session_key flag on the gpg context, which
- * indicates that GnuPG should attempt to retrieve the session key for
- * any encrypted message.
- **/
-void
-g_mime_gpg_context_set_retrieve_session_key (GMimeGpgContext *ctx, gboolean retrieve_session_key)
+static int
+gpg_set_retrieve_session_key (GMimeCryptoContext *context, gboolean retrieve_session_key,
+                             GError **err)
 {
-       g_return_if_fail (GMIME_IS_GPG_CONTEXT (ctx));
+       GMimeGpgContext *ctx = (GMimeGpgContext *) context;
+       
+       if (!GMIME_IS_GPG_CONTEXT (ctx)) {
+               g_set_error (err, GMIME_ERROR, GMIME_ERROR_NOT_SUPPORTED,
+                            "Not a GMimeGpgContext, can't set retrieve_session_key");
+               return -1;
+       }
        
        ctx->retrieve_session_key = retrieve_session_key;
+       
+       return 0;
 }
diff --git a/gmime/gmime-gpg-context.h b/gmime/gmime-gpg-context.h
index 4f17fe0..646a5a4 100644
--- a/gmime/gmime-gpg-context.h
+++ b/gmime/gmime-gpg-context.h
@@ -74,9 +74,6 @@ void g_mime_gpg_context_set_always_trust (GMimeGpgContext *ctx, gboolean always_
 gboolean g_mime_gpg_context_get_use_agent (GMimeGpgContext *ctx);
 void g_mime_gpg_context_set_use_agent (GMimeGpgContext *ctx, gboolean use_agent);
 
-gboolean g_mime_gpg_context_get_retrieve_session_key (GMimeGpgContext *ctx);
-void g_mime_gpg_context_set_retrieve_session_key (GMimeGpgContext *ctx, gboolean retrieve_session_key);
-
 G_END_DECLS
 
 #endif /* __GMIME_GPG_CONTEXT_H__ */
diff --git a/tests/test-pgpmime.c b/tests/test-pgpmime.c
index 90f3e5b..cfd2d81 100644
--- a/tests/test-pgpmime.c
+++ b/tests/test-pgpmime.c
@@ -444,6 +444,7 @@ int main (int argc, char *argv[])
        int i;
        GMimeStream *stream = NULL, *cleartext = NULL;
        char *session_key = NULL;
+       GError *err = NULL;
        
        g_mime_init (0);
        
@@ -466,7 +467,17 @@ int main (int argc, char *argv[])
        
        ctx = g_mime_gpg_context_new (request_passwd, NULL);
        g_mime_gpg_context_set_always_trust ((GMimeGpgContext *) ctx, TRUE);
-       g_mime_gpg_context_set_retrieve_session_key ((GMimeGpgContext *) ctx, TRUE);
+       if (g_mime_crypto_context_set_retrieve_session_key (ctx, TRUE, &err) != 0) {
+               fprintf (stderr, "Failed to set retrieve_session_key on GMimeGpgContext: %s\n",
+                        err ? err->message : "no error info returned" );
+               if (err)
+                       g_error_free (err);
+               return EXIT_FAILURE;
+       }
+       if (!g_mime_crypto_context_get_retrieve_session_key (ctx)) {
+               fprintf (stderr, "We set retrieve_session_key on GMimeGpgContext, but it did not stay 
set.\n");
+               return EXIT_FAILURE;
+       }
        
        testsuite_check ("GMimeGpgContext::import");
        try {
diff --git a/tests/test-smime.c b/tests/test-smime.c
index 3fe47d1..fa838e8 100644
--- a/tests/test-smime.c
+++ b/tests/test-smime.c
@@ -438,6 +438,15 @@ int main (int argc, char *argv[])
        ctx = g_mime_pkcs7_context_new (request_passwd);
        g_mime_pkcs7_context_set_always_trust ((GMimePkcs7Context *) ctx, TRUE);
        
+       if (g_mime_crypto_context_set_retrieve_session_key (ctx, TRUE, NULL) == 0) {
+               fprintf (stderr, "GMimePkcs7Context should not have allowed us to set retrieve_session_key to 
TRUE, since it is not implemented.\n");
+               return EXIT_FAILURE;
+       }
+       if (g_mime_crypto_context_get_retrieve_session_key (ctx)) {
+               fprintf (stderr, "GMimePkcs7Context should have returned FALSE for 
get_retrieve_session_key.\n");
+               return EXIT_FAILURE;
+       }
+       
        testsuite_check ("GMimePkcs7Context::import");
        try {
                key = g_build_filename (datadir, "gmime-cert.p7", NULL);