Merge lp:~jtaylor/ubuntu/oneiric/m2crypto/cleanup into lp:ubuntu/oneiric/m2crypto

[Julian Taylor]

remove undistributable file (see http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=634015)
merge with debian, fixes new openssl ftbs
switch do dh_python2
quiltify existing patches
add patch to fix testsuite for new openssl

=== modified file 'M2Crypto/m2urllib2.py'
--- M2Crypto/m2urllib2.py	2009-11-06 01:28:39 +0000
+++ M2Crypto/m2urllib2.py	2011-08-10 19:50:59 +0000
@@ -14,7 +14,6 @@
 import socket
 from urllib2 import *
 import urlparse
-import inspect
 
 import SSL
 import httpslib
 
=== added file 'debian/README.source'
--- debian/README.source	1970-01-01 00:00:00 +0000
+++ debian/README.source	2011-08-10 19:50:59 +0000
@@ -0,0 +1,2 @@
+removed non-free files in 0.20.1+dfsg1:
+demo/x509/proxylib.py
 
=== modified file 'debian/changelog'
--- debian/changelog	2010-12-03 00:04:32 +0000
+++ debian/changelog	2011-08-10 19:50:59 +0000
@@ -1,3 +1,34 @@
+m2crypto (0.20.1+dfsg1-1.1ubuntu1) oneiric; urgency=low
+
+  * repackage upstream
+    - remove non-free demo/x509/proxylib.py
+  * switch to dh_python2 (LP: #788514) 
+  * switch to 3.0 (quilt)
+    - converted all upstream changes to patches
+    - fix_sslv2_test.patch: testsuite patch for sslv2 deactivation
+    - fix_build_with_new_openssl.patch: build fix from debian 0.20.1-1.1
+  * Merge from debian testing, remaining changes:
+    - disable_sslv2_test.patch: disable sslv23_weak_crypto test as it is expected to
+      fail with SSLv2 having been disabled in openssl 0.9.8o-1ubuntu3.
+      (LP: #600549)
+    - fix_sslv2_test2.patch: fix testsuite with newer openssl. (LP: #600549)
+      - Backported from http://svn.osafoundation.org/viewvc/m2crypto/trunk/tests/test_smime.py?r1=698&r2=721
+    - debian/control: Add openssl for FTBFS. 
+    - debian/rules; enable testsuite, add more files to "clean" rule.
+    - fix_kill_signal.patch: use signal 9 to kill old s_server processes
+      to work around build HUP signal-ignore-mask (LP: #451998).
+
+ -- Julian Taylor <[e-mail]>  Wed, 10 Aug 2011 17:01:24 +0200
+
+m2crypto (0.20.1-1.1) unstable; urgency=low
+
+  * Non-maintainer upload.
+  * Backport revision 721 from upstream SVN repository to fix build errors
+    with libssl-dev >= 1.0.0. (Closes: #622001)
+  * Do not provide sslv2_method if SSLv2 is not available.
+
+ -- Sebastian Ramacher <[e-mail]>  Fri, 24 Jun 2011 17:27:46 +0200
+
 m2crypto (0.20.1-1ubuntu5) natty; urgency=low
 
   * Rebuild to add support for python 2.7.
 
=== modified file 'debian/control'
--- debian/control	2010-04-23 12:55:10 +0000
+++ debian/control	2011-08-10 19:50:59 +0000
@@ -3,7 +3,7 @@
 Priority: optional
 Maintainer: Ubuntu MOTU Developers <[e-mail]>
 XSBC-Original-Maintainer: Dima Barsky <[e-mail]>
-Build-Depends: debhelper (>= 5.0.37.2), python-all-dev (>= 2.3.5-11), python-support (>= 0.4), libssl-dev (>= 0.9.7), swig (>= 1.3.24), python-setuptools (>=0.6c5-3), openssl
+Build-Depends: debhelper (>= 5.0.37.2), python-all-dev (>= 2.6.6-3~), libssl-dev (>= 0.9.7), swig (>= 1.3.24), python-setuptools (>=0.6c5-3), openssl
 Standards-Version: 3.8.3
 
 Package: python-m2crypto
 
=== added directory 'debian/patches'
=== added file 'debian/patches/disable_sslv2_test.patch'
--- debian/patches/disable_sslv2_test.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/disable_sslv2_test.patch	2011-08-10 19:50:59 +0000
@@ -0,0 +1,17 @@
+Description: disable sslv2 test
+ disable sslv23_weak_crypto test as it is expected to
+ fail with SSLv2 having been disabled in openssl 0.9.8o-1ubuntu3.
+Bug.Ubuntu: https://bugs.launchpad.net/ubuntu/+source/m2crypto/+bug/600549
+Author: Marc Deslauriers <[e-mail]>
+Origin: 0.20.1-1ubuntu4
+--- m2crypto-0.20.1.orig/tests/test_ssl.py
++++ m2crypto-0.20.1/tests/test_ssl.py
+@@ -398,7 +398,7 @@ class MiscSSLClientTestCase(BaseSSLClien
+         finally:
+             self.stop_server(pid)
+ 
+-    def test_sslv23_weak_crypto(self):
++    def disabled_test_sslv23_weak_crypto(self):
+         if fips_mode: # TLS is required in FIPS mode
+             return
+         self.args = self.args + ['-no_tls1', '-no_ssl3']
 
=== added file 'debian/patches/fix_build_with_new_openssl.patch'
--- debian/patches/fix_build_with_new_openssl.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix_build_with_new_openssl.patch	2011-08-10 19:50:59 +0000
@@ -0,0 +1,487 @@
+Description: fix ftbs with openssl 1.0.0
+ Backport revision 721 from upstream SVN repository to fix build errors
+ with libssl-dev >= 1.0.0
+Bug-Debian: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=622001
+Author: Sebastian Ramacher <[e-mail]>
+--- m2crypto-0.20.1.orig/M2Crypto/m2urllib2.py
++++ m2crypto-0.20.1/M2Crypto/m2urllib2.py
+@@ -14,6 +14,7 @@ Summary of changes:
+ import socket
+ from urllib2 import *
+ import urlparse
++import inspect
+ 
+ import SSL
+ import httpslib
+--- m2crypto-0.20.1.orig/SWIG/_evp.i
++++ m2crypto-0.20.1/SWIG/_evp.i
+@@ -180,7 +180,7 @@ PyObject *pkcs5_pbkdf2_hmac_sha1(PyObjec
+ 
+     PKCS5_PBKDF2_HMAC_SHA1(passbuf, passlen, saltbuf, saltlen, iter,
+                            keylen, key);
+-    ret = PyString_FromStringAndSize(key, keylen);
++    ret = PyString_FromStringAndSize((char*)key, keylen);
+     OPENSSL_cleanse(key, keylen);
+     return ret;
+ }
+@@ -339,7 +339,7 @@ PyObject *bytes_to_key(const EVP_CIPHER
+     klen = EVP_BytesToKey(cipher, md, (unsigned char *)sbuf, 
+         (unsigned char *)dbuf, dlen, iter, 
+         key, NULL); /* Since we are not returning IV no need to derive it */
+-    ret = PyString_FromStringAndSize(key, klen);
++    ret = PyString_FromStringAndSize((char*)key, klen);
+     return ret;
+ }
+ 
+@@ -435,7 +435,7 @@ PyObject *sign_final(EVP_MD_CTX *ctx, EV
+         PyErr_SetString(_evp_err, ERR_reason_error_string(ERR_get_error()));
+         return NULL;
+     }
+-    ret = PyString_FromStringAndSize(sigbuf, siglen);
++    ret = PyString_FromStringAndSize((char*)sigbuf, siglen);
+     OPENSSL_cleanse(sigbuf, siglen);
+     OPENSSL_free(sigbuf);
+     return ret;
+@@ -513,7 +513,7 @@ PyObject *pkey_as_der(EVP_PKEY *pkey) {
+         PyErr_SetString(PyExc_ValueError, "EVP_PKEY as DER failed");
+         return NULL; 
+     }
+-    der = PyString_FromStringAndSize(pp, len);
++    der = PyString_FromStringAndSize((char*)pp, len);
+     OPENSSL_free(pp);
+     return der;
+ }
+--- m2crypto-0.20.1.orig/SWIG/_m2crypto.i
++++ m2crypto-0.20.1/SWIG/_m2crypto.i
+@@ -38,6 +38,19 @@ static PyObject *ssl_set_tmp_rsa_cb_func
+ #define CONST098
+ #endif
+ 
++/* Bring in STACK_OF macro definition */
++%include <openssl/safestack.h>
++
++/* Bring in LHASH_OF macro definition */
++/* XXX Can't include lhash.h where LHASH_OF is defined, because it includes
++   XXX stdio.h etc. which we fail to include. So we have to (re)define
++   XXX LHASH_OF here instead.
++%include <openssl/lhash.h>
++*/
++#if OPENSSL_VERSION_NUMBER >= 0x10000000L
++#define LHASH_OF(type) struct lhash_st_##type
++#endif
++
+ %include constraints.i
+ %include _threads.i
+ %include _lib.i
+--- m2crypto-0.20.1.orig/SWIG/_rand.i
++++ m2crypto-0.20.1/SWIG/_rand.i
+@@ -87,7 +87,7 @@ PyObject *rand_pseudo_bytes(int n) {
+         Py_INCREF(Py_None);
+         return Py_None;
+     } else {
+-        PyTuple_SET_ITEM(tuple, 0, PyString_FromStringAndSize(blob, n));
++        PyTuple_SET_ITEM(tuple, 0, PyString_FromStringAndSize((char*)blob, n));
+         PyMem_Free(blob);
+         PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong((long)ret));
+         return tuple;
+--- m2crypto-0.20.1.orig/SWIG/_pkcs7.i
++++ m2crypto-0.20.1/SWIG/_pkcs7.i
+@@ -12,7 +12,7 @@
+ %apply Pointer NONNULL { EVP_CIPHER * };
+ %apply Pointer NONNULL { EVP_PKEY * };
+ %apply Pointer NONNULL { PKCS7 * };
+-%apply Pointer NONNULL { STACK * };
++%apply Pointer NONNULL { STACK_OF(X509) * };
+ %apply Pointer NONNULL { X509 * };
+ 
+ %rename(pkcs7_new) PKCS7_new;
+@@ -54,8 +54,8 @@ void smime_init(PyObject *smime_err) {
+ 
+ %threadallow pkcs7_encrypt;
+ %inline %{
+-PKCS7 *pkcs7_encrypt(STACK *stack, BIO *bio, EVP_CIPHER *cipher, int flags) {
+-    return PKCS7_encrypt((STACK_OF(X509) *)stack, bio, cipher, flags);
++PKCS7 *pkcs7_encrypt(STACK_OF(X509) *stack, BIO *bio, EVP_CIPHER *cipher, int flags) {
++    return PKCS7_encrypt(stack, bio, cipher, flags);
+ }
+ 
+ PyObject *pkcs7_decrypt(PKCS7 *pkcs7, EVP_PKEY *pkey, X509 *cert, int flags) {
+@@ -96,14 +96,14 @@ PKCS7 *pkcs7_sign0(X509 *x509, EVP_PKEY
+ 
+ %threadallow pkcs7_sign1;
+ %inline %{
+-PKCS7 *pkcs7_sign1(X509 *x509, EVP_PKEY *pkey, STACK *stack, BIO *bio, int flags) {
+-    return PKCS7_sign(x509, pkey, (STACK_OF(X509) *)stack, bio, flags);
++PKCS7 *pkcs7_sign1(X509 *x509, EVP_PKEY *pkey, STACK_OF(X509) *stack, BIO *bio, int flags) {
++    return PKCS7_sign(x509, pkey, stack, bio, flags);
+ }
+ %}
+ 
+ %threadallow pkcs7_verify1;
+ %inline %{
+-PyObject *pkcs7_verify1(PKCS7 *pkcs7, STACK *stack, X509_STORE *store, BIO *data, int flags) {
++PyObject *pkcs7_verify1(PKCS7 *pkcs7, STACK_OF(X509) *stack, X509_STORE *store, BIO *data, int flags) {
+     int outlen;
+     char *outbuf;
+     BIO *bio;
+@@ -113,7 +113,7 @@ PyObject *pkcs7_verify1(PKCS7 *pkcs7, ST
+         PyErr_SetString(PyExc_MemoryError, "pkcs7_verify1");
+         return NULL;
+     }
+-    if (!PKCS7_verify(pkcs7, (STACK_OF(X509) *)stack, store, data, bio, flags)) {
++    if (!PKCS7_verify(pkcs7, stack, store, data, bio, flags)) {
+         PyErr_SetString(_pkcs7_err, ERR_reason_error_string(ERR_get_error()));
+         BIO_free(bio);
+         return NULL;
+@@ -131,7 +131,7 @@ PyObject *pkcs7_verify1(PKCS7 *pkcs7, ST
+     return ret;
+ }
+ 
+-PyObject *pkcs7_verify0(PKCS7 *pkcs7, STACK *stack, X509_STORE *store, int flags) {
++PyObject *pkcs7_verify0(PKCS7 *pkcs7, STACK_OF(X509) *stack, X509_STORE *store, int flags) {
+     return pkcs7_verify1(pkcs7, stack, store, NULL, flags);
+ }
+ %}
+@@ -229,7 +229,7 @@ int smime_crlf_copy(BIO *in, BIO *out) {
+ }
+ 
+ /* return STACK_OF(X509)* */     
+-STACK *pkcs7_get0_signers(PKCS7 *p7, STACK *certs, int flags) {     
++STACK_OF(X509) *pkcs7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags) {     
+     return PKCS7_get0_signers(p7, certs, flags);      
+ }
+ 
+--- m2crypto-0.20.1.orig/SWIG/_util.i
++++ m2crypto-0.20.1/SWIG/_util.i
+@@ -48,7 +48,7 @@ PyObject *util_string_to_hex(PyObject *b
+         PyErr_SetString(_util_err, ERR_reason_error_string(ERR_get_error()));
+         return NULL;
+     }
+-    obj = PyString_FromStringAndSize(ret, len);
++    obj = PyString_FromStringAndSize((char*)ret, len);
+     OPENSSL_free(ret);
+     return obj;
+ }
+--- m2crypto-0.20.1.orig/SWIG/_x509.i
++++ m2crypto-0.20.1/SWIG/_x509.i
+@@ -148,8 +148,15 @@ extern int X509_NAME_add_entry_by_NID(X5
+ extern int X509_NAME_print_ex(BIO *, X509_NAME *, int, unsigned long);
+ %rename(x509_name_print_ex_fp) X509_NAME_print_ex_fp;
+ extern int X509_NAME_print_ex_fp(FILE *, X509_NAME *, int, unsigned long);
++
++#if OPENSSL_VERSION_NUMBER >= 0x10000000L
++%rename(x509_name_hash) X509_NAME_hash_old;
++extern unsigned long X509_NAME_hash_old(X509_NAME *);
++#else
+ %rename(x509_name_hash) X509_NAME_hash;
+ extern unsigned long X509_NAME_hash(X509_NAME *);
++#endif
++
+ %rename(x509_name_get_index_by_nid) X509_NAME_get_index_by_NID;
+ extern int X509_NAME_get_index_by_NID(X509_NAME *, int, int);
+ 
+@@ -171,7 +178,7 @@ extern ASN1_STRING *X509_NAME_ENTRY_get_
+     if (PyString_Check($input)) {
+         Py_ssize_t len;
+ 
+-        $1 = PyString_AsString($input); 
++        $1 = (unsigned char *)PyString_AsString($input); 
+         len = PyString_Size($input);
+         if (len > INT_MAX) {
+             PyErr_SetString(PyExc_ValueError, "object too large");
+@@ -184,7 +191,7 @@ extern ASN1_STRING *X509_NAME_ENTRY_get_
+     }
+ }
+ %rename(x509_name_entry_set_data) X509_NAME_ENTRY_set_data;
+-extern int X509_NAME_ENTRY_set_data( X509_NAME_ENTRY *, int, CONST unsigned char *, int);
++extern int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *, int, CONST unsigned char *, int);
+ %typemap(in) (CONST unsigned char *, int);
+ 
+ %rename(x509_req_new) X509_REQ_new;
+@@ -230,7 +237,7 @@ extern int X509_STORE_CTX_get_error_dept
+ %rename(x509_store_ctx_free) X509_STORE_CTX_free;
+ extern void X509_STORE_CTX_free(X509_STORE_CTX *);
+ %rename(x509_store_ctx_get1_chain) X509_STORE_CTX_get1_chain;
+-extern STACK *X509_STORE_CTX_get1_chain(X509_STORE_CTX *);
++extern STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *);
+ 
+ %rename(x509_extension_get_critical) X509_EXTENSION_get_critical;
+ extern int X509_EXTENSION_get_critical(X509_EXTENSION *);
+@@ -348,7 +355,7 @@ PyObject *i2d_x509(X509 *x)
+         PyErr_SetString(_x509_err, ERR_reason_error_string(ERR_get_error()));
+     }
+     else {     
+-        ret = PyString_FromStringAndSize(buf, len);
++        ret = PyString_FromStringAndSize((char*)buf, len);
+         OPENSSL_free(buf);
+     }
+     return ret;
+@@ -435,12 +442,12 @@ PyObject *x509_name_by_nid(X509_NAME *na
+ }
+ 
+ int x509_name_set_by_nid(X509_NAME *name, int nid, PyObject *obj) {
+-    return X509_NAME_add_entry_by_NID(name, nid, MBSTRING_ASC, PyString_AsString(obj), -1, -1, 0);
++    return X509_NAME_add_entry_by_NID(name, nid, MBSTRING_ASC, (unsigned char *)PyString_AsString(obj), -1, -1, 0);
+ }
+ 
+ /* x509_name_add_entry_by_txt */
+ int x509_name_add_entry_by_txt(X509_NAME *name, char *field, int type, char *bytes, int len, int loc, int set) {
+-    return X509_NAME_add_entry_by_txt(name, field, type, bytes, len, loc, set);
++    return X509_NAME_add_entry_by_txt(name, field, type, (unsigned char *)bytes, len, loc, set);
+ }
+ 
+ PyObject *x509_name_get_der(X509_NAME *name)
+@@ -450,23 +457,23 @@ PyObject *x509_name_get_der(X509_NAME *n
+ }
+ 
+ /* sk_X509_new_null() is a macro returning "STACK_OF(X509) *". */
+-STACK *sk_x509_new_null(void) {
+-    return (STACK *)sk_X509_new_null();
++STACK_OF(X509) *sk_x509_new_null(void) {
++    return sk_X509_new_null();
+ }
+ 
+ /* sk_X509_free() is a macro. */
+-void sk_x509_free(STACK *stack) {
+-    sk_X509_free((STACK_OF(X509) *)stack);
++void sk_x509_free(STACK_OF(X509) *stack) {
++    sk_X509_free(stack);
+ }
+ 
+ /* sk_X509_push() is a macro. */
+-int sk_x509_push(STACK *stack, X509 *x509) {
+-    return sk_X509_push((STACK_OF(X509) *)stack, x509);
++int sk_x509_push(STACK_OF(X509) *stack, X509 *x509) {
++    return sk_X509_push(stack, x509);
+ }
+ 
+ /* sk_X509_pop() is a macro. */
+-X509 *sk_x509_pop(STACK *stack) {
+-    return sk_X509_pop((STACK_OF(X509) *)stack);
++X509 *sk_x509_pop(STACK_OF(X509) *stack) {
++    return sk_X509_pop(stack);
+ }
+ 
+ int x509_store_load_locations(X509_STORE *store, const char *file) {
+@@ -493,21 +500,29 @@ int x509_req_set_version(X509_REQ *x, lo
+     return X509_REQ_set_version(x, version);
+ }
+ 
+-int x509_req_add_extensions(X509_REQ *req, STACK *exts) {
+-    return X509_REQ_add_extensions(req, (STACK_OF(X509_EXTENSION) *)exts);
++int x509_req_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts) {
++    return X509_REQ_add_extensions(req, exts);
+ }
+ 
+-X509_NAME_ENTRY *x509_name_entry_create_by_txt( X509_NAME_ENTRY **ne, char *field, int type, char *bytes, int len) {
+-    return X509_NAME_ENTRY_create_by_txt( ne, field, type, bytes, len);
++X509_NAME_ENTRY *x509_name_entry_create_by_txt(X509_NAME_ENTRY **ne, char *field, int type, char *bytes, int len) {
++    return X509_NAME_ENTRY_create_by_txt( ne, field, type, (unsigned char *)bytes, len);
+ }
+ 
+-LHASH * 
+-x509v3_lhash(){ 
+-       return lh_new(NULL,NULL);
++#if OPENSSL_VERSION_NUMBER >= 0x10000000L
++LHASH_OF(CONF_VALUE) 
++#else
++LHASH
++#endif
++*x509v3_lhash() { 
++    return lh_new(NULL, NULL); /* Should probably be lh_CONF_VALUE_new but won't compile. */
+ }
+ 
+ X509V3_CTX *
+-x509v3_set_conf_lhash(LHASH * lhash){
++#if OPENSSL_VERSION_NUMBER >= 0x10000000L
++x509v3_set_conf_lhash(LHASH_OF(CONF_VALUE) * lhash) {
++#else
++x509v3_set_conf_lhash(LHASH                * lhash) {
++#endif
+       X509V3_CTX * ctx;
+       if (!(ctx=(X509V3_CTX *)PyMem_Malloc(sizeof(X509V3_CTX)))) {
+           PyErr_SetString(PyExc_MemoryError, "x509v3_set_conf_lhash");
+@@ -517,11 +532,20 @@ x509v3_set_conf_lhash(LHASH * lhash){
+       return ctx;
+ }
+ 
+-X509_EXTENSION *x509v3_ext_conf(LHASH *conf, X509V3_CTX *ctx, char *name, char *value) {
++X509_EXTENSION *
++#if OPENSSL_VERSION_NUMBER >= 0x10000000L
++x509v3_ext_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, char *name, char *value) {
++#else
++x509v3_ext_conf(LHASH                *conf, X509V3_CTX *ctx, char *name, char *value) {
++#endif
+       X509_EXTENSION * ext = NULL;
+       ext = X509V3_EXT_conf(conf, ctx, name, value); 
+       PyMem_Free(ctx); 
++#if OPENSSL_VERSION_NUMBER >= 0x10000000L
++      lh_CONF_VALUE_free(conf);
++#else
+       lh_free(conf);
++#endif
+       return ext;
+ }
+ 
+@@ -543,33 +567,33 @@ PyObject *x509_extension_get_name(X509_E
+ }
+ 
+ /* sk_X509_EXTENSION_new_null is a macro. */
+-STACK *sk_x509_extension_new_null(void) {
+-    return (STACK *)sk_X509_EXTENSION_new_null();
++STACK_OF(X509_EXTENSION) *sk_x509_extension_new_null(void) {
++    return sk_X509_EXTENSION_new_null();
+ }
+ 
+ /* sk_X509_EXTENSION_free() is a macro. */
+-void sk_x509_extension_free(STACK *stack) {
+-    sk_X509_EXTENSION_free((STACK_OF(X509_EXTENSION) *)stack);
++void sk_x509_extension_free(STACK_OF(X509_EXTENSION) *stack) {
++    sk_X509_EXTENSION_free(stack);
+ }
+ 
+ /* sk_X509_EXTENSION_push() is a macro. */
+-int sk_x509_extension_push(STACK *stack, X509_EXTENSION *x509_ext) {
+-    return sk_X509_EXTENSION_push((STACK_OF(X509_EXTENSION) *)stack, x509_ext);
++int sk_x509_extension_push(STACK_OF(X509_EXTENSION) *stack, X509_EXTENSION *x509_ext) {
++    return sk_X509_EXTENSION_push(stack, x509_ext);
+ }
+ 
+ /* sk_X509_EXTENSION_pop() is a macro. */
+-X509_EXTENSION *sk_x509_extension_pop(STACK *stack) {
+-    return sk_X509_EXTENSION_pop((STACK_OF(X509_EXTENSION) *)stack);
++X509_EXTENSION *sk_x509_extension_pop(STACK_OF(X509_EXTENSION) *stack) {
++    return sk_X509_EXTENSION_pop(stack);
+ }
+ 
+ /* sk_X509_EXTENSION_num() is a macro. */
+-int sk_x509_extension_num(STACK *stack) {
+-    return sk_X509_EXTENSION_num((STACK_OF(X509_EXTENSION) *)stack);
++int sk_x509_extension_num(STACK_OF(X509_EXTENSION) *stack) {
++    return sk_X509_EXTENSION_num(stack);
+ }
+ 
+ /* sk_X509_EXTENSION_value() is a macro. */
+-X509_EXTENSION *sk_x509_extension_value(STACK *stack, int i) {
+-    return sk_X509_EXTENSION_value((STACK_OF(X509_EXTENSION) *)stack, i);
++X509_EXTENSION *sk_x509_extension_value(STACK_OF(X509_EXTENSION) *stack, int i) {
++    return sk_X509_EXTENSION_value(stack, i);
+ }
+ 
+ /* X509_STORE_CTX_get_app_data is a macro. */
+@@ -590,7 +614,7 @@ Used in the wrapping of ASN1_seq_unpack
+ #define I2DTYPE int (*)()
+ #endif   
+ 
+-STACK *
++STACK_OF(X509) *
+ make_stack_from_der_sequence(PyObject * pyEncodedString){
+     STACK_OF(X509) *certs;
+     Py_ssize_t encoded_string_len;
+@@ -606,7 +630,7 @@ make_stack_from_der_sequence(PyObject *
+         return NULL;
+     }
+ 
+-    certs = ASN1_seq_unpack((unsigned char *)encoded_string, encoded_string_len, (D2ITYPE)d2i_X509, (void(*)())X509_free ); 
++    certs = ASN1_seq_unpack_X509((unsigned char *)encoded_string, encoded_string_len, d2i_X509, X509_free ); 
+     if (!certs) {
+        PyErr_SetString(_x509_err, ERR_reason_error_string(ERR_get_error()));
+        return NULL;
+@@ -616,13 +640,13 @@ make_stack_from_der_sequence(PyObject *
+ }
+ 
+ PyObject *
+-get_der_encoding_stack(STACK * stack){
++get_der_encoding_stack(STACK_OF(X509) *stack){
+     PyObject * encodedString;
+     
+     unsigned char * encoding;
+     int len; 
+     
+-    encoding = ASN1_seq_pack((STACK_OF(X509)*) stack, (I2DTYPE)i2d_X509, NULL, &len); 
++    encoding = ASN1_seq_pack_X509(stack, i2d_X509, NULL, &len); 
+     if (!encoding) {
+        PyErr_SetString(_x509_err, ERR_reason_error_string(ERR_get_error()));
+        return NULL;
+--- m2crypto-0.20.1.orig/SWIG/_aes.i
++++ m2crypto-0.20.1/SWIG/_aes.i
+@@ -76,7 +76,7 @@ PyObject *AES_crypt(const AES_KEY *key,
+         AES_encrypt((const unsigned char *)in, out, key);
+     else
+         AES_decrypt((const unsigned char *)in, out, key);
+-    return PyString_FromStringAndSize(out, outlen);
++    return PyString_FromStringAndSize((char*)out, outlen);
+ }
+ 
+ int AES_type_check(AES_KEY *key) {
+--- m2crypto-0.20.1.orig/SWIG/_ssl.i
++++ m2crypto-0.20.1/SWIG/_ssl.i
+@@ -17,13 +17,17 @@
+ %apply Pointer NONNULL { SSL_CTX * };
+ %apply Pointer NONNULL { SSL * };
+ %apply Pointer NONNULL { SSL_CIPHER * };
+-%apply Pointer NONNULL { STACK * };
++%apply Pointer NONNULL { STACK_OF(SSL_CIPHER) * };
++%apply Pointer NONNULL { STACK_OF(X509) * };
+ %apply Pointer NONNULL { BIO * };
+ %apply Pointer NONNULL { DH * };
+ %apply Pointer NONNULL { RSA * };
+ %apply Pointer NONNULL { EVP_PKEY *};
+ %apply Pointer NONNULL { PyObject *pyfunc };
+ 
++%rename(ssl_get_ciphers) SSL_get_ciphers;
++extern STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *ssl);
++
+ %rename(ssl_get_version) SSL_get_version;
+ extern const char *SSL_get_version(CONST SSL *);
+ %rename(ssl_get_error) SSL_get_error;
+@@ -41,8 +45,10 @@ extern const char *SSL_alert_desc_string
+ %rename(ssl_get_alert_desc_v) SSL_alert_desc_string_long;
+ extern const char *SSL_alert_desc_string_long(int);
+ 
++#ifndef OPENSSL_NO_SSL2
+ %rename(sslv2_method) SSLv2_method;
+ extern SSL_METHOD *SSLv2_method(void);
++#endif
+ %rename(sslv3_method) SSLv3_method;
+ extern SSL_METHOD *SSLv3_method(void);
+ %rename(sslv23_method) SSLv23_method;
+@@ -668,28 +674,24 @@ int ssl_cipher_get_bits(SSL_CIPHER *c) {
+     return SSL_CIPHER_get_bits(c, NULL);
+ }
+ 
+-STACK *ssl_get_ciphers(SSL *ssl) {
+-    return (STACK *)SSL_get_ciphers(ssl);
+-}
+-
+-int sk_ssl_cipher_num(STACK *stack) {
+-    return sk_num(stack);
++int sk_ssl_cipher_num(STACK_OF(SSL_CIPHER) *stack) {
++    return sk_SSL_CIPHER_num(stack);
+ }
+ 
+-SSL_CIPHER *sk_ssl_cipher_value(STACK *stack, int idx) {
+-    return (SSL_CIPHER *)sk_value(stack, idx);
++SSL_CIPHER *sk_ssl_cipher_value(STACK_OF(SSL_CIPHER) *stack, int idx) {
++    return sk_SSL_CIPHER_value(stack, idx);
+ }
+ 
+-STACK *ssl_get_peer_cert_chain(SSL *ssl) {
+-    return (STACK *)SSL_get_peer_cert_chain(ssl);
++STACK_OF(X509) *ssl_get_peer_cert_chain(SSL *ssl) {
++    return SSL_get_peer_cert_chain(ssl);
+ }
+ 
+-int sk_x509_num(STACK *stack) {
+-    return sk_num(stack);
++int sk_x509_num(STACK_OF(X509) *stack) {
++    return sk_X509_num(stack);
+ }
+ 
+-X509 *sk_x509_value(STACK *stack, int idx) {
+-    return (X509 *)sk_value(stack, idx);
++X509 *sk_x509_value(STACK_OF(X509) *stack, int idx) {
++    return sk_X509_value(stack, idx);
+ }
+ %}
+ 
 
=== added file 'debian/patches/fix_kill_signal.patch'
--- debian/patches/fix_kill_signal.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix_kill_signal.patch	2011-08-10 19:50:59 +0000
@@ -0,0 +1,17 @@
+Description: fix kill signal
+ use signal 9 to kill old s_server processes
+ to work around build HUP signal-ignore-mask (LP: #451998).
+Author: Chuck Short <[e-mail]>
+Origin: 0.20.1-1ubuntu1
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/451998
+--- m2crypto-0.20.1.orig/tests/test_ssl.py
++++ m2crypto-0.20.1/tests/test_ssl.py
+@@ -92,7 +92,7 @@ class BaseSSLClientTestCase(unittest.Tes
+             return pid
+ 
+     def stop_server(self, pid):
+-        os.kill(pid, 1)
++        os.kill(pid, 9)
+         os.waitpid(pid, 0)
+ 
+     def http_get(self, s):
 
=== added file 'debian/patches/fix_sslv2_test.patch'
--- debian/patches/fix_sslv2_test.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix_sslv2_test.patch	2011-08-10 19:50:59 +0000
@@ -0,0 +1,19 @@
+Description: fix test_sslv23_no_v2_no_service test
+ sslv2 is disabled in openssl 1.0.0  thus sslv23 will build up an sslv3
+ connection instead of throwing an error
+Author: Julian Taylor <[e-mail]>
+Forwarded: no
+=== modified file 'tests/test_ssl.py'
+--- m2crypto.orig/tests/test_ssl.py	2010-10-01 11:58:15 +0000
++++ m2crypto/tests/test_ssl.py		2011-08-10 17:25:08 +0000
+@@ -392,7 +392,8 @@
+         try:
+             ctx = SSL.Context('sslv23')
+             s = SSL.Connection(ctx)
+-            self.assertRaises(SSL.SSLError, s.connect, self.srv_addr)
++            s.connect(self.srv_addr)
++            self.failUnlessEqual(s.get_version(), 'SSLv3')
+             s.close()
+         finally:
+             self.stop_server(pid)
+
 
=== added file 'debian/patches/fix_sslv2_test2.patch'
--- debian/patches/fix_sslv2_test2.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix_sslv2_test2.patch	2011-08-10 19:50:59 +0000
@@ -0,0 +1,54 @@
+Description: fix testsuite for newer openssl
+Origin: 0.20.1-1ubuntu3
+Applied-Upstream: http://svn.osafoundation.org/viewvc/m2crypto/trunk/tests/test_smime.py?r1=698&r2=721
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu/+source/m2crypto/+bug/600549
+Author: Marc Deslauriers <[e-mail]>
+--- m2crypto-0.20.1.orig/tests/test_smime.py
++++ m2crypto-0.20.1/tests/test_smime.py
+@@ -37,7 +37,7 @@ class SMIMETestCase(unittest.TestCase):
+         buf = BIO.MemoryBuffer(self.cleartext)
+         s = SMIME.SMIME()
+         s.load_key('tests/signer_key.pem', 'tests/signer.pem')
+-        p7 = s.sign(buf)
++        p7 = s.sign(buf, SMIME.PKCS7_DETACHED)
+         assert len(buf) == 0
+         assert p7.type() == SMIME.PKCS7_SIGNED, p7.type()
+         assert isinstance(p7, SMIME.PKCS7), p7
+@@ -73,9 +73,8 @@ class SMIMETestCase(unittest.TestCase):
+         
+         p7, data = SMIME.smime_load_pkcs7_bio(self.signed)
+         
+-        assert data.read() == self.cleartext
+         assert isinstance(p7, SMIME.PKCS7), p7
+-        v = s.verify(p7)
++        v = s.verify(p7, data) 
+         assert v == self.cleartext
+     
+         t = p7.get0_signers(sk)
+@@ -169,7 +168,7 @@ class SMIMETestCase(unittest.TestCase):
+         s.set_cipher(SMIME.Cipher('des_ede3_cbc'))
+         
+         tmp = BIO.MemoryBuffer()
+-        s.write(tmp, p7, buf)
++        s.write(tmp, p7)
+ 
+         p7 = s.encrypt(tmp)
+         
+@@ -211,6 +210,7 @@ class WriteLoadTestCase(unittest.TestCas
+         assert p7.write(f) == 1
+         f.close()
+ 
++        p7 = s.sign(BIO.MemoryBuffer('some text'), SMIME.PKCS7_DETACHED)
+         self.filenameSmime = 'tests/sig.p7s'
+         f = BIO.openfile(self.filenameSmime, 'wb')
+         assert s.write(f, p7, BIO.MemoryBuffer('some text')) == 1
+@@ -220,7 +220,7 @@ class WriteLoadTestCase(unittest.TestCas
+         buf = BIO.MemoryBuffer()
+         assert SMIME.load_pkcs7(self.filename).write_der(buf) == 1
+         s = buf.read()
+-        assert len(s) == 1204, len(s)
++        assert len(s) in (1204, 1243), len(s)
+         
+     def test_load_pkcs7(self):
+         assert SMIME.load_pkcs7(self.filename).type() == SMIME.PKCS7_SIGNED
+
 
=== added file 'debian/patches/series'
--- debian/patches/series	1970-01-01 00:00:00 +0000
+++ debian/patches/series	2011-08-10 19:50:59 +0000
@@ -0,0 +1,5 @@
+disable_sslv2_test.patch
+fix_build_with_new_openssl.patch
+fix_kill_signal.patch
+fix_sslv2_test2.patch
+fix_sslv2_test.patch
 
=== modified file 'debian/rules'
--- debian/rules	2009-10-16 12:51:15 +0000
+++ debian/rules	2011-08-10 19:50:59 +0000
@@ -73,7 +73,7 @@
 	dh_strip
 	dh_compress
 	dh_fixperms
-	dh_pysupport
+	dh_python2
 	dh_installdeb
 	dh_shlibdeps
 	dh_gencontrol
 
=== added directory 'debian/source'
=== added file 'debian/source/format'
--- debian/source/format	1970-01-01 00:00:00 +0000
+++ debian/source/format	2011-08-10 19:50:59 +0000
@@ -0,0 +1,1 @@
+3.0 (quilt)
 
=== modified file 'debian/watch'
--- debian/watch	2009-06-15 22:11:39 +0000
+++ debian/watch	2011-08-10 19:50:59 +0000
@@ -1,2 +1,3 @@
 version=3
+opts=dversionmangle=s/\+dfsg// \
 http://pypi.python.org/packages/source/M/M2Crypto/M2Crypto-(.*).tar.gz
 
=== modified file 'tests/test_smime.py'
--- tests/test_smime.py	2010-07-09 11:17:57 +0000
+++ tests/test_smime.py	2011-08-10 19:50:59 +0000
@@ -37,7 +37,7 @@
         buf = BIO.MemoryBuffer(self.cleartext)
         s = SMIME.SMIME()
         s.load_key('tests/signer_key.pem', 'tests/signer.pem')
-        p7 = s.sign(buf, SMIME.PKCS7_DETACHED)
+        p7 = s.sign(buf)
         assert len(buf) == 0
         assert p7.type() == SMIME.PKCS7_SIGNED, p7.type()
         assert isinstance(p7, SMIME.PKCS7), p7
@@ -73,8 +73,9 @@
         
         p7, data = SMIME.smime_load_pkcs7_bio(self.signed)
         
+        assert data.read() == self.cleartext
         assert isinstance(p7, SMIME.PKCS7), p7
-        v = s.verify(p7, data) 
+        v = s.verify(p7)
         assert v == self.cleartext
     
         t = p7.get0_signers(sk)
@@ -168,7 +169,7 @@
         s.set_cipher(SMIME.Cipher('des_ede3_cbc'))
         
         tmp = BIO.MemoryBuffer()
-        s.write(tmp, p7)
+        s.write(tmp, p7, buf)
 
         p7 = s.encrypt(tmp)
         
 
=== modified file 'tests/test_ssl.py'
--- tests/test_ssl.py	2010-10-01 11:58:15 +0000
+++ tests/test_ssl.py	2011-08-10 19:50:59 +0000
@@ -92,7 +92,7 @@
             return pid
 
     def stop_server(self, pid):
-        os.kill(pid, 9)
+        os.kill(pid, 1)
         os.waitpid(pid, 0)
 
     def http_get(self, s):
@@ -397,7 +397,7 @@
         finally:
             self.stop_server(pid)
 
-    def disabled_test_sslv23_weak_crypto(self):
+    def test_sslv23_weak_crypto(self):
         if fips_mode: # TLS is required in FIPS mode
             return
         self.args = self.args + ['-no_tls1', '-no_ssl3']