Merge lp:~jelmer/pygpgme/bug452194 into lp:~launchpad-pqm/pygpgme/devel

[Jelmer Vernooij]

Initialize GPGME properly by calling gpgme_check_version().

This adds a call to gpgme_check_version() to PyGPGME. Without this, all functions in PyGPGME modules built against newer versions of GPGME fail with GPG_ERR_NOT_OPERATIONAL.

[Jelmer Vernooij (jelmer)]

This patch also pulls in the last few fixes from James on trunk.

[Michael Hudson-Doyle (mwhudson)]

I think this looks reasonable, but I sure hope our tests find any incompatibilities the trunk changes have brought :-)

review: Approve

=== modified file 'Makefile'
--- Makefile	2008-10-16 12:06:10 +0000
+++ Makefile	2010-03-25 00:48:28 +0000
@@ -1,4 +1,4 @@
-PYTHON = python2.4
+PYTHON = python
 
 build:
 	$(PYTHON) setup.py build_ext -i
 
=== modified file 'gpgme/__init__.py'
--- gpgme/__init__.py	2006-02-14 04:11:33 +0000
+++ gpgme/__init__.py	2010-03-25 00:48:28 +0000
@@ -15,7 +15,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
-from _gpgme import *
+from gpgme._gpgme import *
 
 # create constants
 make_constants(globals())
 
=== modified file 'gpgme/tests/test_context.py'
--- gpgme/tests/test_context.py	2006-10-16 08:22:31 +0000
+++ gpgme/tests/test_context.py	2010-03-25 00:48:28 +0000
@@ -15,6 +15,7 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
+import os
 import unittest
 
 import gpgme
@@ -119,6 +120,25 @@
         del ctx.progress_cb
         self.assertEqual(ctx.progress_cb, None)
 
+    def test_set_engine_info(self):
+        # Add a key using the default $GNUPGHOME based keyring.
+        ctx = gpgme.Context()
+        ctx.import_(self.keyfile('key1.pub'))
+
+        # If we set $GNUPGHOME to a dummy value, we can't read in the
+        # keywe just loaded.
+        os.environ['GNUPGHOME'] = '/no/such/dir'
+        ctx = gpgme.Context()
+        self.assertRaises(gpgme.GpgmeError, ctx.get_key,
+                          'E79A842DA34A1CA383F64A1546BB55F0885C65A4')
+
+        # But if we configure the context using set_engine_info(), it
+        # will find the key.
+        ctx = gpgme.Context()
+        ctx.set_engine_info(gpgme.PROTOCOL_OpenPGP, None, self._gpghome)
+        key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
+        self.assertTrue(key)
+
 
 def test_suite():
     loader = unittest.TestLoader()
 
=== modified file 'gpgme/tests/test_delete.py'
--- gpgme/tests/test_delete.py	2006-02-14 04:11:33 +0000
+++ gpgme/tests/test_delete.py	2010-03-25 00:48:28 +0000
@@ -16,7 +16,6 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 import unittest
-import StringIO
 
 import gpgme
 from gpgme.tests.util import GpgHomeTestCase
 
=== modified file 'gpgme/tests/test_editkey.py'
--- gpgme/tests/test_editkey.py	2006-02-14 04:11:33 +0000
+++ gpgme/tests/test_editkey.py	2010-03-25 00:48:28 +0000
@@ -17,7 +17,10 @@
 
 import unittest
 import os
-import StringIO
+try:
+    from io import BytesIO
+except ImportError:
+    from StringIO import StringIO as BytesIO
 
 import gpgme
 import gpgme.editutil
@@ -38,7 +41,7 @@
     def test_edit_quit(self):
         ctx = gpgme.Context()
         key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
-        output = StringIO.StringIO()
+        output = BytesIO()
 
         self.status = None
         self.args = None
 
=== modified file 'gpgme/tests/test_encrypt_decrypt.py'
--- gpgme/tests/test_encrypt_decrypt.py	2006-02-14 04:11:33 +0000
+++ gpgme/tests/test_encrypt_decrypt.py	2010-03-25 00:48:28 +0000
@@ -15,8 +15,12 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
+import os
 import unittest
-import StringIO
+try:
+    from io import BytesIO
+except ImportError:
+    from StringIO import StringIO as BytesIO
 from textwrap import dedent
 
 import gpgme
@@ -28,7 +32,7 @@
                    'signonly.pub', 'signonly.sec']
 
     def test_decrypt(self):
