Add support for CRL and Revoked objects.
diff --git a/src/crypto/crl.c b/src/crypto/crl.c
new file mode 100644
index 0000000..c90cbe8
--- /dev/null
+++ b/src/crypto/crl.c
@@ -0,0 +1,294 @@
+#include <Python.h>
+#define crypto_MODULE
+#include "crypto.h"
+
+
+static X509_REVOKED * X509_REVOKED_dup(X509_REVOKED *orig)
+{
+ X509_REVOKED *dupe = NULL;
+
+ dupe = X509_REVOKED_new();
+ if(dupe == NULL)
+ return NULL;
+ if(orig->serialNumber)
+ {
+ dupe->serialNumber = M_ASN1_INTEGER_dup(orig->serialNumber);
+ }
+ if(orig->revocationDate)
+ {
+ dupe->revocationDate = M_ASN1_INTEGER_dup(orig->revocationDate);
+ }
+ if(orig->extensions)
+ {
+ STACK_OF(X509_EXTENSION) *sk = NULL;
+ X509_EXTENSION * ext;
+ int j;
+
+ sk = sk_X509_EXTENSION_new_null();
+ for(j = 0; j < sk_X509_EXTENSION_num(orig->extensions); j++) {
+ ext = sk_X509_EXTENSION_value(orig->extensions, j);
+ ext = X509_EXTENSION_dup(ext);
+ sk_X509_EXTENSION_push(sk, ext);
+ }
+ dupe->extensions = sk;
+ }
+ dupe->sequence = orig->sequence;
+ return dupe;
+}
+
+static char crypto_CRL_get_revoked_doc[] = "\n\
+Return revoked portion of the CRL structure (by value\n\
+not reference).\n\
+\n\
+@return: A tuple of Revoked objects.\n\
+";
+static PyObject *
+crypto_CRL_get_revoked(crypto_CRLObj *self, PyObject *args)
+{
+ int j, num_rev;
+ X509_REVOKED *r = NULL;
+ PyObject *obj = NULL, *rev_obj;
+
+ if (!PyArg_ParseTuple(args, ":get_revoked"))
+ return NULL;
+
+ num_rev = sk_X509_REVOKED_num(self->crl->crl->revoked);
+ if(num_rev < 0)
+ {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ if ((obj = PyTuple_New(num_rev)) == NULL)
+ return NULL;
+
+ for(j = 0; j < num_rev; j++)
+ {
+ r = sk_X509_REVOKED_value(self->crl->crl->revoked, j);
+ r = X509_REVOKED_dup(r);
+ if( r == NULL )
+ goto error;
+ rev_obj = (PyObject *) crypto_Revoked_New(r);
+ if( rev_obj == NULL )
+ goto error;
+ r = NULL; /* it's now owned by rev_obj */
+ PyTuple_SET_ITEM(obj, j, rev_obj);
+ }
+ return obj;
+
+ error:
+ if(r)
+ X509_REVOKED_free(r);
+ Py_XDECREF(obj);
+ return NULL;
+}
+
+static char crypto_CRL_add_revoked_doc[] = "\n\
+Add a revoked (by value not reference) to the CRL structure\n\
+\n\
+@param cert: The new revoked.\n\
+@type cert: L{X509}\n\
+@return: None\n\
+";
+static PyObject *
+crypto_CRL_add_revoked(crypto_CRLObj *self, PyObject *args, PyObject *keywds)
+{
+ crypto_RevokedObj * rev_obj = NULL;
+ static char *kwlist[] = {"revoked", NULL};
+ X509_REVOKED * dup;
+
+ if (!PyArg_ParseTupleAndKeywords(args, keywds, "O!:add_revoked",
+ kwlist, &crypto_Revoked_Type, &rev_obj))
+ return NULL;
+
+ dup = X509_REVOKED_dup( rev_obj->revoked );
+ if(dup == NULL)
+ return NULL;
+ X509_CRL_add0_revoked(self->crl, dup);
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static char crypto_CRL_export_doc[] = "\n\
+Export a CRL as a string\n\
+\n\
+@param cert: Used to sign CRL.\n\
+@type cert: L{X509}\n\
+@param key: Used to sign CRL.\n\
+@type key: L{PKey}\n\
+@return: None\n\
+";
+static PyObject *
+crypto_CRL_export(crypto_CRLObj *self, PyObject *args, PyObject *keywds)
+{
+ int ret, buf_len, type = X509_FILETYPE_PEM, days = 100;
+ char *temp;
+ BIO *bio;
+ PyObject *buffer;
+ crypto_PKeyObj *key;
+ ASN1_TIME *tmptm;
+ crypto_X509Obj *x509;
+ static char *kwlist[] = {"cert", "key", "type", "days", NULL};
+
+ if (!PyArg_ParseTupleAndKeywords(args, keywds, "O!O!|ii:dump_crl", kwlist,
+ &crypto_X509_Type, &x509,
+ &crypto_PKey_Type, &key, &type, &days))
+ return NULL;
+
+ bio=BIO_new(BIO_s_mem());
+ tmptm = ASN1_TIME_new();
+ if (!tmptm)
+ return 0;
+ X509_gmtime_adj(tmptm,0);
+ X509_CRL_set_lastUpdate(self->crl, tmptm);
+ X509_gmtime_adj(tmptm,days*24*60*60);
+ X509_CRL_set_nextUpdate(self->crl, tmptm);
+ ASN1_TIME_free(tmptm);
+ X509_CRL_set_issuer_name(self->crl, X509_get_subject_name(x509->x509));
+ X509_CRL_sign(self->crl, key->pkey, EVP_md5());
+ switch (type)
+ {
+ case X509_FILETYPE_PEM:
+ ret = PEM_write_bio_X509_CRL(bio, self->crl);
+ break;
+
+ case X509_FILETYPE_ASN1:
+ ret = (int) i2d_X509_CRL_bio(bio, self->crl);
+ break;
+
+ case X509_FILETYPE_TEXT:
+ ret = X509_CRL_print(bio, self->crl);
+ break;
+
+ default:
+ PyErr_SetString(PyExc_ValueError,
+ "type argument must be FILETYPE_PEM or FILETYPE_ASN1");
+ return NULL;
+ };
+ if( ! ret )
+ {
+ exception_from_error_queue(crypto_Error);
+ BIO_free(bio);
+ return NULL;
+ }
+ buf_len = BIO_get_mem_data(bio, &temp);
+ buffer = PyString_FromStringAndSize(temp, buf_len);
+ BIO_free(bio);
+ return buffer;
+}
+
+crypto_CRLObj *
+crypto_CRL_New(X509_CRL *crl)
+{
+ crypto_CRLObj *self;
+
+ self = PyObject_New(crypto_CRLObj, &crypto_CRL_Type);
+ if (self==NULL)
+ return NULL;
+ self->crl = crl;
+ return self;
+}
+
+/*
+ * ADD_METHOD(name) expands to a correct PyMethodDef declaration
+ * { 'name', (PyCFunction)crypto_CRL_name, METH_VARARGS, crypto_CRL_name_doc }
+ * for convenience
+ */
+#define ADD_METHOD(name) \
+ { #name, (PyCFunction)crypto_CRL_##name, METH_VARARGS, crypto_CRL_##name##_doc }
+#define ADD_KW_METHOD(name) \
+ { #name, (PyCFunction)crypto_CRL_##name, METH_VARARGS | METH_KEYWORDS, crypto_CRL_##name##_doc }
+static PyMethodDef crypto_CRL_methods[] =
+{
+ ADD_KW_METHOD(add_revoked),
+ ADD_METHOD(get_revoked),
+ ADD_KW_METHOD(export),
+ { NULL, NULL }
+};
+#undef ADD_METHOD
+
+
+static PyObject *
+crypto_CRL_getattr(crypto_CRLObj *self, char *name)
+{
+ return Py_FindMethod(crypto_CRL_methods, (PyObject *)self, name);
+}
+
+static void
+crypto_CRL_dealloc(crypto_CRLObj *self)
+{
+ X509_CRL_free(self->crl);
+ self->crl = NULL;
+
+ PyObject_Del(self);
+}
+
+static char crypto_CRL_doc[] = "\n\
+CRL() -> CRL instance\n\
+\n\
+Create a new empty CRL object.\n\
+\n\
+@returns: The CRL object\n\
+";
+
+static PyObject* crypto_CRL_new(PyTypeObject *subtype, PyObject *args, PyObject *kwargs) {
+ if (!PyArg_ParseTuple(args, ":CRL")) {
+ return NULL;
+ }
+
+ return (PyObject *)crypto_CRL_New(X509_CRL_new());
+}
+
+PyTypeObject crypto_CRL_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0,
+ "CRL",
+ sizeof(crypto_CRLObj),
+ 0,
+ (destructor)crypto_CRL_dealloc,
+ NULL, /* print */
+ (getattrfunc)crypto_CRL_getattr,
+ NULL, /* setattr */
+ NULL, /* compare */
+ NULL, /* repr */
+ NULL, /* as_number */
+ NULL, /* as_sequence */
+ NULL, /* as_mapping */
+ NULL, /* hash */
+ NULL, /* call */
+ NULL, /* str */
+ NULL, /* getattro */
+ NULL, /* setattro */
+ NULL, /* as_buffer */
+ Py_TPFLAGS_DEFAULT,
+ crypto_CRL_doc, /* doc */
+ NULL, /* traverse */
+ NULL, /* clear */
+ NULL, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ NULL, /* tp_iter */
+ NULL, /* tp_iternext */
+ crypto_CRL_methods, /* tp_methods */
+ NULL, /* tp_members */
+ NULL, /* tp_getset */
+ NULL, /* tp_base */
+ NULL, /* tp_dict */
+ NULL, /* tp_descr_get */
+ NULL, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ NULL, /* tp_init */
+ NULL, /* tp_alloc */
+ crypto_CRL_new, /* tp_new */
+};
+
+int init_crypto_crl(PyObject *module) {
+ if(PyType_Ready(&crypto_CRL_Type) < 0) {
+ return 0;
+ }
+
+ if (PyModule_AddObject(module, "CRL", (PyObject *)&crypto_CRL_Type) != 0) {
+ return 0;
+ }
+ return 1;
+}
+
diff --git a/src/crypto/crl.h b/src/crypto/crl.h
new file mode 100644
index 0000000..87f5048
--- /dev/null
+++ b/src/crypto/crl.h
@@ -0,0 +1,19 @@
+#ifndef PyOpenSSL_crypto_CRL_H_
+#define PyOpenSSL_crypto_CRL_H_
+
+#include <Python.h>
+
+extern int init_crypto_crl (PyObject *);
+
+extern PyTypeObject crypto_CRL_Type;
+
+#define crypto_CRL_Check(v) ((v)->ob_type == &crypto_CRL_Type)
+
+typedef struct {
+ PyObject_HEAD
+ X509_CRL *crl;
+} crypto_CRLObj;
+
+crypto_CRLObj * crypto_CRL_New(X509_CRL *crl);
+
+#endif
diff --git a/src/crypto/crypto.c b/src/crypto/crypto.c
index 21501c1..a3ce9a9 100644
--- a/src/crypto/crypto.c
+++ b/src/crypto/crypto.c
@@ -430,6 +430,53 @@
return buffer;
}
+static char crypto_load_crl_doc[] = "\n\
+Load a certificate revocation list from a buffer\n\
+\n\
+@param type: The file type (one of FILETYPE_PEM, FILETYPE_ASN1)\n\
+@param buffer: The buffer the CRL is stored in\n\
+\n\
+@return: The PKey object\n\
+";
+
+static PyObject *
+crypto_load_crl(PyObject *spam, PyObject *args)
+{
+ int type, len;
+ char *buffer;
+ BIO *bio;
+ X509_CRL *crl;
+
+ if (!PyArg_ParseTuple(args, "is#:load_crl", &type, &buffer, &len))
+ return NULL;
+
+ bio = BIO_new_mem_buf(buffer, len);
+ switch (type)
+ {
+ case X509_FILETYPE_PEM:
+ crl = PEM_read_bio_X509_CRL(bio, NULL, NULL, NULL);
+ break;
+
+ case X509_FILETYPE_ASN1:
+ crl = d2i_X509_CRL_bio(bio, NULL);
+ break;
+
+ default:
+ PyErr_SetString(PyExc_ValueError, "type argument must be FILETYPE_PEM or FILETYPE_ASN1");
+ BIO_free(bio);
+ return NULL;
+ }
+ BIO_free(bio);
+
+ if (crl == NULL)
+ {
+ exception_from_error_queue(crypto_Error);
+ return NULL;
+ }
+
+ return (PyObject *)crypto_CRL_New(crl);
+}
+
static char crypto_load_pkcs7_data_doc[] = "\n\
Load pkcs7 data from a buffer\n\
\n\
@@ -555,6 +602,7 @@
{ "dump_certificate", (PyCFunction)crypto_dump_certificate, METH_VARARGS, crypto_dump_certificate_doc },
{ "load_certificate_request", (PyCFunction)crypto_load_certificate_request, METH_VARARGS, crypto_load_certificate_request_doc },
{ "dump_certificate_request", (PyCFunction)crypto_dump_certificate_request, METH_VARARGS, crypto_dump_certificate_request_doc },
+ { "load_crl", (PyCFunction)crypto_load_crl, METH_VARARGS, crypto_load_crl_doc },
{ "load_pkcs7_data", (PyCFunction)crypto_load_pkcs7_data, METH_VARARGS, crypto_load_pkcs7_data_doc },
{ "load_pkcs12", (PyCFunction)crypto_load_pkcs12, METH_VARARGS, crypto_load_pkcs12_doc },
{ "X509_verify_cert_error_string", (PyCFunction)crypto_X509_verify_cert_error_string, METH_VARARGS, crypto_X509_verify_cert_error_string_doc },
@@ -696,7 +744,10 @@
goto error;
if (!init_crypto_netscape_spki(module))
goto error;
-
+ if (!init_crypto_crl(module))
+ goto error;
+ if (!init_crypto_revoked(module))
+ goto error;
error:
;
}
diff --git a/src/crypto/crypto.h b/src/crypto/crypto.h
index b5e6b65..057b5dd 100644
--- a/src/crypto/crypto.h
+++ b/src/crypto/crypto.h
@@ -23,6 +23,8 @@
#include "x509ext.h"
#include "pkcs7.h"
#include "pkcs12.h"
+#include "crl.h"
+#include "revoked.h"
#include "../util.h"
extern PyObject *crypto_Error;
diff --git a/src/crypto/revoked.c b/src/crypto/revoked.c
new file mode 100644
index 0000000..8289408
--- /dev/null
+++ b/src/crypto/revoked.c
@@ -0,0 +1,258 @@
+#include <Python.h>
+#define crypto_MODULE
+#include "crypto.h"
+
+
+static char crypto_Revoked_get_rev_date_doc[] = "\n\
+Retrieve the revocation date\n\
+\n\
+@return: A string giving the timestamp, in the format:\n\
+\n\
+ YYYYMMDDhhmmssZ\n\
+ YYYYMMDDhhmmss+hhmm\n\
+ YYYYMMDDhhmmss-hhmm\n\
+";
+
+static PyObject*
+crypto_Revoked_get_rev_date(crypto_RevokedObj *self, PyObject *args)
+{
+ /* returns a borrowed reference. */
+ return _get_asn1_time(
+ ":get_rev_date", self->revoked->revocationDate, args);
+}
+
+static char crypto_Revoked_set_rev_date_doc[] = "\n\
+Set the revocation timestamp\n\
+\n\
+@param when: A string giving the timestamp, in the format:\n\
+\n\
+ YYYYMMDDhhmmssZ\n\
+ YYYYMMDDhhmmss+hhmm\n\
+ YYYYMMDDhhmmss-hhmm\n\
+\n\
+@return: None\n\
+";
+
+static PyObject*
+crypto_Revoked_set_rev_date(crypto_RevokedObj *self, PyObject *args)
+{
+ return _set_asn1_time(
+ "s:set_rev_date", self->revoked->revocationDate, args);
+}
+
+
+static PyObject *
+ASN1_INTEGER_to_PyString(ASN1_INTEGER *asn1_int)
+{
+ BIO *bio = NULL;
+ PyObject *buf = NULL;
+ int ret, pending;
+
+ /* Create a openssl BIO buffer */
+ bio = BIO_new(BIO_s_mem());
+ if (bio == NULL)
+ goto err;
+
+ /* Write the integer to the BIO as a hex string. */
+ i2a_ASN1_INTEGER(bio, asn1_int);
+
+ /* Allocate a Python string. */
+ pending = BIO_pending(bio);
+ buf = PyString_FromStringAndSize(NULL, pending);
+ if (buf == NULL) {
+ goto err;
+ }
+
+ /* Copy the BIO contents to a Python string. */
+ ret = BIO_read(bio, PyString_AsString(buf), pending);
+ if (ret <= 0) { /* problem with BIO_read */
+ goto err;
+ }
+
+ /* Cleanup */
+ BIO_free(bio);
+ bio = NULL;
+ return buf;
+
+ err:
+ if(bio) {
+ BIO_free(bio);
+ }
+ if(buf) {
+ Py_DECREF(buf);
+ }
+ return NULL;
+}
+
+
+static char crypto_Revoked_get_serial_doc[] = "\n\
+Return the serial number of a Revoked structure\n\
+\n\
+@return: The serial number as a string\n\
+";
+static PyObject *
+crypto_Revoked_get_serial(crypto_RevokedObj *self, PyObject *args)
+{
+ if (!PyArg_ParseTuple(args, ":get_serial"))
+ return NULL;
+
+ if(self->revoked->serialNumber == NULL) {
+ /* never happens */
+ Py_INCREF(Py_None);
+ return Py_None;
+ } else {
+ return ASN1_INTEGER_to_PyString(self->revoked->serialNumber);
+ }
+}
+
+static char crypto_Revoked_set_serial_doc[] = "\n\
+Set the serial number of a revoked Revoked structure\n\
+\n\
+@param hex_str: The new serial number.\n\
+@type hex_str: L{str}\n\
+@return: None\n\
+";
+static PyObject *
+crypto_Revoked_set_serial(crypto_RevokedObj *self, PyObject *args, PyObject *keywds)
+{
+ static char *kwlist[] = {"hex_str", NULL};
+ const char *hex_str = NULL;
+ BIGNUM *serial = NULL;
+ ASN1_INTEGER *tmpser = NULL;
+
+ if (!PyArg_ParseTupleAndKeywords(args, keywds, "s:set_serial",
+ kwlist, &hex_str))
+ return NULL;
+
+ if( ! BN_hex2bn(&serial, hex_str) ) {
+ PyErr_SetString(PyExc_TypeError, "bad hex string");
+ return NULL;
+ }
+
+ tmpser = BN_to_ASN1_INTEGER(serial, NULL);
+ BN_free(serial);
+ serial = NULL;
+ X509_REVOKED_set_serialNumber(self->revoked, tmpser);
+ ASN1_INTEGER_free(tmpser);
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+
+crypto_RevokedObj *
+crypto_Revoked_New(X509_REVOKED *revoked)
+{
+ crypto_RevokedObj *self;
+
+ self = PyObject_New(crypto_RevokedObj, &crypto_Revoked_Type);
+ if (self==NULL)
+ return NULL;
+ self->revoked = revoked;
+ return self;
+}
+
+/*
+ * ADD_METHOD(name) expands to a correct PyMethodDef declaration
+ * { 'name', (PyCFunction)crypto_Revoked_name, METH_VARARGS, crypto_Revoked_name_doc }
+ * for convenience
+ */
+#define ADD_METHOD(name) \
+ { #name, (PyCFunction)crypto_Revoked_##name, METH_VARARGS, crypto_Revoked_##name##_doc }
+#define ADD_KW_METHOD(name) \
+ { #name, (PyCFunction)crypto_Revoked_##name, METH_VARARGS | METH_KEYWORDS, crypto_Revoked_##name##_doc }
+static PyMethodDef crypto_Revoked_methods[] =
+{
+ ADD_METHOD(get_rev_date),
+ ADD_METHOD(set_rev_date),
+ ADD_METHOD(get_serial),
+ ADD_KW_METHOD(set_serial),
+ { NULL, NULL }
+};
+#undef ADD_METHOD
+
+
+static PyObject *
+crypto_Revoked_getattr(crypto_RevokedObj *self, char *name)
+{
+ return Py_FindMethod(crypto_Revoked_methods, (PyObject *)self, name);
+}
+
+static void
+crypto_Revoked_dealloc(crypto_RevokedObj *self)
+{
+ X509_REVOKED_free(self->revoked);
+ self->revoked = NULL;
+
+ PyObject_Del(self);
+}
+
+static char crypto_Revoked_doc[] = "\n\
+Revoked() -> Revoked instance\n\
+\n\
+Create a new empty Revoked object.\n\
+\n\
+@returns: The Revoked object\n\
+";
+
+static PyObject* crypto_Revoked_new(PyTypeObject *subtype, PyObject *args, PyObject *kwargs) {
+ if (!PyArg_ParseTuple(args, ":Revoked")) {
+ return NULL;
+ }
+
+ return (PyObject *)crypto_Revoked_New(X509_REVOKED_new());
+}
+
+PyTypeObject crypto_Revoked_Type = {
+ PyObject_HEAD_INIT(NULL)
+ 0,
+ "Revoked",
+ sizeof(crypto_RevokedObj),
+ 0,
+ (destructor)crypto_Revoked_dealloc,
+ NULL, /* print */
+ (getattrfunc)crypto_Revoked_getattr,
+ NULL, /* setattr */
+ NULL, /* compare */
+ NULL, /* repr */
+ NULL, /* as_number */
+ NULL, /* as_sequence */
+ NULL, /* as_mapping */
+ NULL, /* hash */
+ NULL, /* call */
+ NULL, /* str */
+ NULL, /* getattro */
+ NULL, /* setattro */
+ NULL, /* as_buffer */
+ Py_TPFLAGS_DEFAULT,
+ crypto_Revoked_doc, /* doc */
+ NULL, /* traverse */
+ NULL, /* clear */
+ NULL, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ NULL, /* tp_iter */
+ NULL, /* tp_iternext */
+ crypto_Revoked_methods, /* tp_methods */
+ NULL, /* tp_members */
+ NULL, /* tp_getset */
+ NULL, /* tp_base */
+ NULL, /* tp_dict */
+ NULL, /* tp_descr_get */
+ NULL, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ NULL, /* tp_init */
+ NULL, /* tp_alloc */
+ crypto_Revoked_new, /* tp_new */
+};
+
+int init_crypto_revoked(PyObject *module) {
+ if(PyType_Ready(&crypto_Revoked_Type) < 0) {
+ return 0;
+ }
+
+ if (PyModule_AddObject(module, "Revoked", (PyObject *)&crypto_Revoked_Type) != 0) {
+ return 0;
+ }
+ return 1;
+}
+
diff --git a/src/crypto/revoked.h b/src/crypto/revoked.h
new file mode 100644
index 0000000..fb85ac6
--- /dev/null
+++ b/src/crypto/revoked.h
@@ -0,0 +1,18 @@
+#ifndef PyOpenSSL_crypto_REVOKED_H_
+#define PyOpenSSL_crypto_REVOKED_H_
+
+#include <Python.h>
+
+extern PyTypeObject crypto_Revoked_Type;
+
+#define crypto_Revoked_Check(v) ((v)->ob_type == &crypto_Revoked_Type)
+
+typedef struct {
+ PyObject_HEAD
+ X509_REVOKED *revoked;
+} crypto_RevokedObj;
+
+extern int init_crypto_revoked (PyObject *);
+extern crypto_RevokedObj * crypto_Revoked_New(X509_REVOKED *revoked);
+
+#endif
diff --git a/src/crypto/x509.c b/src/crypto/x509.c
index e089d40..daae351 100644
--- a/src/crypto/x509.c
+++ b/src/crypto/x509.c
@@ -335,8 +335,8 @@
return Py_None;
}
-static PyObject*
-_set_asn1_time(char *format, ASN1_TIME* timestamp, crypto_X509Obj *self, PyObject *args)
+PyObject*
+_set_asn1_time(char *format, ASN1_TIME* timestamp, PyObject *args)
{
char *when;
@@ -375,7 +375,7 @@
crypto_X509_set_notBefore(crypto_X509Obj *self, PyObject *args)
{
return _set_asn1_time(
- "s:set_notBefore", X509_get_notBefore(self->x509), self, args);
+ "s:set_notBefore", X509_get_notBefore(self->x509), args);
}
static char crypto_X509_set_notAfter_doc[] = "\n\
@@ -394,11 +394,11 @@
crypto_X509_set_notAfter(crypto_X509Obj *self, PyObject *args)
{
return _set_asn1_time(
- "s:set_notAfter", X509_get_notAfter(self->x509), self, args);
+ "s:set_notAfter", X509_get_notAfter(self->x509), args);
}
-static PyObject*
-_get_asn1_time(char *format, ASN1_TIME* timestamp, crypto_X509Obj *self, PyObject *args)
+PyObject*
+_get_asn1_time(char *format, ASN1_TIME* timestamp, PyObject *args)
{
ASN1_GENERALIZEDTIME *gt_timestamp = NULL;
PyObject *py_timestamp = NULL;
@@ -450,7 +450,7 @@
* X509_get_notBefore returns a borrowed reference.
*/
return _get_asn1_time(
- ":get_notBefore", X509_get_notBefore(self->x509), self, args);
+ ":get_notBefore", X509_get_notBefore(self->x509), args);
}
@@ -472,7 +472,7 @@
* X509_get_notAfter returns a borrowed reference.
*/
return _get_asn1_time(
- ":get_notAfter", X509_get_notAfter(self->x509), self, args);
+ ":get_notAfter", X509_get_notAfter(self->x509), args);
}
diff --git a/src/crypto/x509.h b/src/crypto/x509.h
index 40768cf..43e41eb 100644
--- a/src/crypto/x509.h
+++ b/src/crypto/x509.h
@@ -16,8 +16,6 @@
#include <Python.h>
#include <openssl/ssl.h>
-extern int init_crypto_x509 (PyObject *);
-
extern PyTypeObject crypto_X509_Type;
#define crypto_X509_Check(v) ((v)->ob_type == &crypto_X509_Type)
@@ -28,5 +26,9 @@
int dealloc;
} crypto_X509Obj;
+PyObject* _set_asn1_time(char *format, ASN1_TIME* timestamp, PyObject *args);
+PyObject* _get_asn1_time(char *format, ASN1_TIME* timestamp, PyObject *args);
+extern int init_crypto_x509 (PyObject *);
+
#endif