PyObject * CCNObject_New(enum _pyccn_capsules type, void *pointer) { PyObject *capsule; int r; assert(pointer); capsule = PyCapsule_New(pointer, type2name(type), pyccn_Capsule_Destructor); if (!capsule) return NULL; switch (type) { case CONTENT_OBJECT: { struct content_object_data *context; context = calloc(1, sizeof(*context)); JUMP_IF_NULL_MEM(context, error); r = PyCapsule_SetContext(capsule, context); if (r < 0) { free(context); goto error; } break; } case INTEREST: { struct interest_data *context; context = calloc(1, sizeof(*context)); JUMP_IF_NULL_MEM(context, error); r = PyCapsule_SetContext(capsule, context); if (r < 0) { free(context); goto error; } break; } default: break; } return capsule; error: Py_XDECREF(capsule); return NULL; }
struct ccn_parsed_interest * _pyccn_interest_get_pi(PyObject *py_interest) { struct interest_data *context; struct ccn_charbuf *interest; int r; assert(CCNObject_IsValid(INTEREST, py_interest)); context = PyCapsule_GetContext(py_interest); assert(context); if (context->pi) return context->pi; interest = CCNObject_Get(INTEREST, py_interest); context->pi = calloc(1, sizeof(struct ccn_parsed_interest)); JUMP_IF_NULL_MEM(context->pi, error); /* TODO: we should also use the comps argument */ r = ccn_parse_interest(interest->buf, interest->length, context->pi, NULL); if (r < 0) { PyErr_SetString(g_PyExc_CCNInterestError, "Unable to parse the" " Interest"); goto error; } assert(context->pi); return context->pi; error: return NULL; }
static int parse_ContentObject(PyObject *py_content_object) { struct content_object_data *context; struct ccn_charbuf *content_object; int r; assert(CCNObject_IsValid(CONTENT_OBJECT, py_content_object)); context = PyCapsule_GetContext(py_content_object); assert(context); if (context->pco) free(context->pco); ccn_indexbuf_destroy(&context->comps); /* * no error happens between deallocation and following line, so I'm not * setting context->pco to NULL */ context->pco = calloc(1, sizeof(struct ccn_parsed_ContentObject)); JUMP_IF_NULL_MEM(context->pco, error); context->comps = ccn_indexbuf_create(); JUMP_IF_NULL_MEM(context->comps, error); content_object = CCNObject_Get(CONTENT_OBJECT, py_content_object); r = ccn_parse_ContentObject(content_object->buf, content_object->length, context->pco, context->comps); if (r < 0) { PyErr_SetString(g_PyExc_CCNContentObjectError, "Unable to parse the" " ContentObject"); goto error; } return 0; error: if (context->pco) { free(context->pco); context->pco = NULL; } ccn_indexbuf_destroy(&context->comps); return -1; }
PyObject * _pyndn_cmd_KeyLocator_to_ndn(PyObject *UNUSED(self), PyObject *args, PyObject *kwds) { static char *kwlist[] = {"name", "digest", "key", "cert", NULL}; PyObject *py_name = Py_None, *py_digest = Py_None, *py_key = Py_None, *py_cert = Py_None; struct ndn_charbuf *keylocator; int r; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO", kwlist, &py_name, &py_digest, &py_key, &py_cert)) return NULL; keylocator = ndn_charbuf_create(); JUMP_IF_NULL_MEM(keylocator, error); r = ndn_charbuf_append_tt(keylocator, NDN_DTAG_KeyLocator, NDN_DTAG); JUMP_IF_NEG_MEM(r, error); if (py_name != Py_None) { //TODO: add digest as well r = KeyLocator_name_to_ndn(keylocator, py_name); JUMP_IF_NEG(r, error); } else if (py_key != Py_None) { r = KeyLocator_key_to_ndn(keylocator, py_key); JUMP_IF_NEG(r, error); } else if (py_cert != Py_None) { #if 0 ndn_charbuf_append_tt(keylocator, NDN_DTAG_Certificate, NDN_DTAG); // TODO: How to handle certificate? ** Not supported here ndn_charbuf_append_closer(keylocator); /* </Certificate> */ #endif PyErr_SetString(PyExc_NotImplementedError, "Certificate key locator is" " not implemented"); goto error; } r = ndn_charbuf_append_closer(keylocator); /* </KeyLocator> */ JUMP_IF_NEG_MEM(r, error); return NDNObject_New(KEY_LOCATOR, keylocator); error: ndn_charbuf_destroy(&keylocator); return NULL; }
PyObject * _pyccn_cmd_encode_ContentObject(PyObject *UNUSED(self), PyObject *args) { PyObject *py_content_object, *py_name, *py_content, *py_signed_info, *py_key; PyObject *py_o = NULL, *ret = NULL; struct ccn_charbuf *name, *signed_info, *content_object = NULL; struct ccn_pkey *private_key; const char *digest_alg = NULL; char *content; Py_ssize_t content_len; int r; if (!PyArg_ParseTuple(args, "OOOOO", &py_content_object, &py_name, &py_content, &py_signed_info, &py_key)) return NULL; if (strcmp(py_content_object->ob_type->tp_name, "ContentObject")) { PyErr_SetString(PyExc_TypeError, "Must pass a ContentObject as arg 1"); return NULL; } if (!CCNObject_IsValid(NAME, py_name)) { PyErr_SetString(PyExc_TypeError, "Must pass a CCN Name as arg 2"); return NULL; } else name = CCNObject_Get(NAME, py_name); if (py_content != Py_None && !PyBytes_Check(py_content)) { PyErr_SetString(PyExc_TypeError, "Must pass a Bytes as arg 3"); return NULL; } else if (py_content == Py_None) { content = NULL; content_len = 0; } else { r = PyBytes_AsStringAndSize(py_content, &content, &content_len); if (r < 0) return NULL; } if (!CCNObject_IsValid(SIGNED_INFO, py_signed_info)) { PyErr_SetString(PyExc_TypeError, "Must pass a CCN SignedInfo as arg 4"); return NULL; } else signed_info = CCNObject_Get(SIGNED_INFO, py_signed_info); if (strcmp(py_key->ob_type->tp_name, "Key")) { PyErr_SetString(PyExc_TypeError, "Must pass a Key as arg 4"); return NULL; } // DigestAlgorithm py_o = PyObject_GetAttrString(py_content_object, "digestAlgorithm"); if (py_o != Py_None) { PyErr_SetString(PyExc_NotImplementedError, "non-default digest" " algorithm not yet supported"); goto error; } Py_CLEAR(py_o); // Key private_key = Key_to_ccn_private(py_key); // Note that we don't load this key into the keystore hashtable in the library // because it makes this method require access to a ccn handle, and in fact, // ccn_sign_content just uses what's in signedinfo (after an error check by // chk_signing_params and then calls ccn_encode_ContentObject anyway // // Encode the content object // Build the ContentObject here. content_object = ccn_charbuf_create(); JUMP_IF_NULL_MEM(content_object, error); r = ccn_encode_ContentObject(content_object, name, signed_info, content, content_len, digest_alg, private_key); debug("ccn_encode_ContentObject res=%d\n", r); if (r < 0) { ccn_charbuf_destroy(&content_object); PyErr_SetString(g_PyExc_CCNError, "Unable to encode ContentObject"); goto error; } ret = CCNObject_New(CONTENT_OBJECT, content_object); error: Py_XDECREF(py_o); return ret; }
PyObject * _pyccn_cmd_SignedInfo_to_ccn(PyObject *UNUSED(self), PyObject *args, PyObject *kwds) { static char *kwlist[] = {"pubkey_digest", "type", "timestamp", "freshness", "final_block_id", "key_locator", NULL}; PyObject *py_pubkey_digest, *py_timestamp = Py_None, *py_final_block = Py_None, *py_key_locator = Py_None; struct ccn_charbuf *si; PyObject *py_si; int r; size_t publisher_key_id_size; const void *publisher_key_id; int type, freshness = -1; struct ccn_charbuf *timestamp = NULL, *finalblockid = NULL, *key_locator = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oi|OiOO", kwlist, &py_pubkey_digest, &type, &py_timestamp, &freshness, &py_final_block, &py_key_locator)) return NULL; if (!PyBytes_Check(py_pubkey_digest)) { PyErr_SetString(PyExc_TypeError, "Must pass a Bytes as pubkey_digest"); return NULL; } else { publisher_key_id_size = PyBytes_GET_SIZE(py_pubkey_digest); publisher_key_id = PyBytes_AS_STRING(py_pubkey_digest); } if (py_timestamp != Py_None) { PyErr_SetString(PyExc_NotImplementedError, "Timestamp is not implemented yet"); return NULL; } else timestamp = NULL; if (py_final_block != Py_None) { char *s; Py_ssize_t len; if (!PyBytes_Check(py_final_block)) { PyErr_SetString(PyExc_TypeError, "Must pass a bytes as final block"); return NULL; } finalblockid = ccn_charbuf_create(); JUMP_IF_NULL_MEM(finalblockid, error); s = PyBytes_AS_STRING(py_final_block); len = PyBytes_GET_SIZE(py_final_block); r = ccn_charbuf_append_tt(finalblockid, len, CCN_BLOB); JUMP_IF_NEG_MEM(r, error); r = ccn_charbuf_append(finalblockid, s, len); JUMP_IF_NEG_MEM(r, error); } else finalblockid = NULL; if (py_key_locator == Py_None) key_locator = NULL; else if (CCNObject_IsValid(KEY_LOCATOR, py_key_locator)) key_locator = CCNObject_Get(KEY_LOCATOR, py_key_locator); else { PyErr_SetString(PyExc_TypeError, "key_locator needs to be a CCN KeyLocator object"); return NULL; } py_si = CCNObject_New_charbuf(SIGNED_INFO, &si); JUMP_IF_NULL(py_si, error); r = ccn_signed_info_create(si, publisher_key_id, publisher_key_id_size, timestamp, type, freshness, finalblockid, key_locator); ccn_charbuf_destroy(&finalblockid); if (r < 0) { Py_DECREF(py_si); PyErr_SetString(g_PyExc_CCNError, "Error while creating SignedInfo"); return NULL; } return py_si; error: ccn_charbuf_destroy(&finalblockid); return NULL; }