-        ciphertext = StringIO.StringIO(dedent('''
+        ciphertext = BytesIO(dedent('''
             -----BEGIN PGP MESSAGE-----
             Version: GnuPG v1.4.1 (GNU/Linux)
 
@@ -48,13 +52,13 @@
             =1s5N
             -----END PGP MESSAGE-----
             '''))
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         ctx = gpgme.Context()
         ctx.decrypt(ciphertext, plaintext)
         self.assertEqual(plaintext.getvalue(), 'hello world\n')
 
     def test_decrypt_verify(self):
-        ciphertext = StringIO.StringIO(dedent('''
+        ciphertext = BytesIO(dedent('''
             -----BEGIN PGP MESSAGE-----
             Version: GnuPG v1.4.1 (GNU/Linux)
 
@@ -76,7 +80,7 @@
             =fl3U
             -----END PGP MESSAGE-----
             '''))
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         ctx = gpgme.Context()
         sigs = ctx.decrypt_verify(ciphertext, plaintext)
         self.assertEqual(plaintext.getvalue(), 'hello world\n')
@@ -93,8 +97,8 @@
         self.assertEqual(sigs[0].validity_reason, None)
 
     def test_encrypt(self):
-        plaintext = StringIO.StringIO('Hello World\n')
-        ciphertext = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        ciphertext = BytesIO()
         ctx = gpgme.Context()
         recipient = ctx.get_key('93C2240D6B8AA10AB28F701D2CF46B7FC97E6B0F')
         ctx.encrypt([recipient], gpgme.ENCRYPT_ALWAYS_TRUST,
@@ -102,13 +106,13 @@
 
         # rewind ciphertext buffer, and try to decrypt:
         ciphertext.seek(0)
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         ctx.decrypt(ciphertext, plaintext)
         self.assertEqual(plaintext.getvalue(), 'Hello World\n')
 
     def test_encrypt_armor(self):
-        plaintext = StringIO.StringIO('Hello World\n')
-        ciphertext = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        ciphertext = BytesIO()
         ctx = gpgme.Context()
         ctx.armor = True
         recipient = ctx.get_key('93C2240D6B8AA10AB28F701D2CF46B7FC97E6B0F')
@@ -117,13 +121,31 @@
 
         # rewind ciphertext buffer, and try to decrypt:
         ciphertext.seek(0)
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
+        ctx.decrypt(ciphertext, plaintext)
+        self.assertEqual(plaintext.getvalue(), 'Hello World\n')
+
+    def test_encrypt_symmetric(self):
+        plaintext = BytesIO('Hello World\n')
+        ciphertext = BytesIO()
+        def passphrase(uid_hint, passphrase_info, prev_was_bad, fd):
+            os.write(fd, 'Symmetric passphrase\n')
+        ctx = gpgme.Context()
+        ctx.armor = True
+        ctx.passphrase_cb = passphrase
+        ctx.encrypt(None, 0, plaintext, ciphertext)
+        self.assertTrue(
+            ciphertext.getvalue().startswith('-----BEGIN PGP MESSAGE-----'))
+
+        # Rewind ciphertext buffer and try to decrypt it:
+        ciphertext.seek(0)
+        plaintext = BytesIO()
         ctx.decrypt(ciphertext, plaintext)
         self.assertEqual(plaintext.getvalue(), 'Hello World\n')
 
     def test_encrypt_sign(self):
-        plaintext = StringIO.StringIO('Hello World\n')
-        ciphertext = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        ciphertext = BytesIO()
         ctx = gpgme.Context()
         ctx.armor = True
         signer = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
@@ -139,7 +161,7 @@
 
         # rewind ciphertext buffer, and try to decrypt:
         ciphertext.seek(0)
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         sigs = ctx.decrypt_verify(ciphertext, plaintext)
         self.assertEqual(plaintext.getvalue(), 'Hello World\n')
         self.assertEqual(len(sigs), 1)
@@ -152,8 +174,8 @@
         self.assertEqual(sigs[0].validity_reason, None)
 
     def test_encrypt_to_signonly(self):
-        plaintext = StringIO.StringIO('Hello World\n')
-        ciphertext = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        ciphertext = BytesIO()
         ctx = gpgme.Context()
         recipient = ctx.get_key('15E7CE9BF1771A4ABC550B31F540A569CB935A42')
         try:
 
=== modified file 'gpgme/tests/test_export.py'
--- gpgme/tests/test_export.py	2006-02-14 04:11:33 +0000
+++ gpgme/tests/test_export.py	2010-03-25 00:48:28 +0000
@@ -16,7 +16,10 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 import unittest
-import StringIO
+try:
+    from io import BytesIO
+except ImportError:
+    from StringIO import StringIO as BytesIO
 from textwrap import dedent
 
 import gpgme
@@ -29,7 +32,7 @@
     def test_export_by_fingerprint(self):
         ctx = gpgme.Context()
         ctx.armor = True
-        keydata = StringIO.StringIO()
+        keydata = BytesIO()
         ctx.export('15E7CE9BF1771A4ABC550B31F540A569CB935A42', keydata)
 
         self.assertTrue(keydata.getvalue().startswith(
@@ -38,7 +41,7 @@
     def test_export_by_email(self):
         ctx = gpgme.Context()
         ctx.armor = True
-        keydata = StringIO.StringIO()
+        keydata = BytesIO()
         ctx.export('[e-mail]', keydata)
 
         self.assertTrue(keydata.getvalue().startswith(
@@ -47,7 +50,7 @@
     def test_export_by_name(self):
         ctx = gpgme.Context()
         ctx.armor = True
-        keydata = StringIO.StringIO()
+        keydata = BytesIO()
         ctx.export('Sign Only', keydata)
 
         self.assertTrue(keydata.getvalue().startswith(
 
=== modified file 'gpgme/tests/test_genkey.py'
--- gpgme/tests/test_genkey.py	2008-10-16 07:44:55 +0000
+++ gpgme/tests/test_genkey.py	2010-03-25 00:48:28 +0000
@@ -16,7 +16,10 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 import unittest
-import StringIO
+try:
+    from io import BytesIO
+except ImportError:
+    from StringIO import StringIO as BytesIO
 
 import gpgme
 from gpgme.tests.util import GpgHomeTestCase
@@ -47,8 +50,8 @@
         ctx = gpgme.Context()
         ctx.signers = [key]
 
-        plaintext = StringIO.StringIO('Hello World\n')
-        signature = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        signature = BytesIO()
 
         ctx.armor = True
         new_sigs = ctx.sign(
@@ -61,7 +64,7 @@
         self.assertEqual(len(sigs), 1)
         self.assertEqual(sigs[0].fpr, key.subkeys[0].fpr)
 
-    def test_generate_signing_only_keys(self):
+    def _test_generate_signing_only_keys(self):
         ctx = gpgme.Context()
         result = ctx.genkey(signing_only_param)
 
 
=== modified file 'gpgme/tests/test_import.py'
--- gpgme/tests/test_import.py	2006-02-14 04:11:33 +0000
+++ gpgme/tests/test_import.py	2010-03-25 00:48:28 +0000
@@ -16,7 +16,10 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 import unittest
-import StringIO
+try:
+    from io import BytesIO
+except ImportError:
+    from StringIO import StringIO as BytesIO
 
 import gpgme
 from gpgme.tests.util import GpgHomeTestCase
@@ -79,7 +82,7 @@
         key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4', True)
 
     def test_import_stringio(self):
-        fp = StringIO.StringIO(self.keyfile('key1.pub').read())
+        fp = BytesIO(self.keyfile('key1.pub').read())
         ctx = gpgme.Context()
         result = ctx.import_(fp)
         self.assertEqual(len(result.imports), 1)
@@ -93,7 +96,7 @@
         keys = '\n'.join([self.keyfile('key1.pub').read(),
                           self.keyfile('key1.sec').read(),
                           self.keyfile('key2.pub').read()])
-        fp = StringIO.StringIO(keys)
+        fp = BytesIO(keys)
         ctx = gpgme.Context()
         result = ctx.import_(fp)
         self.assertEqual(result.considered, 3)
@@ -130,7 +133,7 @@
         key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4', True)
 
     def test_import_empty(self):
-        fp = StringIO.StringIO('')
+        fp = BytesIO('')
         ctx = gpgme.Context()
         result = ctx.import_(fp)
         self.assertEqual(result.considered, 0)
@@ -143,7 +146,7 @@
 
         fp = self.keyfile('key1.pub')
         result = ctx.import_(fp)
-        
+
         self.assertEqual(result.considered, 1)
         self.assertEqual(result.no_user_id, 0)
         self.assertEqual(result.imported, 0)
 
=== modified file 'gpgme/tests/test_passphrase.py'
--- gpgme/tests/test_passphrase.py	2006-02-14 04:11:33 +0000
+++ gpgme/tests/test_passphrase.py	2010-03-25 00:48:28 +0000
@@ -17,7 +17,10 @@
 
 import unittest
 import os
-import StringIO
+try:
+    from io import BytesIO
+except ImportError:
+    from StringIO import StringIO as BytesIO
 from textwrap import dedent
 
 import gpgme
@@ -31,8 +34,8 @@
         ctx = gpgme.Context()
         key = ctx.get_key('EFB052B4230BBBC51914BCBB54DCBBC8DBFB9EB3')
         ctx.signers = [key]
-        plaintext = StringIO.StringIO('Hello World\n')
-        signature = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        signature = BytesIO()
 
         try:
             new_sigs = ctx.sign(plaintext, signature, gpgme.SIG_MODE_CLEAR)
@@ -53,8 +56,8 @@
         key = ctx.get_key('EFB052B4230BBBC51914BCBB54DCBBC8DBFB9EB3')
         ctx.signers = [key]
         ctx.passphrase_cb = self.passphrase_cb
-        plaintext = StringIO.StringIO('Hello World\n')
-        signature = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        signature = BytesIO()
 
         self.uid_hint = None
         self.passphrase_info = None
 
=== modified file 'gpgme/tests/test_progress.py'
--- gpgme/tests/test_progress.py	2006-02-14 04:11:33 +0000
+++ gpgme/tests/test_progress.py	2010-03-25 00:48:28 +0000
@@ -17,7 +17,10 @@
 
 import unittest
 import os
-import StringIO
+try:
+    from io import BytesIO
+except ImportError:
+    from StringIO import StringIO as BytesIO
 from textwrap import dedent
 
 import gpgme
@@ -35,8 +38,8 @@
         key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
         ctx.signers = [key]
         ctx.progress_cb = self.progress_cb
-        plaintext = StringIO.StringIO('Hello World\n')
-        signature = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        signature = BytesIO()
 
         self.progress_cb_called = False
         new_sigs = ctx.sign(plaintext, signature, gpgme.SIG_MODE_CLEAR)
 
=== modified file 'gpgme/tests/test_sign_verify.py'
--- gpgme/tests/test_sign_verify.py	2007-04-10 02:34:52 +0000
+++ gpgme/tests/test_sign_verify.py	2010-03-25 00:48:28 +0000
@@ -16,7 +16,10 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 import unittest
-import StringIO
+try:
+    from io import BytesIO
+except ImportError:
+    from StringIO import StringIO as BytesIO
 from textwrap import dedent
 
 import gpgme
@@ -28,7 +31,7 @@
                    'signonly.pub', 'signonly.sec']
 
     def test_verify_normal(self):
-        signature = StringIO.StringIO(dedent('''
+        signature = BytesIO(dedent('''
             -----BEGIN PGP MESSAGE-----
             Version: GnuPG v1.4.1 (GNU/Linux)
 
@@ -38,7 +41,7 @@
             =HCW0
             -----END PGP MESSAGE-----
             '''))
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         ctx = gpgme.Context()
         sigs = ctx.verify(signature, None, plaintext)
 
@@ -56,7 +59,7 @@
         self.assertEqual(sigs[0].validity_reason, None)
 
     def test_verify_detached(self):
-        signature = StringIO.StringIO(dedent('''
+        signature = BytesIO(dedent('''
             -----BEGIN PGP SIGNATURE-----
             Version: GnuPG v1.4.1 (GNU/Linux)
 
@@ -65,7 +68,7 @@
             =dyZS
             -----END PGP SIGNATURE-----
             '''))
-        signed_text = StringIO.StringIO('Hello World\n')
+        signed_text = BytesIO('Hello World\n')
         ctx = gpgme.Context()
         sigs = ctx.verify(signature, signed_text, None)
 
@@ -82,7 +85,7 @@
         self.assertEqual(sigs[0].validity_reason, None)
 
     def test_verify_clearsign(self):
-        signature = StringIO.StringIO(dedent('''
+        signature = BytesIO(dedent('''
             -----BEGIN PGP SIGNED MESSAGE-----
             Hash: SHA1
 
@@ -95,7 +98,7 @@
             =kZ2c
             -----END PGP SIGNATURE-----
             '''))
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         ctx = gpgme.Context()
         sigs = ctx.verify(signature, None, plaintext)
 
@@ -113,7 +116,7 @@
         self.assertEqual(sigs[0].validity_reason, None)
 
     def test_verify_multiple_sigs(self):
-        signature = StringIO.StringIO(dedent('''
+        signature = BytesIO(dedent('''
             -----BEGIN PGP SIGNED MESSAGE-----
             Hash: SHA1
 
@@ -137,7 +140,7 @@
             =0A7N
             -----END PGP SIGNATURE-----
             '''))
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         ctx = gpgme.Context()
         sigs = ctx.verify(signature, None, plaintext)
 
@@ -166,7 +169,7 @@
         self.assertEqual(sigs[1].validity_reason, None)
 
     def test_verify_no_signature(self):
-        signature = StringIO.StringIO(dedent('''
+        signature = BytesIO(dedent('''
             -----BEGIN PGP SIGNED MESSAGE-----
             Hash: SHA1
 
@@ -174,7 +177,7 @@
             -----BEGIN PGP SIGNATURE-----
             -----END PGP SIGNATURE-----
             '''))
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         ctx = gpgme.Context()
         sigs = ctx.verify(signature, None, plaintext)
 
@@ -182,7 +185,7 @@
         self.assertEqual(len(sigs), 0)
 
     def test_verify_bad_signature(self):
-        signature = StringIO.StringIO(dedent('''
+        signature = BytesIO(dedent('''
             -----BEGIN PGP SIGNED MESSAGE-----
             Hash: SHA1
 
@@ -193,7 +196,7 @@
             iNhhNHx+gzGBUqtIK5LpENTCGgCfV3aO
             -----END PGP SIGNATURE-----
             '''))
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         ctx = gpgme.Context()
         try:
             ctx.verify(signature, None, plaintext)
@@ -208,8 +211,8 @@
         ctx.armor = False
         key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
         ctx.signers = [key]
-        plaintext = StringIO.StringIO('Hello World\n')
-        signature = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        signature = BytesIO()
 
         new_sigs = ctx.sign(plaintext, signature, gpgme.SIG_MODE_NORMAL)
         self.assertEqual(len(new_sigs), 1)
@@ -219,7 +222,7 @@
 
         # now verify the signature
         signature.seek(0)
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         sigs = ctx.verify(signature, None, plaintext)
         self.assertEqual(plaintext.getvalue(), 'Hello World\n')
         self.assertEqual(len(sigs), 1)
@@ -236,8 +239,8 @@
         ctx.armor = True
         key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
         ctx.signers = [key]
-        plaintext = StringIO.StringIO('Hello World\n')
-        signature = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        signature = BytesIO()
 
         new_sigs = ctx.sign(plaintext, signature, gpgme.SIG_MODE_NORMAL)
         self.assertEqual(len(new_sigs), 1)
@@ -247,7 +250,7 @@
 
         # now verify the signature
         signature.seek(0)
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         sigs = ctx.verify(signature, None, plaintext)
         self.assertEqual(plaintext.getvalue(), 'Hello World\n')
         self.assertEqual(len(sigs), 1)
@@ -264,8 +267,8 @@
         ctx.armor = True
         key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
         ctx.signers = [key]
-        plaintext = StringIO.StringIO('Hello World\n')
-        signature = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        signature = BytesIO()
 
         new_sigs = ctx.sign(plaintext, signature, gpgme.SIG_MODE_DETACH)
         self.assertEqual(len(new_sigs), 1)
@@ -291,8 +294,8 @@
         ctx.armor = True
         key = ctx.get_key('E79A842DA34A1CA383F64A1546BB55F0885C65A4')
         ctx.signers = [key]
-        plaintext = StringIO.StringIO('Hello World\n')
-        signature = StringIO.StringIO()
+        plaintext = BytesIO('Hello World\n')
+        signature = BytesIO()
 
         new_sigs = ctx.sign(plaintext, signature, gpgme.SIG_MODE_CLEAR)
         self.assertEqual(len(new_sigs), 1)
@@ -302,7 +305,7 @@
 
         # now verify the signature
         signature.seek(0)
-        plaintext = StringIO.StringIO()
+        plaintext = BytesIO()
         sigs = ctx.verify(signature, None, plaintext)
         self.assertEqual(plaintext.getvalue(), 'Hello World\n')
         self.assertEqual(len(sigs), 1)
 
=== modified file 'setup.py'
--- setup.py	2008-10-15 21:36:35 +0000
+++ setup.py	2010-03-25 00:48:28 +0000
@@ -1,4 +1,11 @@
 #!/usr/bin/env python
+"""A Python module for working with OpenPGP messages
+
+PyGPGME is a Python module that lets you sign, verify, encrypt and
+decrypt messages using the OpenPGP format.
+
+It is built on top of the GNU Privacy Guard and the GPGME library.
+"""
 
 from distutils.core import setup, Extension
 
@@ -17,17 +24,14 @@
      ],
     libraries=['gpgme'])
 
+description, long_description = __doc__.split("\n\n", 1)
+
 setup(name='pygpgme',
       version='0.1',
       author='James Henstridge',
       author_email='[e-mail]',
-      description='A Python module for working with OpenPGP messages',
-      long_description='''
-          PyGPGME is a Python module that lets you sign, verify, encrypt
-          and decrypt messages using the OpenPGP format.
-
-          It is built on top of the GNU Privacy Guard and the GPGME
-          library.''',
+      description=description,
+      long_description=long_description,
       license='LGPL',
       classifiers=[
           'Intended Audience :: Developers',
@@ -38,7 +42,7 @@
           'Topic :: Security :: Cryptography',
           'Topic :: Software Development :: Libraries :: Python Modules'
       ],
-      url='https://launchpad.net/products/pygpgme',
+      url='https://launchpad.net/pygpgme',
       ext_modules=[gpgme],
       packages=['gpgme', 'gpgme.tests'],
       package_data={'gpgme.tests': ['keys/*.pub', 'keys/*.sec']})
 
=== modified file 'src/gpgme.c'
--- src/gpgme.c	2008-10-15 21:36:35 +0000
+++ src/gpgme.c	2010-03-25 00:48:28 +0000
@@ -26,23 +26,33 @@
     { NULL, NULL, 0 }
 };
 
-PyMODINIT_FUNC
-init_gpgme(void)
+#if PY_VERSION_HEX >= 0x03000000
+static PyModuleDef pygpgme_module = {
+    PyModuleDef_HEAD_INIT,
+    "gpgme._gpgme",
+    .m_size = -1,
+    .m_methods = pygpgme_functions
+};
+#endif
+
+static PyObject *
+create_module(void)
 {
+    const char *gpgme_version;
     PyObject *mod;
 
     pygpgme_error = PyErr_NewException("gpgme.GpgmeError",
                                        PyExc_RuntimeError, NULL);
 
 #define INIT_TYPE(type)                      \
-    if (!type.ob_type)                       \
-        type.ob_type = &PyType_Type;         \
+    if (!Py_TYPE(&type))                      \
+        Py_TYPE(&type) = &PyType_Type;        \
     if (!type.tp_alloc)                      \
         type.tp_alloc = PyType_GenericAlloc; \
     if (!type.tp_new)                        \
         type.tp_new = PyType_GenericNew;     \
     if (PyType_Ready(&type) < 0)             \
-        return
+        return NULL
 
 #define ADD_TYPE(type)                \
     Py_INCREF(&PyGpgme ## type ## _Type); \
@@ -59,7 +69,11 @@
     INIT_TYPE(PyGpgmeGenkeyResult_Type);
     INIT_TYPE(PyGpgmeKeyIter_Type);
 
+#if PY_VERSION_HEX >= 0x03000000
+    mod = PyModule_Create(&pygpgme_module);
+#else
     mod = Py_InitModule("gpgme._gpgme", pygpgme_functions);
+#endif
 
     ADD_TYPE(Context);
     ADD_TYPE(Key);
@@ -74,4 +88,24 @@
 
     Py_INCREF(pygpgme_error);
     PyModule_AddObject(mod, "GpgmeError", pygpgme_error);
-}
+
+    gpgme_version = gpgme_check_version(NULL);
+    PyModule_AddObject(mod, "GPGME_VERSION",
+                       PyString_FromString(gpgme_version));
+
+    return mod;
+}
+
+#if PY_VERSION_HEX >= 0x03000000
+PyMODINIT_FUNC
+PyInit__gpgme(void)
+{
+    return create_module();
+}
+#else
+PyMODINIT_FUNC
+init_gpgme(void)
+{
+    create_module();
+}
+#endif
 
=== added file 'src/pycompat.h'
--- src/pycompat.h	1970-01-01 00:00:00 +0000
+++ src/pycompat.h	2010-03-25 00:48:28 +0000
@@ -0,0 +1,49 @@
+
+#ifndef PYGPGME_COMPAT_H
+#define PYGPGME_COMPAT_H
+
+#if PY_VERSION_HEX < 0x02060000
+
+#  define PyVarObject_HEAD_INIT(type, size) \
+          PyObject_HEAD_INIT(type) size,
+#  define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
+
+
+#  define PyBytesObject PyStringObject
+#  define PyBytes_Type PyString_Type
+
+#  define PyBytes_Check PyString_Check
+#  define PyBytes_CheckExact PyString_CheckExact 
+#  define PyBytes_CHECK_INTERNED PyString_CHECK_INTERNED
+#  define PyBytes_AS_STRING PyString_AS_STRING
+#  define PyBytes_GET_SIZE PyString_GET_SIZE
+#  define Py_TPFLAGS_BYTES_SUBCLASS Py_TPFLAGS_STRING_SUBCLASS
+
+#  define PyBytes_FromStringAndSize PyString_FromStringAndSize
+#  define PyBytes_FromString PyString_FromString
+#  define PyBytes_FromFormatV PyString_FromFormatV
+#  define PyBytes_FromFormat PyString_FromFormat
+#  define PyBytes_Size PyString_Size
+#  define PyBytes_AsString PyString_AsString
+#  define PyBytes_Repr PyString_Repr
+#  define PyBytes_Concat PyString_Concat
+#  define PyBytes_ConcatAndDel PyString_ConcatAndDel
+#  define PyBytes_Format PyString_Format
+#  define PyBytes_DecodeEscape PyString_DecodeEscape
+#  define PyBytes_Decode PyString_Decode
+#  define PyBytes_Encode PyString_Encode
+#  define PyBytes_AsEncodedObject PyString_AsEncodedObject
+#  define PyBytes_AsEncodedString PyString_AsEncodedString
+#  define PyBytes_AsDecodedObject PyString_AsDecodedObject
+#  define PyBytes_AsDecodedString PyString_AsDecodedString
+#  define PyBytes_AsStringAndSize PyString_AsStringAndSize
+
+#endif
+
+#if PY_VERSION_HEX > 0x03000000
+/* Ugh.  I'll need to fix this code, but the text/bytes changes take
+   precedence. */
+#  include <intobject.h>
+#endif
+
+#endif /* PYGPGME_COMPAT_H */
 
=== modified file 'src/pygpgme-context.c'
--- src/pygpgme-context.c	2008-10-16 07:44:55 +0000
+++ src/pygpgme-context.c	2010-03-25 00:48:28 +0000
@@ -356,7 +356,22 @@
     { NULL, (getter)0, (setter)0 }
 };
 
-/* XXX: set_locale */
+static PyObject *
+pygpgme_context_set_engine_info(PyGpgmeContext *self, PyObject *args)
+{
+    int protocol;
+    const char *file_name, *home_dir;
+
+    if (!PyArg_ParseTuple(args, "izz", &protocol, &file_name, &home_dir))
+        return NULL;
+
+    if (pygpgme_check_error(gpgme_ctx_set_engine_info(self->ctx, protocol,
+                                                      file_name, home_dir)))
+        return NULL;
+
+    Py_RETURN_NONE;
+}
+
 static PyObject *
 pygpgme_context_set_locale(PyGpgmeContext *self, PyObject *args)
 {
@@ -372,11 +387,6 @@
     Py_RETURN_NONE;
 }
 
-/* the following don't seem to be used */
-/* XXX: signers_clear */
-/* XXX: signers_add */
-/* XXX: signers_enum */
-
 static PyObject *
 pygpgme_context_get_key(PyGpgmeContext *self, PyObject *args)
 {
@@ -424,10 +434,17 @@
 
     list = PyList_New(0);
     for (key = res->invalid_recipients; key != NULL; key = key->next) {
-        PyObject *item, *err;
+        PyObject *item, *py_fpr, *err;
 
+        if (key->fpr)
+            py_fpr = PyUnicode_DecodeASCII(key->fpr, strlen(key->fpr),
+                                           "replace");
+        else {
+            py_fpr = Py_None;
+            Py_INCREF(py_fpr);
+        }
         err = pygpgme_error_object(key->reason);
-        item = Py_BuildValue("(zN)", key->fpr, err);
+        item = Py_BuildValue("(NN)", py_fpr, err);
         PyList_Append(list, item);
         Py_DECREF(item);
     }
@@ -442,121 +459,107 @@
 static PyObject *
 pygpgme_context_encrypt(PyGpgmeContext *self, PyObject *args)
 {
-    PyObject *py_recp, *py_plain, *py_cipher;
+    PyObject *py_recp, *py_plain, *py_cipher, *recp_seq = NULL, *result = NULL;
     int flags, i, length;
-    gpgme_key_t *recp;
-    gpgme_data_t plain, cipher;
+    gpgme_key_t *recp = NULL;
+    gpgme_data_t plain = NULL, cipher = NULL;
     gpgme_error_t err;
 
     if (!PyArg_ParseTuple(args, "OiOO", &py_recp, &flags,
                           &py_plain, &py_cipher))
-        return NULL;
-
-    py_recp = PySequence_Fast(py_recp, "first argument must be a sequence");
-    if (py_recp == NULL)
-        return NULL;
-
-    length = PySequence_Fast_GET_SIZE(py_recp);
-    recp = malloc((length + 1) * sizeof (gpgme_key_t));
-    for (i = 0; i < length; i++) {
-        PyObject *item = PySequence_Fast_GET_ITEM(py_recp, i);
-
-        if (!PyObject_TypeCheck(item, &PyGpgmeKey_Type)) {
-            free(recp);
-            Py_DECREF(py_recp);
-            PyErr_SetString(PyExc_TypeError, "items in first argument must "
-                            "be gpgme.Key objects");
-            return NULL;
+        goto end;
+
+    if (py_recp != Py_None) {
+        recp_seq = PySequence_Fast(py_recp, "first argument must be a "
+                                   "sequence or None");
+        if (recp_seq == NULL)
+            goto end;
+
+        length = PySequence_Fast_GET_SIZE(recp_seq);
+        recp = malloc((length + 1) * sizeof (gpgme_key_t));
+        for (i = 0; i < length; i++) {
+            PyObject *item = PySequence_Fast_GET_ITEM(recp_seq, i);
+
+            if (!PyObject_TypeCheck(item, &PyGpgmeKey_Type)) {
+                PyErr_SetString(PyExc_TypeError, "items in first argument "
+                                "must be gpgme.Key objects");
+                goto end;
+            }
+            recp[i] = ((PyGpgmeKey *)item)->key;
         }
-        recp[i] = ((PyGpgmeKey *)item)->key;
-    }
-    recp[i] = NULL;
-
-    if (pygpgme_data_new(&plain, py_plain)) {
-        free(recp);
-        Py_DECREF(py_recp);
-        return NULL;    
-    }
-    if (pygpgme_data_new(&cipher, py_cipher)) {
-        free(recp);
-        Py_DECREF(py_recp);
-        gpgme_data_release(plain);
-        return NULL;    
-    }
-
-    Py_BEGIN_ALLOW_THREADS;
-    err = gpgme_op_encrypt(self->ctx, recp, flags, plain, cipher);
+        recp[i] = NULL;
+    }
+
+    if (pygpgme_data_new(&plain, py_plain))
+        goto end;
+    if (pygpgme_data_new(&cipher, py_cipher))
+        goto end;
+
+    Py_BEGIN_ALLOW_THREADS;    err = gpgme_op_encrypt(self->ctx, recp, flags, plain, cipher);
     Py_END_ALLOW_THREADS;
 
-    free(recp);
-    Py_DECREF(py_recp);
-    gpgme_data_release(plain);
-    gpgme_data_release(cipher);
-
     if (pygpgme_check_error(err)) {
         decode_encrypt_result(self);
-        return NULL;
+        goto end;
     }
 
-    Py_RETURN_NONE;
+    Py_INCREF(Py_None);
+    result = Py_None;
+
+ end:
+    if (recp != NULL)
+        free(recp);
+    Py_XDECREF(recp_seq);
+    if (plain != NULL)
+        gpgme_data_release(plain);
+    if (cipher != NULL)
+        gpgme_data_release(cipher);
+
+    return result;
 }
 
 static PyObject *
 pygpgme_context_encrypt_sign(PyGpgmeContext *self, PyObject *args)
 {
-    PyObject *py_recp, *py_plain, *py_cipher;
+    PyObject *py_recp, *py_plain, *py_cipher, *recp_seq = NULL, *result = NULL;
     int flags, i, length;
-    gpgme_key_t *recp;
-    gpgme_data_t plain, cipher;
+    gpgme_key_t *recp = NULL;
+    gpgme_data_t plain = NULL, cipher = NULL;
     gpgme_error_t err;
-    gpgme_sign_result_t result;
+    gpgme_sign_result_t sign_result;
 
     if (!PyArg_ParseTuple(args, "OiOO", &py_recp, &flags,
                           &py_plain, &py_cipher))
-        return NULL;
-
-    py_recp = PySequence_Fast(py_recp, "first argument must be a sequence");
-    if (py_recp == NULL)
-        return NULL;
-
-    length = PySequence_Fast_GET_SIZE(py_recp);
+        goto end;
+
+    recp_seq = PySequence_Fast(py_recp, "first argument must be a sequence");
+    if (recp_seq == NULL)
+        goto end;
+
+    length = PySequence_Fast_GET_SIZE(recp_seq);
     recp = malloc((length + 1) * sizeof (gpgme_key_t));
     for (i = 0; i < length; i++) {
-        PyObject *item = PySequence_Fast_GET_ITEM(py_recp, i);
+        PyObject *item = PySequence_Fast_GET_ITEM(recp_seq, i);
 
         if (!PyObject_TypeCheck(item, &PyGpgmeKey_Type)) {
-            free(recp);
-            Py_DECREF(py_recp);
-            PyErr_SetString(PyExc_TypeError, "items in first argument must "
-                            "be gpgme.Key objects");
-            return NULL;
+            PyErr_SetString(PyExc_TypeError, "items in first argument "
+                            "must be gpgme.Key objects");
+            goto end;
         }
         recp[i] = ((PyGpgmeKey *)item)->key;
     }
     recp[i] = NULL;
 
-    if (pygpgme_data_new(&plain, py_plain)) {
-        free(recp);
-        Py_DECREF(py_recp);
-        return NULL;    
-    }
-    if (pygpgme_data_new(&cipher, py_cipher)) {
-        free(recp);
-        Py_DECREF(py_recp);
-        gpgme_data_release(plain);
-        return NULL;    
-    }
+    if (pygpgme_data_new(&plain, py_plain))
+        goto end;
+    if (pygpgme_data_new(&cipher, py_cipher))
+        goto end;
 
     Py_BEGIN_ALLOW_THREADS;
     err = gpgme_op_encrypt_sign(self->ctx, recp, flags, plain, cipher);
     Py_END_ALLOW_THREADS;
 
-    free(recp);
-    Py_DECREF(py_recp);
-    gpgme_data_release(plain);
-    gpgme_data_release(cipher);
-
-    result = gpgme_op_sign_result(self->ctx);
+    sign_result = gpgme_op_sign_result(self->ctx);
 
     /* annotate exception */
     if (pygpgme_check_error(err)) {
@@ -569,36 +572,54 @@
         PyErr_Fetch(&err_type, &err_value, &err_traceback);
         PyErr_NormalizeException(&err_type, &err_value, &err_traceback);
 
-        if (result == NULL)
-            goto end;
+        if (sign_result == NULL)
+            goto error_end;
 
         if (!PyErr_GivenExceptionMatches(err_type, pygpgme_error))
-            goto end;
+            goto error_end;
 
         list = PyList_New(0);
-        for (key = result->invalid_signers; key != NULL; key = key->next) {
-            PyObject *item, *err;
+        for (key = sign_result->invalid_signers; key != NULL; key = key->next) {
+            PyObject *item, *py_fpr, *err;
 
+            if (key->fpr)
+                py_fpr = PyUnicode_DecodeASCII(key->fpr, strlen(key->fpr),
+                                               "replace");
+            else {
+                py_fpr = Py_None;
+                Py_INCREF(py_fpr);
+            }
             err = pygpgme_error_object(key->reason);
-            item = Py_BuildValue("(zN)", key->fpr, err);
+            item = Py_BuildValue("(NN)", py_fpr, err);
             PyList_Append(list, item);
             Py_DECREF(item);
         }
         PyObject_SetAttrString(err_value, "invalid_signers", list);
         Py_DECREF(list);
 
-        list = pygpgme_newsiglist_new(result->signatures);
+        list = pygpgme_newsiglist_new(sign_result->signatures);
         PyObject_SetAttrString(err_value, "signatures", list);
         Py_DECREF(list);
-    end:
+    error_end:
         PyErr_Restore(err_type, err_value, err_traceback);
-        return NULL;
+        goto end;
     }
 
-    if (result)
-        return pygpgme_newsiglist_new(result->signatures);
+    if (sign_result)
+        result = pygpgme_newsiglist_new(sign_result->signatures);
     else
-        return PyList_New(0);
+        result = PyList_New(0);
+
+ end:
+    if (recp != NULL)
+        free(recp);
+    Py_XDECREF(recp_seq);
+    if (plain != NULL)
+        gpgme_data_release(plain);
+    if (cipher != NULL)
+        gpgme_data_release(cipher);
+
+    return result;
 }
 
 static void
@@ -619,7 +640,9 @@
         goto end;
 
     if (res->unsupported_algorithm) {
-        value = PyString_FromString(res->unsupported_algorithm);
+        value = PyUnicode_DecodeUTF8(res->unsupported_algorithm,
+                                     strlen(res->unsupported_algorithm),
+                                     "replace");
     } else {
         Py_INCREF(Py_None);
         value = Py_None;
@@ -655,7 +678,7 @@
 
     if (pygpgme_data_new(&plain, py_plain)) {
         gpgme_data_release(cipher);
-        return NULL;    
+        return NULL;
     }
 
     Py_BEGIN_ALLOW_THREADS;
@@ -690,7 +713,7 @@
 
     if (pygpgme_data_new(&plain, py_plain)) {
         gpgme_data_release(cipher);
-        return NULL;    
+        return NULL;
     }
 
     Py_BEGIN_ALLOW_THREADS;
@@ -748,11 +771,11 @@
         return NULL;
 
     if (pygpgme_data_new(&plain, py_plain))
-        return NULL;    
+        return NULL;
 
     if (pygpgme_data_new(&sig, py_sig)) {
         gpgme_data_release(plain);
-        return NULL;    
+        return NULL;
     }
 
     Py_BEGIN_ALLOW_THREADS;
@@ -781,10 +804,17 @@
 
         list = PyList_New(0);
         for (key = result->invalid_signers; key != NULL; key = key->next) {
-            PyObject *item, *err;
+            PyObject *item, *py_fpr, *err;
 
+            if (key->fpr)
+                py_fpr = PyUnicode_DecodeASCII(key->fpr, strlen(key->fpr),
+                                               "replace");
+            else {
+                py_fpr = Py_None;
+                Py_INCREF(py_fpr);
+            }
             err = pygpgme_error_object(key->reason);
-            item = Py_BuildValue("(zN)", key->fpr, err);
+            item = Py_BuildValue("(NN)", py_fpr, err);
             PyList_Append(list, item);
             Py_DECREF(item);
         }
@@ -822,12 +852,12 @@
     }
     if (pygpgme_data_new(&signed_text, py_signed_text)) {
         gpgme_data_release(sig);
-        return NULL;    
+        return NULL;
     }
     if (pygpgme_data_new(&plaintext, py_plaintext)) {
         gpgme_data_release(sig);
         gpgme_data_release(signed_text);
-        return NULL;    
+        return NULL;
     }
 
     Py_BEGIN_ALLOW_THREADS;
@@ -924,9 +954,9 @@
         Py_INCREF(py_pattern);
         pattern = NULL;
         patterns = NULL;
-    } else if (PyString_Check(py_pattern)) {
+    } else if (PyBytes_Check(py_pattern)) {
         Py_INCREF(py_pattern);
-        pattern = PyString_AsString(py_pattern);
+        pattern = PyBytes_AsString(py_pattern);
         patterns = NULL;
     } else {
         py_pattern = PySequence_Fast(py_pattern,
@@ -939,14 +969,14 @@
         for (i = 0; i < length; i++) {
             PyObject *item = PySequence_Fast_GET_ITEM(py_pattern, i);
 
-            if (!PyString_Check(item)) {
+            if (!PyBytes_Check(item)) {
                 PyErr_SetString(PyExc_TypeError,
                     "first argument must be a string or sequence of strings");
                 free(patterns);
                 Py_DECREF(py_pattern);
                 return NULL;
             }
-            patterns[i] = PyString_AsString(item);
+            patterns[i] = PyBytes_AsString(item);
         }
         patterns[i] = NULL;
     }
@@ -1131,9 +1161,9 @@
         Py_INCREF(py_pattern);
         pattern = NULL;
         patterns = NULL;
-    } else if (PyString_Check(py_pattern)) {
+    } else if (PyBytes_Check(py_pattern)) {
         Py_INCREF(py_pattern);
-        pattern = PyString_AsString(py_pattern);
+        pattern = PyBytes_AsString(py_pattern);
         patterns = NULL;
     } else {
         py_pattern = PySequence_Fast(py_pattern,
@@ -1146,14 +1176,14 @@
         for (i = 0; i < length; i++) {
             PyObject *item = PySequence_Fast_GET_ITEM(py_pattern, i);
 
-            if (!PyString_Check(item)) {
+            if (!PyBytes_Check(item)) {
                 PyErr_SetString(PyExc_TypeError,
                     "first argument must be a string or sequence of strings");
                 free(patterns);
                 Py_DECREF(py_pattern);
                 return NULL;
             }
-            patterns[i] = PyString_AsString(item);
+            patterns[i] = PyBytes_AsString(item);
         }
         patterns[i] = NULL;
     }
@@ -1184,6 +1214,7 @@
 // pygpgme_context_trustlist
 
 static PyMethodDef pygpgme_context_methods[] = {
+    { "set_engine_info", (PyCFunction)pygpgme_context_set_engine_info, METH_VARARGS },
     { "set_locale", (PyCFunction)pygpgme_context_set_locale, METH_VARARGS },
     { "get_key", (PyCFunction)pygpgme_context_get_key, METH_VARARGS },
     { "encrypt", (PyCFunction)pygpgme_context_encrypt, METH_VARARGS },
@@ -1204,8 +1235,7 @@
 };
 
 PyTypeObject PyGpgmeContext_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.Context",
     sizeof(PyGpgmeContext),
     .tp_flags = Py_TPFLAGS_DEFAULT,
 
=== modified file 'src/pygpgme-data.c'
--- src/pygpgme-data.c	2006-02-14 04:07:06 +0000
+++ src/pygpgme-data.c	2010-03-25 00:48:28 +0000
@@ -65,17 +65,17 @@
         goto end;
     }
     /* if we don't have a string return value, consider that an error too */
-    if (!PyString_Check(result)) {
+    if (!PyBytes_Check(result)) {
         Py_DECREF(result);
         errno = EINVAL;
         result_size = -1;
         goto end;
     }
     /* copy the result into the given buffer */
-    result_size = PyString_Size(result);
+    result_size = PyBytes_Size(result);
     if (result_size > size)
         result_size = size;
-    memcpy(buffer, PyString_AsString(result), result_size);
+    memcpy(buffer, PyBytes_AsString(result), result_size);
     Py_DECREF(result);
  end:
     PyGILState_Release(state);
@@ -87,19 +87,25 @@
 {
     PyGILState_STATE state;
     PyObject *fp = handle;
-    PyObject *result;
-    ssize_t bytes_written = 0;
+    PyObject *py_buffer = NULL;
+    PyObject *result = NULL;
+    ssize_t bytes_written = -1;
 
     state = PyGILState_Ensure();
-    result = PyObject_CallMethod(fp, "write", "s#", buffer, (int)size);
+    py_buffer = PyBytes_FromStringAndSize(buffer, size);
+    if (py_buffer == NULL) {
+        set_errno();
+        goto end;
+    }
+    result = PyObject_CallMethod(fp, "write", "O", py_buffer);
     if (result == NULL) {
         set_errno();
-        bytes_written = -1;
         goto end;
     }
-    Py_DECREF(result);
     bytes_written = size;
  end:
+    Py_XDECREF(result);
+    Py_XDECREF(py_buffer);
     PyGILState_Release(state);
     return bytes_written;
 }
@@ -171,8 +177,10 @@
 
     error = gpgme_data_new_from_cbs(dh, &python_data_cbs, fp);
 
-    if (pygpgme_check_error(error))
+    if (pygpgme_check_error(error)) {
+        *dh = NULL;
         return -1;
+    }
 
     /* if no error, then the new gpgme_data_t object owns a reference to
      * the python object */
 
=== modified file 'src/pygpgme-error.c'
--- src/pygpgme-error.c	2006-02-14 04:07:06 +0000
+++ src/pygpgme-error.c	2010-03-25 00:48:28 +0000
@@ -26,34 +26,62 @@
 pygpgme_error_object(gpgme_error_t err)
 {
     char buf[256] = { '\0' };
-    PyObject *exc, *attr;
+    PyObject *exc = NULL, *source = NULL, *code = NULL, *strerror = NULL;
 
     if (err == GPG_ERR_NO_ERROR)
         Py_RETURN_NONE;
 
+    if (!(source = PyInt_FromLong(gpgme_err_source(err))))
+        goto end;
+
+    if (!(code = PyInt_FromLong(gpgme_err_code(err))))
+        goto end;
+
     /* get the error string */
-    if (gpgme_strerror_r(err, buf, 255) != 0)
+    if (gpgme_strerror_r(err, buf, sizeof(buf) - 1) != 0)
         strcpy(buf, "Unknown");
+    if (!(strerror = PyUnicode_DecodeUTF8(buf, strlen(buf), "replace")))
+        goto end;
 
-    exc = PyObject_CallFunction(pygpgme_error, "lls",
-                                (long)gpgme_err_source(err),
-                                (long)gpgme_err_code(err),
-                                buf);
+    exc = PyObject_CallFunction(pygpgme_error, "OOO", source, code, strerror);
     if (!exc)
-        return NULL;
+        goto end;
+
     /* set the source and code as attributes of the exception object: */
-    attr = PyInt_FromLong(gpgme_err_source(err));
-    PyObject_SetAttrString(exc, "source", attr);
-    Py_DECREF(attr);
-
-    attr = PyInt_FromLong(gpgme_err_code(err));
-    PyObject_SetAttrString(exc, "code", attr);
-    Py_DECREF(attr);
-
-    attr = PyString_FromString(buf);
-    PyObject_SetAttrString(exc, "message", attr);
-    Py_DECREF(attr);
-
+    PyObject_SetAttrString(exc, "source", source);
+    PyObject_SetAttrString(exc, "code", code);
+    PyObject_SetAttrString(exc, "strerror", strerror);
+
+    /* pygpgme 0.1 set the "message" attribute on exceptions, but
+     * Python 2.6 classes this exception attribute as deprecated (even
+     * though we weren't using it in the deprecated fashion).
+     *
+     * We now set the "strerror" attribute for this information, which
+     * is similar to IOError/OSError.
+     *
+     * For backward compatibility, we still set "message" on Python
+     * versions before 3.0.  The hack below is to avoid issuing a
+     * deprecation warning.
+     */
+#if PY_VERSION_HEX < 0x03000000
+#  if PY_VERSION_HEX >= 0x02060000
+    {
+        PyBaseExceptionObject *base_exc = (PyBaseExceptionObject *)exc;
+        PyObject *old_message = base_exc->message;
+
+        Py_INCREF(strerror);
+        base_exc->message = strerror;
+        Py_XDECREF(old_message);
+    }
+#  else
+    PyObject_SetAttrString(exc, "message", strerror);
+#  endif
+#endif
+
+ end:
+    Py_XDECREF(strerror);
+    Py_XDECREF(code);
+    Py_XDECREF(source);
     return exc;
 }
 
@@ -98,7 +126,7 @@
     source = PyTuple_GetItem(args, 0);
     if (source == NULL)
         goto end;
-  
+
     if (PyErr_GivenExceptionMatches(err_type, pygpgme_error)) {
         code = PyTuple_GetItem(args, 1);
         if (code == NULL)
 
=== modified file 'src/pygpgme-genkey.c'
--- src/pygpgme-genkey.c	2008-10-16 07:44:55 +0000
+++ src/pygpgme-genkey.c	2010-03-25 00:48:28 +0000
@@ -30,15 +30,14 @@
 }
 
 static PyMemberDef pygpgme_genkey_result_members[] = {
-    { "primary", T_OBJECT, offsetof(PyGpgmeGenkeyResult, primary), RO},
-    { "sub", T_OBJECT, offsetof(PyGpgmeGenkeyResult, sub), RO},
-    { "fpr", T_OBJECT, offsetof(PyGpgmeGenkeyResult, fpr), RO},
+    { "primary", T_OBJECT, offsetof(PyGpgmeGenkeyResult, primary), READONLY},
+    { "sub", T_OBJECT, offsetof(PyGpgmeGenkeyResult, sub), READONLY},
+    { "fpr", T_OBJECT, offsetof(PyGpgmeGenkeyResult, fpr), READONLY},
     { NULL, 0, 0, 0}
 };
 
 PyTypeObject PyGpgmeGenkeyResult_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.GenkeyResult",
     sizeof(PyGpgmeGenkeyResult),
     .tp_flags = Py_TPFLAGS_DEFAULT,
@@ -65,7 +64,8 @@
     self->primary = PyBool_FromLong(result->primary);
     self->sub = PyBool_FromLong(result->sub);
     if (result->fpr)
-        self->fpr = PyString_FromString(result->fpr);
+        self->fpr = PyUnicode_DecodeASCII(result->fpr, strlen(result->fpr),
+                                          "replace");
     else {
         Py_INCREF(Py_None);
         self->fpr = Py_None;
 
=== modified file 'src/pygpgme-import.c'
--- src/pygpgme-import.c	2006-02-14 04:07:06 +0000
+++ src/pygpgme-import.c	2010-03-25 00:48:28 +0000
@@ -42,33 +42,32 @@
 }
 
 static PyMemberDef pygpgme_import_members[] = {
-    { "considered", T_OBJECT, offsetof(PyGpgmeImportResult, considered), RO},
-    { "no_user_id", T_OBJECT, offsetof(PyGpgmeImportResult, no_user_id), RO},
-    { "imported", T_OBJECT, offsetof(PyGpgmeImportResult, imported), RO},
-    { "imported_rsa", T_OBJECT, offsetof(PyGpgmeImportResult, imported_rsa), RO},
-    { "unchanged", T_OBJECT, offsetof(PyGpgmeImportResult, unchanged), RO},
-    { "new_user_ids", T_OBJECT, offsetof(PyGpgmeImportResult, new_user_ids), RO},
-    { "new_sub_keys", T_OBJECT, offsetof(PyGpgmeImportResult, new_sub_keys), RO},
-    { "new_signatures", T_OBJECT, offsetof(PyGpgmeImportResult, new_signatures), RO},
+    { "considered", T_OBJECT, offsetof(PyGpgmeImportResult, considered), READONLY},
+    { "no_user_id", T_OBJECT, offsetof(PyGpgmeImportResult, no_user_id), READONLY},
+    { "imported", T_OBJECT, offsetof(PyGpgmeImportResult, imported), READONLY},
+    { "imported_rsa", T_OBJECT, offsetof(PyGpgmeImportResult, imported_rsa), READONLY},
+    { "unchanged", T_OBJECT, offsetof(PyGpgmeImportResult, unchanged), READONLY},
+    { "new_user_ids", T_OBJECT, offsetof(PyGpgmeImportResult, new_user_ids), READONLY},
+    { "new_sub_keys", T_OBJECT, offsetof(PyGpgmeImportResult, new_sub_keys), READONLY},
+    { "new_signatures", T_OBJECT, offsetof(PyGpgmeImportResult, new_signatures), READONLY},
     { "new_revocations", T_OBJECT,
-      offsetof(PyGpgmeImportResult, new_revocations), RO},
+      offsetof(PyGpgmeImportResult, new_revocations), READONLY},
     { "secret_read", T_OBJECT,
-      offsetof(PyGpgmeImportResult, secret_read), RO},
+      offsetof(PyGpgmeImportResult, secret_read), READONLY},
     { "secret_imported", T_OBJECT,
-      offsetof(PyGpgmeImportResult, secret_imported), RO},
+      offsetof(PyGpgmeImportResult, secret_imported), READONLY},
     { "secret_unchanged", T_OBJECT,
-      offsetof(PyGpgmeImportResult, secret_unchanged), RO},
+      offsetof(PyGpgmeImportResult, secret_unchanged), READONLY},
     { "skipped_new_keys", T_OBJECT,
-      offsetof(PyGpgmeImportResult, skipped_new_keys), RO},
+      offsetof(PyGpgmeImportResult, skipped_new_keys), READONLY},
     { "not_imported", T_OBJECT,
-      offsetof(PyGpgmeImportResult, not_imported), RO},
-    { "imports", T_OBJECT, offsetof(PyGpgmeImportResult, imports), RO},
+      offsetof(PyGpgmeImportResult, not_imported), READONLY},
+    { "imports", T_OBJECT, offsetof(PyGpgmeImportResult, imports), READONLY},
     { NULL, 0, 0, 0}
 };
 
 PyTypeObject PyGpgmeImportResult_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.Import",
     sizeof(PyGpgmeImportResult),
     .tp_flags = Py_TPFLAGS_DEFAULT,
@@ -115,10 +114,17 @@
     if (!self->imports)
         return NULL;
     for (status = result->imports; status != NULL; status = status->next) {
-        PyObject *item;
+        PyObject *py_fpr, *item;
 
-        item = Py_BuildValue("(zNi)",
-                             status->fpr,
+        if (status->fpr)
+            py_fpr = PyUnicode_DecodeASCII(status->fpr, strlen(status->fpr),
+                                           "replace");
+        else {
+            py_fpr = Py_None;
+            Py_INCREF(py_fpr);
+        }
+        item = Py_BuildValue("(NNi)",
+                             py_fpr,
                              pygpgme_error_object(status->result),
                              status->status);
         if (!item) {
 
=== modified file 'src/pygpgme-key.c'
--- src/pygpgme-key.c	2006-02-14 04:07:06 +0000
+++ src/pygpgme-key.c	2010-03-25 00:48:28 +0000
@@ -99,7 +99,8 @@
 pygpgme_subkey_get_keyid(PyGpgmeSubkey *self)
 {
     if (self->subkey->keyid)
-        return PyString_FromString(self->subkey->keyid);
+        return PyUnicode_DecodeASCII(self->subkey->keyid,
+                                     strlen(self->subkey->keyid), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -108,7 +109,8 @@
 pygpgme_subkey_get_fpr(PyGpgmeSubkey *self)
 {
     if (self->subkey->fpr)
-        return PyString_FromString(self->subkey->fpr);
+        return PyUnicode_DecodeASCII(self->subkey->fpr,
+                                     strlen(self->subkey->fpr), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -145,8 +147,7 @@
 };
 
 PyTypeObject PyGpgmeSubkey_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.Subkey",
     sizeof(PyGpgmeSubkey),
     .tp_flags = Py_TPFLAGS_DEFAULT,
@@ -198,7 +199,8 @@
 pygpgme_key_sig_get_keyid(PyGpgmeKeySig *self)
 {
     if (self->key_sig->keyid)
-        return PyString_FromString(self->key_sig->keyid);
+        return PyUnicode_DecodeASCII(self->key_sig->keyid,
+                                     strlen(self->key_sig->keyid), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -225,7 +227,8 @@
 pygpgme_key_sig_get_uid(PyGpgmeKeySig *self)
 {
     if (self->key_sig->uid)
-        return PyString_FromString(self->key_sig->uid);
+        return PyUnicode_DecodeUTF8(self->key_sig->uid,
+                                    strlen(self->key_sig->uid), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -234,7 +237,8 @@
 pygpgme_key_sig_get_name(PyGpgmeKeySig *self)
 {
     if (self->key_sig->name)
-        return PyString_FromString(self->key_sig->name);
+        return PyUnicode_DecodeUTF8(self->key_sig->name,
+                                    strlen(self->key_sig->name), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -243,7 +247,8 @@
 pygpgme_key_sig_get_email(PyGpgmeKeySig *self)
 {
     if (self->key_sig->email)
-        return PyString_FromString(self->key_sig->email);
+        return PyUnicode_DecodeUTF8(self->key_sig->email,
+                                    strlen(self->key_sig->email), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -252,7 +257,8 @@
 pygpgme_key_sig_get_comment(PyGpgmeKeySig *self)
 {
     if (self->key_sig->comment)
-        return PyString_FromString(self->key_sig->comment);
+        return PyUnicode_DecodeUTF8(self->key_sig->comment,
+                                    strlen(self->key_sig->comment), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -282,8 +288,7 @@
 };
 
 PyTypeObject PyGpgmeKeySig_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.KeySig",
     sizeof(PyGpgmeKeySig),
     .tp_flags = Py_TPFLAGS_DEFAULT,
@@ -323,7 +328,8 @@
 pygpgme_user_id_get_uid(PyGpgmeUserId *self)
 {
     if (self->user_id->uid)
-        return PyString_FromString(self->user_id->uid);
+        return PyUnicode_DecodeUTF8(self->user_id->uid,
+                                    strlen(self->user_id->uid), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -332,7 +338,8 @@
 pygpgme_user_id_get_name(PyGpgmeUserId *self)
 {
     if (self->user_id->name)
-        return PyString_FromString(self->user_id->name);
+        return PyUnicode_DecodeUTF8(self->user_id->name,
+                                    strlen(self->user_id->name), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -341,7 +348,8 @@
 pygpgme_user_id_get_email(PyGpgmeUserId *self)
 {
     if (self->user_id->email)
-        return PyString_FromString(self->user_id->email);
+        return PyUnicode_DecodeUTF8(self->user_id->email,
+                                    strlen(self->user_id->email), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -350,7 +358,8 @@
 pygpgme_user_id_get_comment(PyGpgmeUserId *self)
 {
     if (self->user_id->comment)
-        return PyString_FromString(self->user_id->comment);
+        return PyUnicode_DecodeUTF8(self->user_id->comment,
+                                    strlen(self->user_id->comment), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -394,8 +403,7 @@
 };
 
 PyTypeObject PyGpgmeUserId_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.UserId",
     sizeof(PyGpgmeUserId),
     .tp_flags = Py_TPFLAGS_DEFAULT,
@@ -476,7 +484,10 @@
 pygpgme_key_get_issuer_serial(PyGpgmeKey *self)
 {
     if (self->key->issuer_serial)
-        return PyString_FromString(self->key->issuer_serial);
+        /* Haven't tested this, so perhaps it should be UTF8 */
+        return PyUnicode_DecodeASCII(self->key->issuer_serial,
+                                     strlen(self->key->issuer_serial),
+                                     "replace");
     else
         Py_RETURN_NONE;
 }
@@ -485,7 +496,9 @@
 pygpgme_key_get_issuer_name(PyGpgmeKey *self)
 {
     if (self->key->issuer_name)
-        return PyString_FromString(self->key->issuer_name);
+        return PyUnicode_DecodeUTF8(self->key->issuer_name,
+                                    strlen(self->key->issuer_name),
+                                    "replace");
     else
         Py_RETURN_NONE;
 }
@@ -494,7 +507,9 @@
 pygpgme_key_get_chain_id(PyGpgmeKey *self)
 {
     if (self->key->chain_id)
-        return PyString_FromString(self->key->chain_id);
+        /* Haven't tested this, so perhaps it should be UTF8 */
+        return PyUnicode_DecodeASCII(self->key->chain_id,
+                                     strlen(self->key->chain_id), "replace");
     else
         Py_RETURN_NONE;
 }
@@ -585,8 +600,7 @@
 };
 
 PyTypeObject PyGpgmeKey_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.Key",
     sizeof(PyGpgmeKey),
     .tp_flags = Py_TPFLAGS_DEFAULT,
 
=== modified file 'src/pygpgme-keyiter.c'
--- src/pygpgme-keyiter.c	2006-02-14 04:07:06 +0000
+++ src/pygpgme-keyiter.c	2010-03-25 00:48:28 +0000
@@ -73,8 +73,7 @@
 }
 
 PyTypeObject PyGpgmeKeyIter_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.KeyIter",
     sizeof(PyGpgmeKeyIter),
     .tp_flags = Py_TPFLAGS_DEFAULT,
 
=== modified file 'src/pygpgme-signature.c'
--- src/pygpgme-signature.c	2006-02-14 04:07:06 +0000
+++ src/pygpgme-signature.c	2010-03-25 00:48:28 +0000
@@ -33,18 +33,17 @@
 }
 
 static PyMemberDef pygpgme_newsig_members[] = {
-    { "type", T_OBJECT, offsetof(PyGpgmeNewSignature, type), RO},
-    { "pubkey_algo", T_OBJECT, offsetof(PyGpgmeNewSignature, pubkey_algo), RO},
-    { "hash_algo", T_OBJECT, offsetof(PyGpgmeNewSignature, hash_algo), RO},
-    { "timestamp", T_OBJECT, offsetof(PyGpgmeNewSignature, timestamp), RO},
-    { "fpr", T_OBJECT, offsetof(PyGpgmeNewSignature, fpr), RO},
-    { "sig_class", T_OBJECT, offsetof(PyGpgmeNewSignature, sig_class), RO},
+    { "type", T_OBJECT, offsetof(PyGpgmeNewSignature, type), READONLY},
+    { "pubkey_algo", T_OBJECT, offsetof(PyGpgmeNewSignature, pubkey_algo), READONLY},
+    { "hash_algo", T_OBJECT, offsetof(PyGpgmeNewSignature, hash_algo), READONLY},
+    { "timestamp", T_OBJECT, offsetof(PyGpgmeNewSignature, timestamp), READONLY},
+    { "fpr", T_OBJECT, offsetof(PyGpgmeNewSignature, fpr), READONLY},
+    { "sig_class", T_OBJECT, offsetof(PyGpgmeNewSignature, sig_class), READONLY},
     { NULL, 0, 0, 0}
 };
 
 PyTypeObject PyGpgmeNewSignature_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.NewSignature",
     sizeof(PyGpgmeNewSignature),
     .tp_flags = Py_TPFLAGS_DEFAULT,
@@ -72,7 +71,8 @@
         item->hash_algo = PyInt_FromLong(sig->hash_algo);
         item->timestamp = PyInt_FromLong(sig->timestamp);
         if (sig->fpr) {
-            item->fpr = PyString_FromString(sig->fpr);
+            item->fpr = PyUnicode_DecodeASCII(sig->fpr, strlen(sig->fpr),
+                                              "replace");
         } else {
             Py_INCREF(Py_None);
             item->fpr = Py_None;
@@ -105,24 +105,23 @@
 }
 
 static PyMemberDef pygpgme_sig_members[] = {
-    { "summary", T_OBJECT, offsetof(PyGpgmeSignature, summary), RO},
-    { "fpr", T_OBJECT, offsetof(PyGpgmeSignature, fpr), RO},
-    { "status", T_OBJECT, offsetof(PyGpgmeSignature, status), RO},
-    { "notations", T_OBJECT, offsetof(PyGpgmeSignature, notations), RO},
-    { "timestamp", T_OBJECT, offsetof(PyGpgmeSignature, timestamp), RO},
+    { "summary", T_OBJECT, offsetof(PyGpgmeSignature, summary), READONLY},
+    { "fpr", T_OBJECT, offsetof(PyGpgmeSignature, fpr), READONLY},
+    { "status", T_OBJECT, offsetof(PyGpgmeSignature, status), READONLY},
+    { "notations", T_OBJECT, offsetof(PyGpgmeSignature, notations), READONLY},
+    { "timestamp", T_OBJECT, offsetof(PyGpgmeSignature, timestamp), READONLY},
     { "exp_timestamp", T_OBJECT,
-      offsetof(PyGpgmeSignature, exp_timestamp), RO},
+      offsetof(PyGpgmeSignature, exp_timestamp), READONLY},
     { "wrong_key_usage", T_OBJECT,
-      offsetof(PyGpgmeSignature, wrong_key_usage), RO},
-    { "validity", T_OBJECT, offsetof(PyGpgmeSignature, validity), RO},
+      offsetof(PyGpgmeSignature, wrong_key_usage), READONLY},
+    { "validity", T_OBJECT, offsetof(PyGpgmeSignature, validity), READONLY},
     { "validity_reason", T_OBJECT,
-      offsetof(PyGpgmeSignature, validity_reason), RO},
+      offsetof(PyGpgmeSignature, validity_reason), READONLY},
     { NULL, 0, 0, 0}
 };
 
 PyTypeObject PyGpgmeSignature_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,
+    PyVarObject_HEAD_INIT(NULL, 0)
     "gpgme.Signature",
     sizeof(PyGpgmeSignature),
     .tp_flags = Py_TPFLAGS_DEFAULT,
@@ -148,7 +147,8 @@
         }
         item->summary = PyInt_FromLong(sig->summary);
         if (sig->fpr) {
-            item->fpr = PyString_FromString(sig->fpr);
+            item->fpr = PyUnicode_DecodeASCII(sig->fpr, strlen(sig->fpr),
+                                              "replace");
         } else {
             Py_INCREF(Py_None);
             item->fpr = Py_None;
@@ -156,12 +156,17 @@
         item->status = pygpgme_error_object(sig->status);
         item->notations = PyList_New(0);
         for (not = sig->notations; not != NULL; not = not->next) {
-            PyObject *pynot = Py_BuildValue("(zz)", not->name, not->value);
-
-            if (!pynot)
+            PyObject *py_name, *py_value, *py_not;
+
+            py_name = PyUnicode_DecodeUTF8(not->name, not->name_len,
+                                           "replace");
+            py_value = PyBytes_FromStringAndSize(not->value, not->value_len);
+            py_not = Py_BuildValue("(NN)", py_name, py_value);
+
+            if (!py_not)
                 break;
-            PyList_Append(item->notations, pynot);
-            Py_DECREF(pynot);
+            PyList_Append(item->notations, py_not);
+            Py_DECREF(py_not);
         }
         item->timestamp = PyInt_FromLong(sig->timestamp);
         item->exp_timestamp = PyInt_FromLong(sig->exp_timestamp);
 
=== modified file 'src/pygpgme.h'
--- src/pygpgme.h	2008-10-15 21:36:35 +0000
+++ src/pygpgme.h	2010-03-25 00:48:28 +0000
@@ -23,6 +23,8 @@
 #include <Python.h>
 #include <gpgme.h>
 
+#include "pycompat.h"
+
 #define HIDDEN __attribute__((visibility("hidden")))
 
 typedef struct {