int
ccn_keypair_from_rsa(int public_only, RSA *private_key_rsa,
PyObject **py_private_key_ccn, PyObject **py_public_key_ccn)
{
struct ccn_pkey *private_key = NULL, *public_key = NULL;
PyObject *py_private_key = NULL, *py_public_key = NULL;
unsigned int err;
int r;
RSA *public_key_rsa;
if (!public_only && py_private_key_ccn) {
private_key = (struct ccn_pkey *) EVP_PKEY_new();
JUMP_IF_NULL(private_key, openssl_error);
py_private_key = CCNObject_New(PKEY_PRIV, private_key);
JUMP_IF_NULL(py_private_key, error);
r = EVP_PKEY_set1_RSA((EVP_PKEY*) private_key, private_key_rsa);
JUMP_IF_NEG(r, openssl_error);
}
if (py_public_key_ccn) {
public_key = (struct ccn_pkey *) EVP_PKEY_new();
JUMP_IF_NULL(public_key, openssl_error);
py_public_key = CCNObject_New(PKEY_PUB, public_key);
JUMP_IF_NULL(py_public_key, error);
public_key_rsa = RSAPublicKey_dup(private_key_rsa);
JUMP_IF_NULL(public_key_rsa, openssl_error);
r = EVP_PKEY_set1_RSA((EVP_PKEY *) public_key, public_key_rsa);
RSA_free(public_key_rsa);
JUMP_IF_NULL(r, error);
}
if (py_private_key_ccn) {
*py_private_key_ccn = public_only ? (Py_INCREF(Py_None), Py_None) :
py_private_key;
}
if (py_public_key_ccn)
*py_public_key_ccn = py_public_key;
return 0;
openssl_error:
err = ERR_get_error();
PyErr_Format(g_PyExc_CCNKeyError, "Unable to generate keypair from the key:"
" %s", ERR_reason_error_string(err));
error:
if (!py_public_key && public_key)
ccn_pubkey_free(public_key);
Py_XDECREF(py_public_key);
if (!py_private_key && private_key)
ccn_pubkey_free(private_key);
Py_XDECREF(py_private_key);
return -1;
}
static void
pyccn_Capsule_Destructor(PyObject *capsule)
{
const char *name;
void *pointer;
enum _pyccn_capsules type;
assert(PyCapsule_CheckExact(capsule));
name = PyCapsule_GetName(capsule);
type = name2type(name);
pointer = PyCapsule_GetPointer(capsule, name);
assert(pointer);
switch (type) {
case CLOSURE:
{
PyObject *py_obj_closure;
struct ccn_closure *p = pointer;
py_obj_closure = PyCapsule_GetContext(capsule);
assert(py_obj_closure);
Py_DECREF(py_obj_closure); /* No longer referencing Closure object */
/* If we store something else, than ourselves, it probably is a bug */
assert(capsule == p->data);
free(p);
}
break;
case CONTENT_OBJECT:
{
struct content_object_data *context;
struct ccn_charbuf *p = pointer;
context = PyCapsule_GetContext(capsule);
if (context) {
if (context->pco)
free(context->pco);
ccn_indexbuf_destroy(&context->comps);
free(context);
}
ccn_charbuf_destroy(&p);
}
break;
case HANDLE:
{
struct ccn *p = pointer;
ccn_disconnect(p);
ccn_destroy(&p);
}
break;
case INTEREST:
{
struct interest_data *context;
struct ccn_charbuf *p = pointer;
context = PyCapsule_GetContext(capsule);
if (context) {
if (context->pi)
free(context->pi);
free(context);
}
ccn_charbuf_destroy(&p);
}
break;
case PKEY_PRIV:
case PKEY_PUB:
{
struct ccn_pkey *p = pointer;
ccn_pubkey_free(p);
}
break;
case EXCLUSION_FILTER:
case KEY_LOCATOR:
case NAME:
case SIGNATURE:
case SIGNED_INFO:
{
struct ccn_charbuf *p = pointer;
ccn_charbuf_destroy(&p);
}
break;
case SIGNING_PARAMS:
{
struct ccn_signing_params *p = pointer;
if (p->template_ccnb)
ccn_charbuf_destroy(&p->template_ccnb);
free(p);
}
break;
default:
debug("Got capsule: %s\n", PyCapsule_GetName(capsule));
panic("Unable to destroy the object: got an unknown capsule");
}
}
