int
ccn_parse_LinkAuthenticator(struct ccn_buf_decoder *d, struct ccn_parsed_Link *pl)
{
/* Implement with a single offset for the blob, CCN_PL_[BE]_PublisherDigest
* and remember the DTAG value to indicate which type of digest it is
*/
if (ccn_buf_match_dtag(d, CCN_DTAG_LinkAuthenticator)) {
ccn_buf_advance(d); // advance over DTAG token
pl->offset[CCN_PL_B_LinkAuthenticator] = d->decoder.token_index;
pl->offset[CCN_PL_B_PublisherID] = d->decoder.token_index;
pl->offset[CCN_PL_B_PublisherDigest] = d->decoder.token_index;
pl->offset[CCN_PL_E_PublisherDigest] = d->decoder.token_index;
if (ccn_buf_match_dtag(d, CCN_DTAG_PublisherPublicKeyDigest) ||
ccn_buf_match_dtag(d, CCN_DTAG_PublisherCertificateDigest) ||
ccn_buf_match_dtag(d, CCN_DTAG_PublisherIssuerKeyDigest) ||
ccn_buf_match_dtag(d, CCN_DTAG_PublisherIssuerCertificateDigest)) {
pl->publisher_digest_type = d->decoder.numval; // remember the DTAG
ccn_buf_advance(d); // over the DTAG token
if (!ccn_buf_match_some_blob(d))
return (d->decoder.state = -__LINE__);
pl->offset[CCN_PL_B_PublisherDigest] = d->decoder.token_index;
ccn_buf_advance(d); // over the digest
pl->offset[CCN_PL_E_PublisherDigest] = d->decoder.token_index;
ccn_buf_check_close(d); // over the DTAG closer
}
if (d->decoder.state < 0)
return (d->decoder.state);
pl->offset[CCN_PL_E_PublisherID] = d->decoder.token_index;
/* parse optional NameComponentCount nonNegativeInteger */
pl->offset[CCN_PL_B_NameComponentCount] = d->decoder.token_index;
pl->name_component_count = ccn_parse_optional_tagged_nonNegativeInteger(d, CCN_DTAG_NameComponentCount);
pl->offset[CCN_PL_E_NameComponentCount] = d->decoder.token_index;
/* parse optional Timestamp TimestampType */
pl->offset[CCN_PL_B_Timestamp] = d->decoder.token_index;
if (ccn_buf_match_dtag(d, CCN_DTAG_Timestamp))
ccn_parse_required_tagged_timestamp(d, CCN_DTAG_Timestamp);
pl->offset[CCN_PL_E_Timestamp] = d->decoder.token_index;
/* parse optional Type ContentType */
pl->offset[CCN_PL_B_Type] = d->decoder.token_index;
pl->type = ccn_parse_optional_tagged_binary_number(d, CCN_DTAG_Type, 3, 3, CCN_CONTENT_DATA);
pl->offset[CCN_PL_E_Type] = d->decoder.token_index;
/* parse optional ContentDigest Base64BinaryType */
pl->offset[CCN_PL_B_ContentDigest] = d->decoder.token_index;
ccn_parse_optional_tagged_BLOB(d, CCN_DTAG_ContentDigest, 32, 32);
pl->offset[CCN_PL_E_ContentDigest] = d->decoder.token_index;
ccn_buf_check_close(d);
pl->offset[CCN_PL_E_LinkAuthenticator] = d->decoder.token_index;
} else
d->decoder.state = -__LINE__;
if (!CCN_FINAL_DSTATE(d->decoder.state))
return (CCN_DSTATE_ERR_CODING);
return(0);
}
static int
ccn_parse_SignedInfo(struct ccn_buf_decoder *d, struct ccn_parsed_ContentObject *x)
{
x->offset[CCN_PCO_B_SignedInfo] = d->decoder.token_index;
if (ccn_buf_match_dtag(d, CCN_DTAG_SignedInfo)) {
ccn_buf_advance(d);
x->offset[CCN_PCO_B_PublisherPublicKeyDigest] = d->decoder.token_index;
ccn_parse_required_tagged_BLOB(d, CCN_DTAG_PublisherPublicKeyDigest, 16, 64);
x->offset[CCN_PCO_E_PublisherPublicKeyDigest] = d->decoder.token_index;
x->offset[CCN_PCO_B_Timestamp] = d->decoder.token_index;
ccn_parse_required_tagged_timestamp(d, CCN_DTAG_Timestamp);
x->offset[CCN_PCO_E_Timestamp] = d->decoder.token_index;
x->offset[CCN_PCO_B_Type] = d->decoder.token_index;
x->type = CCN_CONTENT_DATA;
x->type = ccn_parse_optional_tagged_binary_number(d, CCN_DTAG_Type, 3, 3, CCN_CONTENT_DATA);
x->offset[CCN_PCO_E_Type] = d->decoder.token_index;
x->offset[CCN_PCO_B_FreshnessSeconds] = d->decoder.token_index;
ccn_parse_optional_tagged_nonNegativeInteger(d, CCN_DTAG_FreshnessSeconds);
x->offset[CCN_PCO_E_FreshnessSeconds] = d->decoder.token_index;
x->offset[CCN_PCO_B_FinalBlockID] = d->decoder.token_index;
ccn_parse_optional_tagged_BLOB(d, CCN_DTAG_FinalBlockID, 1, -1);
x->offset[CCN_PCO_E_FinalBlockID] = d->decoder.token_index;
x->offset[CCN_PCO_B_KeyLocator] = d->decoder.token_index;
x->offset[CCN_PCO_B_Key_Certificate_KeyName] = d->decoder.token_index;
x->offset[CCN_PCO_E_Key_Certificate_KeyName] = d->decoder.token_index;
x->offset[CCN_PCO_B_KeyName_Name] = d->decoder.token_index;
x->offset[CCN_PCO_E_KeyName_Name] = d->decoder.token_index;
x->offset[CCN_PCO_B_KeyName_Pub] = d->decoder.token_index;
x->offset[CCN_PCO_E_KeyName_Pub] = d->decoder.token_index;
if (ccn_buf_match_dtag(d, CCN_DTAG_KeyLocator)) {
ccn_buf_advance(d);
x->offset[CCN_PCO_B_Key_Certificate_KeyName] = d->decoder.token_index;
if (ccn_buf_match_dtag(d, CCN_DTAG_Key)) {
(void)ccn_parse_required_tagged_BLOB(d, CCN_DTAG_Key, 0, -1);
}
else if (ccn_buf_match_dtag(d, CCN_DTAG_Certificate)) {
(void)ccn_parse_required_tagged_BLOB(d, CCN_DTAG_Certificate, 0, -1);
}
else {
struct parsed_KeyName keyname = {-1, -1, -1, -1};
if (ccn_parse_KeyName(d, &keyname) >= 0) {
if (keyname.Name >= 0) {
x->offset[CCN_PCO_B_KeyName_Name] = keyname.Name;
x->offset[CCN_PCO_E_KeyName_Name] = keyname.endName;
}
if (keyname.PublisherID >= 0) {
x->offset[CCN_PCO_B_KeyName_Pub] = keyname.PublisherID;
x->offset[CCN_PCO_E_KeyName_Pub] = keyname.endPublisherID;
}
}
}
x->offset[CCN_PCO_E_Key_Certificate_KeyName] = d->decoder.token_index;
ccn_buf_check_close(d);
}
x->offset[CCN_PCO_E_KeyLocator] = d->decoder.token_index;
ccn_buf_check_close(d);
}
else
d->decoder.state = -__LINE__;
x->offset[CCN_PCO_E_SignedInfo] = d->decoder.token_index;
if (d->decoder.state < 0)
return (d->decoder.state);
return(0);
}
PyObject *
SignedInfo_obj_from_ccn(PyObject *py_signed_info)
{
struct ccn_charbuf *signed_info;
PyObject *py_obj_SignedInfo, *py_o;
struct ccn_buf_decoder decoder, *d;
size_t start, stop, size;
const unsigned char *ptr;
int r;
signed_info = CCNObject_Get(SIGNED_INFO, py_signed_info);
debug("SignedInfo_from_ccn start, size=%zd\n", signed_info->length);
// 1) Create python object
py_obj_SignedInfo = PyObject_CallObject(g_type_SignedInfo, NULL);
if (!py_obj_SignedInfo)
return NULL;
// 2) Set ccn_data to a cobject pointing to the c struct
// and ensure proper destructor is set up for the c object.
r = PyObject_SetAttrString(py_obj_SignedInfo, "ccn_data", py_signed_info);
JUMP_IF_NEG(r, error);
// 3) Parse c structure and fill python attributes
// using PyObject_SetAttrString
// based on chk_signing_params
// from ccn_client.c
//
//outputs:
// Note, it is ok that non-filled optional elements
// are initialized to None (through the .py file __init__)
//
d = ccn_buf_decoder_start(&decoder, signed_info->buf, signed_info->length);
if (!ccn_buf_match_dtag(d, CCN_DTAG_SignedInfo)) {
PyErr_Format(g_PyExc_CCNSignedInfoError, "Error finding"
" CCN_DTAG_SignedInfo (decoder state: %d)", d->decoder.state);
goto error;
}
ccn_buf_advance(d);
/* PublisherPublic Key */
//XXX: should we check for case when PublishePublicKeyDigest is not present? -dk
start = d->decoder.token_index;
ccn_parse_required_tagged_BLOB(d, CCN_DTAG_PublisherPublicKeyDigest,
16, 64);
stop = d->decoder.token_index;
r = ccn_ref_tagged_BLOB(CCN_DTAG_PublisherPublicKeyDigest, d->buf, start,
stop, &ptr, &size);
if (r < 0) {
PyErr_Format(g_PyExc_CCNSignedInfoError, "Error parsing"
" CCN_DTAG_PublisherPublicKey (decoder state %d)",
d->decoder.state);
goto error;
}
// self.publisherPublicKeyDigest = None # SHA256 hash
debug("PyObject_SetAttrString publisherPublicKeyDigest\n");
py_o = PyBytes_FromStringAndSize((const char*) ptr, size);
JUMP_IF_NULL(py_o, error);
r = PyObject_SetAttrString(py_obj_SignedInfo, "publisherPublicKeyDigest",
py_o);
Py_DECREF(py_o);
JUMP_IF_NEG(r, error);
/* Timestamp */
start = d->decoder.token_index;
ccn_parse_required_tagged_BLOB(d, CCN_DTAG_Timestamp, 1, -1);
stop = d->decoder.token_index;
r = ccn_ref_tagged_BLOB(CCN_DTAG_Timestamp, d->buf, start, stop, &ptr,
&size);
if (r < 0) {
PyErr_Format(g_PyExc_CCNSignedInfoError, "Error parsing"
" CCN_DTAG_Timestamp (decoder state %d)", d->decoder.state);
goto error;
}
// self.timeStamp = None # CCNx timestamp
debug("PyObject_SetAttrString timeStamp\n");
py_o = PyBytes_FromStringAndSize((const char*) ptr, size);
JUMP_IF_NULL(py_o, error);
r = PyObject_SetAttrString(py_obj_SignedInfo, "timeStamp", py_o);
Py_DECREF(py_o);
JUMP_IF_NEG(r, error);
/* Type */
assert(d->decoder.state >= 0);
r = ccn_parse_optional_tagged_binary_number(d, CCN_DTAG_Type, 3, 3,
CCN_CONTENT_DATA);
if (d->decoder.state < 0) {
PyErr_SetString(g_PyExc_CCNSignedInfoError, "Unable to parse type");
goto error;
}
py_o = _pyccn_Int_FromLong(r);
JUMP_IF_NULL(py_o, error);
r = PyObject_SetAttrString(py_obj_SignedInfo, "type", py_o);
Py_DECREF(py_o);
JUMP_IF_NEG(r, error);
/*
start = d->decoder.token_index;
ccn_parse_optional_tagged_BLOB(d, CCN_DTAG_Type, 1, -1);
stop = d->decoder.token_index;
r = ccn_ref_tagged_BLOB(CCN_DTAG_Type, d->buf, start, stop, &ptr, &size);
if (r == 0) {
// type = None # CCNx type
// TODO: Provide a string representation with the Base64 mnemonic?
debug("PyObject_SetAttrString type\n");
py_o = PyByteArray_FromStringAndSize((const char*) ptr, size);
JUMP_IF_NULL(py_o, error);
r = PyObject_SetAttrString(py_obj_SignedInfo, "type", py_o);
Py_DECREF(py_o);
JUMP_IF_NEG(r, error);
}
*/
/* FreshnessSeconds */
r = ccn_parse_optional_tagged_nonNegativeInteger(d, CCN_DTAG_FreshnessSeconds);
if (r >= 0) {
// self.freshnessSeconds = None
debug("PyObject_SetAttrString freshnessSeconds\n");
py_o = _pyccn_Int_FromLong(r);
JUMP_IF_NULL(py_o, error);
r = PyObject_SetAttrString(py_obj_SignedInfo, "freshnessSeconds", py_o);
Py_DECREF(py_o);
JUMP_IF_NEG(r, error);
}
/* FinalBlockID */
#if 0 /* old code (left in case mine is wrong - dk) */
if (ccn_buf_match_dtag(d, CCN_DTAG_FinalBlockID)) {
ccn_buf_advance(d);
start = d->decoder.token_index;
if (ccn_buf_match_some_blob(d))
ccn_buf_advance(d);
stop = d->decoder.token_index;
ccn_buf_check_close(d);
if (d->decoder.state >= 0 && stop > start) {
// self.finalBlockID = None
fprintf(stderr, "PyObject_SetAttrString finalBlockID, len=%zd\n", stop - start);
py_o = PyByteArray_FromStringAndSize((const char*) (d->buf + start), stop - start);
PyObject_SetAttrString(py_obj_SignedInfo, "finalBlockID", py_o);
Py_INCREF(py_o);
}
}
#endif
start = d->decoder.token_index;
ccn_parse_optional_tagged_BLOB(d, CCN_DTAG_FinalBlockID, 1, -1);
stop = d->decoder.token_index;
r = ccn_ref_tagged_BLOB(CCN_DTAG_FinalBlockID, d->buf, start, stop, &ptr,
&size);
if (r == 0) {
// self.finalBlockID = None
debug("PyObject_SetAttrString finalBlockID, len=%zd\n", size);
py_o = PyBytes_FromStringAndSize((const char*) ptr, size);
JUMP_IF_NULL(py_o, error);
r = PyObject_SetAttrString(py_obj_SignedInfo, "finalBlockID", py_o);
Py_DECREF(py_o);
JUMP_IF_NEG(r, error);
}
/* KeyLocator */
#if 0 /* Old code in case mine is wrong - dk */
start = d->decoder.token_index;
if (ccn_buf_match_dtag(d, CCN_DTAG_KeyLocator))
ccn_buf_advance_past_element(d);
stop = d->decoder.token_index;
if (d->decoder.state >= 0 && stop > start) {
fprintf(stderr, "PyObject_SetAttrString keyLocator, len=%zd\n", stop - start);
struct ccn_charbuf* keyLocator = ccn_charbuf_create();
ccn_charbuf_append(keyLocator, d->buf + start, stop - start);
// self.keyLocator = None
py_o = KeyLocator_obj_from_ccn(keyLocator); // it will free
PyObject_SetAttrString(py_obj_SignedInfo, "keyLocator", py_o);
Py_INCREF(py_o);
}
#endif
/*
* KeyLocator is not a BLOB, but an another structure, this requires
* us to parse it differently
*/
start = d->decoder.token_index;
if (ccn_buf_match_dtag(d, CCN_DTAG_KeyLocator)) {
struct ccn_charbuf *key_locator;
PyObject *py_key_locator;
r = ccn_buf_advance_past_element(d);
if (r < 0) {
PyErr_Format(g_PyExc_CCNSignedInfoError, "Error locating"
" CCN_DTAG_KeyLocator (decoder state: %d, r: %d)",
d->decoder.state, r);
goto error;
}
stop = d->decoder.token_index;
/*
debug("element_index = %zd size = %zd nest = %d numval = %zd state = %d"
" token_index %zd\n",
d->decoder.element_index, d->decoder.index, d->decoder.nest,
d->decoder.numval, d->decoder.state, d->decoder.token_index);
assert(d->decoder.state >= 0);
*/
ptr = d->buf + start;
size = stop - start;
assert(size > 0);
debug("PyObject_SetAttrString keyLocator, len=%zd\n", size);
py_key_locator = CCNObject_New_charbuf(KEY_LOCATOR, &key_locator);
JUMP_IF_NULL(py_key_locator, error);
r = ccn_charbuf_append(key_locator, ptr, size);
if (r < 0) {
Py_DECREF(py_key_locator);
PyErr_NoMemory();
goto error;
}
// self.keyLocator = None
py_o = KeyLocator_obj_from_ccn(py_key_locator);
Py_DECREF(py_key_locator);
JUMP_IF_NULL(py_o, error);
r = PyObject_SetAttrString(py_obj_SignedInfo, "keyLocator", py_o);
Py_DECREF(py_o);
JUMP_IF_NEG(r, error);
}
ccn_buf_check_close(d);
if (d->decoder.state < 0) {
PyErr_Format(g_PyExc_CCNSignedInfoError, "SignedInfo decoding error"
" (decoder state: %d, numval: %zd)", d->decoder.state,
d->decoder.numval);
goto error;
}
// 4) Return the created object
debug("SignedInfo_from_ccn ends\n");
return py_obj_SignedInfo;
error:
Py_DECREF(py_obj_SignedInfo);
return NULL;
}
