/**
* 找到ndnb编码过的名字中的 组件边界
*
* Find Component boundaries in a ndnb-encoded Name.
*
* Thin veneer over ndn_parse_Name().
* components arg may be NULL to just do a validity check
*
* @returns -1 for error, otherwise the number of Components.
*/
int
ndn_name_split(const struct ndn_charbuf *c, struct ndn_indexbuf *components)
{
struct ndn_buf_decoder decoder;
struct ndn_buf_decoder *d;
d = ndn_buf_decoder_start(&decoder, c->buf, c->length);
return(ndn_parse_Name(d, components));
}
struct ndn_forwarding_entry *
ndn_forwarding_entry_parse(const unsigned char *p, size_t size)
{
struct ndn_buf_decoder decoder;
struct ndn_buf_decoder *d = ndn_buf_decoder_start(&decoder, p, size);
struct ndn_charbuf *store = ndn_charbuf_create();
struct ndn_forwarding_entry *result;
const unsigned char *val;
size_t sz;
size_t start;
size_t end;
int action_off = -1;
int ndnd_id_off = -1;
if (store == NULL)
return(NULL);
result = calloc(1, sizeof(*result));
if (result == NULL) {
ndn_charbuf_destroy(&store);
return(NULL);
}
if (ndn_buf_match_dtag(d, NDN_DTAG_ForwardingEntry)) {
ndn_buf_advance(d);
action_off = ndn_parse_tagged_string(d, NDN_DTAG_Action, store);
if (ndn_buf_match_dtag(d, NDN_DTAG_Name)) {
result->name_prefix = ndn_charbuf_create();
start = d->decoder.token_index;
ndn_parse_Name(d, NULL);
end = d->decoder.token_index;
ndn_charbuf_append(result->name_prefix, p + start, end - start);
}
else
result->name_prefix = NULL;
if (ndn_buf_match_dtag(d, NDN_DTAG_PublisherPublicKeyDigest)) {
ndn_buf_advance(d);
if (ndn_buf_match_blob(d, &val, &sz)) {
ndn_buf_advance(d);
if (sz != 32)
d->decoder.state = -__LINE__;
}
ndn_buf_check_close(d);
if (d->decoder.state >= 0) {
ndnd_id_off = store->length;
ndn_charbuf_append(store, val, sz);
result->ndnd_id_size = sz;
}
}
result->faceid = ndn_parse_optional_tagged_nonNegativeInteger(d, NDN_DTAG_FaceID);
result->flags = ndn_parse_optional_tagged_nonNegativeInteger(d, NDN_DTAG_ForwardingFlags);
result->lifetime = ndn_parse_optional_tagged_nonNegativeInteger(d, NDN_DTAG_FreshnessSeconds);
ndn_buf_check_close(d);
}
else
d->decoder.state = -__LINE__;
if (d->decoder.index != size || !NDN_FINAL_DSTATE(d->decoder.state) ||
store->length > sizeof(result->store))
ndn_forwarding_entry_destroy(&result);
else {
char *b = (char *)result->store;
memcpy(b, store->buf, store->length);
result->action = (action_off == -1) ? NULL : b + action_off;
result->ndnd_id = (ndnd_id_off == -1) ? NULL : result->store + ndnd_id_off;
}
ndn_charbuf_destroy(&store);
return(result);
}
PyObject *
KeyLocator_obj_from_ndn(PyObject *py_keylocator)
{
struct ndn_buf_decoder decoder, *d;
struct ndn_charbuf *keylocator;
struct ndn_charbuf *name;
struct ndn_pkey *pubkey;
size_t start, stop;
int r;
PyObject *py_o;
PyObject *py_KeyLocator_obj = NULL;
keylocator = NDNObject_Get(KEY_LOCATOR, py_keylocator);
debug("KeyLocator_from_ndn start\n");
d = ndn_buf_decoder_start(&decoder, keylocator->buf, keylocator->length);
assert(d); //should always succeed
if (!ndn_buf_match_dtag(d, NDN_DTAG_KeyLocator)) {
PyErr_SetString(g_PyExc_NDNKeyLocatorError, "The input isn't a valid"
" KeyLocator");
return NULL;
}
ndn_buf_advance(d);
if (ndn_buf_match_dtag(d, NDN_DTAG_KeyName)) {
const unsigned char *bname;
size_t bname_size;
PyObject *py_name_obj;
ndn_buf_advance(d);
start = d->decoder.token_index;
r = ndn_parse_Name(d, NULL);
stop = d->decoder.token_index;
if (r < 0)
return PyErr_Format(g_PyExc_NDNKeyLocatorError, "Error finding"
" NDN_DTAG_Name for KeyName (decoder state: %d)",
d->decoder.state);
assert(stop > start);
bname_size = stop - start;
bname = d->buf + start;
/*
r = ndn_ref_tagged_BLOB(NDN_DTAG_Name, d->buf, start, stop, &bname,
&bname_size);
if (r < 0)
return PyErr_Format(g_PyExc_NDNKeyLocatorError, "Error getting"
" NDN_DTAG_Name BLOB for KeyName (decoder state: %d)",
d->decoder.state);
*/
debug("Parse NDN_DTAG_Name inside KeyName, len=%zd\n", bname_size);
py_o = NDNObject_New_charbuf(NAME, &name);
if (!py_o)
return NULL;
r = ndn_charbuf_append(name, bname, bname_size);
if (r < 0) {
Py_DECREF(py_o);
return PyErr_NoMemory();
}
py_name_obj = Name_obj_from_ndn(py_o);
Py_DECREF(py_o);
if (!py_name_obj)
return NULL;
py_KeyLocator_obj = PyObject_CallObject(g_type_KeyLocator, NULL);
if (!py_KeyLocator_obj) {
Py_DECREF(py_name_obj);
goto error;
}
r = PyObject_SetAttrString(py_KeyLocator_obj, "keyName", py_name_obj);
Py_DECREF(py_name_obj);
JUMP_IF_NEG(r, error);
#pragma message "Parse and add digest to the keylocator"
} else if (ndn_buf_match_dtag(d, NDN_DTAG_Key)) {
const unsigned char *dkey;
size_t dkey_size;
PyObject *py_key_obj, *py_ndn_key;
start = d->decoder.token_index;
r = ndn_parse_required_tagged_BLOB(d, NDN_DTAG_Key, 1, -1);
stop = d->decoder.token_index;
if (r < 0)
return PyErr_Format(g_PyExc_NDNKeyLocatorError, "Error finding"
" NDN_DTAG_Key for Key (decoder state: %d)", d->decoder.state);
r = ndn_ref_tagged_BLOB(NDN_DTAG_Key, d->buf, start, stop, &dkey,
&dkey_size);
if (r < 0)
return PyErr_Format(g_PyExc_NDNKeyLocatorError, "Error getting"
" NDN_DTAG_Key BLOB for Key (decoder state: %d)",
d->decoder.state);
debug("Parse NDN_DTAG_Key, len=%zd\n", dkey_size);
pubkey = ndn_d2i_pubkey(dkey, dkey_size); // free with ndn_pubkey_free()
if (!pubkey) {
PyErr_SetString(g_PyExc_NDNKeyLocatorError, "Unable to parse key to"
" internal representation");
return NULL;
}
py_ndn_key = NDNObject_New(PKEY_PUB, pubkey);
if (!py_ndn_key) {
ndn_pubkey_free(pubkey);
return NULL;
}
py_key_obj = Key_obj_from_ndn(py_ndn_key);
Py_DECREF(py_ndn_key);
if (!py_key_obj)
return NULL;
py_KeyLocator_obj = PyObject_CallObject(g_type_KeyLocator, NULL);
if (!py_KeyLocator_obj) {
Py_DECREF(py_key_obj);
goto error;
}
r = PyObject_SetAttrString(py_KeyLocator_obj, "key", py_key_obj);
Py_DECREF(py_key_obj);
JUMP_IF_NEG(r, error);
} else if (ndn_buf_match_dtag(d, NDN_DTAG_Certificate)) {
PyErr_SetString(PyExc_NotImplementedError, "Found certificate DTAG,"
" which currently is unsupported");
return NULL;
} else {
PyErr_SetString(g_PyExc_NDNKeyLocatorError, "Unknown KeyLocator Type");
return NULL;
}
ndn_buf_check_close(d); // we don't really check the parser, though-
return py_KeyLocator_obj;
error:
Py_XDECREF(py_KeyLocator_obj);
return NULL;
}
