static int
start_interest(struct sync_diff_data *diff_data) {
static char *here = "sync_track.start_interest";
struct SyncRootStruct *root = diff_data->root;
struct SyncBaseStruct *base = root->base;
struct ccns_handle *ch = diff_data->client_data;
struct SyncHashCacheEntry *ce = ch->next_ce;
struct ccn_charbuf *prefix = SyncCopyName(diff_data->root->topoPrefix);
int res = 0;
struct ccn *ccn = base->sd->ccn;
if (ccn == NULL) {
ccn_charbuf_destroy(&prefix);
return SyncNoteFailed(root, here, "bad ccn handle", __LINE__);
}
res |= ccn_name_append_str(prefix, "\xC1.S.ra");
res |= ccn_name_append(prefix, root->sliceHash->buf, root->sliceHash->length);
if (ce != NULL) {
// append the best component seen
res |= ccn_name_append(prefix, ce->hash->buf, ce->hash->length);
} else {
// append an empty component
res |= ccn_name_append(prefix, "", 0);
}
struct SyncNameAccum *excl = SyncExclusionsFromHashList(root, NULL, ch->hashSeen);
struct ccn_charbuf *template = SyncGenInterest(NULL,
/**
*
* Create new face by sending out a request Interest
* The actual new face instance is returned
*
*/
static
struct ccn_face_instance *create_face(struct ccn *h, struct ccn_charbuf *local_scope_template,
struct ccn_charbuf *no_name, struct ccn_face_instance *face_instance)
{
struct ccn_charbuf *newface = NULL;
struct ccn_charbuf *signed_info = NULL;
struct ccn_charbuf *temp = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *resultbuf = NULL;
struct ccn_parsed_ContentObject pcobuf = {0};
struct ccn_face_instance *new_face_instance = NULL;
const unsigned char *ptr = NULL;
size_t length = 0;
int res = 0;
/* Encode the given face instance */
newface = ccn_charbuf_create();
ccnb_append_face_instance(newface, face_instance);
temp = ccn_charbuf_create();
res = ccn_sign_content(h, temp, no_name, NULL, newface->buf, newface->length);
resultbuf = ccn_charbuf_create();
/* Construct the Interest name that will create the face */
name = ccn_charbuf_create();
ccn_name_init(name);
ccn_name_append_str(name, "ccnx");
ccn_name_append(name, face_instance->ccnd_id, face_instance->ccnd_id_size);
ccn_name_append_str(name, face_instance->action);
ccn_name_append(name, temp->buf, temp->length);
/* send Interest to retrieve Data that contains the newly created face */
res = ccn_get(h, name, local_scope_template, 1000, resultbuf, &pcobuf, NULL, 0);
ON_ERROR_CLEANUP(res);
/* decode Data to get the actual face instance */
res = ccn_content_get_value(resultbuf->buf, resultbuf->length, &pcobuf, &ptr, &length);
ON_ERROR_CLEANUP(res);
new_face_instance = ccn_face_instance_parse(ptr, length);
ccn_charbuf_destroy(&newface);
ccn_charbuf_destroy(&signed_info);
ccn_charbuf_destroy(&temp);
ccn_charbuf_destroy(&resultbuf);
ccn_charbuf_destroy(&name);
return new_face_instance;
cleanup:
ccn_charbuf_destroy(&newface);
ccn_charbuf_destroy(&signed_info);
ccn_charbuf_destroy(&temp);
ccn_charbuf_destroy(&resultbuf);
ccn_charbuf_destroy(&name);
return NULL;
}
/**
* Append Components from a flatname to a ccnb-encoded Name
* @param dst is the destination, which should hold a ccnb-encoded Name
* @param flatname points to first byte of flatname
* @param size is the number of bytes in flatname
* @param skip is the number of components at the front of flatname to skip
* @param count is the maximum number of components to append, or -1 for all
* @returns number of appended components, or -1 if there is an error.
*/
int
ccn_name_append_flatname(struct ccn_charbuf *dst,
const unsigned char *flatname, size_t size,
int skip, int count)
{
int ans;
int compnum;
int i;
int rnc;
int res;
const unsigned char *cp;
size_t cs;
if (skip < 0)
return(-1);
ans = 0;
compnum = 0;
for (i = 0; i < size; i += CCNFLATSKIP(rnc)) {
if (ans == count)
return(ans);
rnc = ccn_flatname_next_comp(flatname + i, size - i);
if (rnc <= 0)
return(-1);
cp = flatname + i + CCNFLATDELIMSZ(rnc);
cs = CCNFLATDATASZ(rnc);
if (compnum >= skip) {
res = ccn_name_append(dst, cp, cs);
if (res < 0)
return(-1);
ans++;
}
compnum++;
}
return(ans);
}
int
ccns_slice_name(struct ccn_charbuf *nm, struct ccns_slice *s)
{
struct ccn_charbuf *c;
struct ccn_digest *digest = NULL;
struct ccn_charbuf *hash = NULL;
int res = 0;
c = ccn_charbuf_create();
if (c == NULL)
return (-1);
res = append_slice(c, s);
if (res < 0)
goto Cleanup;
digest = ccn_digest_create(CCN_DIGEST_SHA256);
hash = ccn_charbuf_create_n(ccn_digest_size(digest));
if (hash == NULL)
goto Cleanup;
ccn_digest_init(digest);
res |= ccn_digest_update(digest, c->buf, c->length);
res |= ccn_digest_final(digest, hash->buf, hash->limit);
if (res < 0)
goto Cleanup;
hash->length = hash->limit;
if (ccn_name_from_uri(nm, "ccnx:/%C1.M.S.localhost/%C1.S.cs") < 0)
res = -1;
res |= ccn_name_append(nm, hash->buf, hash->length);
Cleanup:
ccn_charbuf_destroy(&c);
ccn_digest_destroy(&digest);
ccn_charbuf_destroy(&hash);
return (res);
}
struct ccn_charbuf* CcnH_signForwardingEntry(struct ccn* ccnh, CCNDID ccndid, struct ccn_forwarding_entry* fe) {
struct ccn_charbuf* request = ccn_charbuf_create();
ccnb_append_forwarding_entry(request, fe);
struct ccn_charbuf* emptyname = ccn_charbuf_create();
ccn_name_init(emptyname);
struct ccn_charbuf* signed_request = ccn_charbuf_create();
ccn_sign_content(ccnh, signed_request, emptyname, NULL, request->buf, request->length);
struct ccn_charbuf* reqname = ccn_charbuf_create();
ccn_name_from_uri(reqname, "ccnx:/ccnx");
ccn_name_append(reqname, ccndid, CCNDID_length);
ccn_name_append_str(reqname, fe->action);
ccn_name_append(reqname, signed_request->buf, signed_request->length);
ccn_charbuf_destroy(&request);
ccn_charbuf_destroy(&emptyname);
ccn_charbuf_destroy(&signed_request);
return reqname;
}
void
ccn_ssh_connect(char *remote_name_str)
{
dropbear_log(LOG_WARNING,"Enter ccn_ssh_connect");
int result;
struct ccn_charbuf *remote_name;
/*
struct ccn_pkey *server_pkey;
void *encrypted_local_name;
size_t encrypted_local_name_length;
*/
struct ccn_charbuf *connect_template;
remote_name = ccn_charbuf_create();
result = ccn_name_from_uri(remote_name,remote_name_str);
if( result < 0 )
dropbear_exit("Could not parse server uri");
ccn_name_append_str(remote_name,"ssh");
ccn_name_append_str(remote_name,"client");
/*
server_pkey = ssh_ccn_retrieve_public_key(
cli_opts.ssh_ccn,
cli_opts.remote_name_str,
cli_opts.ccn_cached_keystore);
if( server_pkey == NULL )
dropbear_exit("Could not get server public key");
result = ccn_pubkey_encrypt(server_pkey,
cli_opts.ccnxdomain,
strlen(cli_opts.ccnxdomain),
&encrypted_local_name,
&encrypted_local_name_length);
ccn_name_append(remote_name,encrypted_local_name);
*/
ccn_name_append(remote_name,cli_opts.ccnxdomain,strlen(cli_opts.ccnxdomain));
dropbear_log(LOG_WARNING,"Connecting to remote:");
print_ccnb_charbuf(remote_name);
connect_template = make_connect_template();
result = ccn_express_interest(cli_opts.ssh_ccn,
remote_name,
&newServerAction,
connect_template);
if( result < 0 )
dropbear_exit("Failed to express interest to server");
}
void NdnMediaProcess::initPipe(struct ccn_closure *selfp, struct ccn_upcall_info *info, UserDataBuf *userBuf) {
fprintf(stderr, "initializing pipe\n");
// get seq
const unsigned char *ccnb = info->content_ccnb;
size_t ccnb_size = info->pco->offset[CCN_PCO_E];
struct ccn_indexbuf *comps = info->content_comps;
long seq;
const unsigned char *seqptr = NULL;
char *endptr = NULL;
size_t seq_size = 0;
int k = comps->n - 2;
if (userBuf->seq < 0) {
seq = ccn_ref_tagged_BLOB(CCN_DTAG_Component, ccnb,
comps->buf[k], comps->buf[k + 1],
&seqptr, &seq_size);
if (seq >= 0) {
seq = strtol((const char *)seqptr, &endptr, 10);
if (endptr != ((const char *)seqptr) + seq_size)
seq = -1;
}
if (seq >= 0) {
userBuf->seq = seq;
}
else {
return;
}
}
fprintf(stderr, "fetched content with seq %d\n", seq);
// send hint-ahead interests
for (int i = 0; i < hint_ahead; i ++) {
userBuf->seq++;
struct ccn_charbuf *pathbuf = ccn_charbuf_create();
ccn_name_init(pathbuf);
ccn_name_append_components(pathbuf, ccnb, comps->buf[0], comps->buf[k]);
struct ccn_charbuf *temp = ccn_charbuf_create();
ccn_charbuf_putf(temp, "%ld", userBuf->seq);
ccn_name_append(pathbuf, temp->buf, temp->length);
// no need to trylock as we already have the lock
// this should use pipe callback, selfp is normal callback
int res = ccn_express_interest(info->h, pathbuf, userBuf->data_buf.pipe_callback, NULL);
if (res < 0) {
fprintf(stderr, "Sending interest failed at normal processor\n");
std::exit(1);
}
ccn_charbuf_destroy(&pathbuf);
ccn_charbuf_destroy(&temp);
}
}
void CcnCC_registerControlPrefix(CcnCC self) {
if (self->regControlPrefix) return;
struct ccn_charbuf* prefix = ccn_charbuf_create();
ccn_name_from_uri(prefix, "ccnx:/ccnx/ndnld");
ccn_name_append(prefix, self->ccndid, CCNDID_length);
ccn_name_append_str(prefix, "control");
struct ccn_closure* action = (struct ccn_closure*)calloc(1, sizeof(struct ccn_closure));
action->data = self;
action->p = &CcnCC_controlInterest;
ccn_set_interest_filter(self->ccnh, prefix, action);
ccn_charbuf_destroy(&prefix);
}
void CcnLAC_fetchFaceid(CcnLAC self, CCNDID ccndid) {
struct ccn_charbuf* prefix = ccn_charbuf_create();
ccn_name_from_uri(prefix, "ccnx:/ccnx/ndnld");
ccn_name_append(prefix, ccndid, CCNDID_length);
ccn_name_append_str(prefix, "discover-faceid");
struct ccn_forwarding_entry* fe = CcnH_buildForwardingEntry(CcnPrefixOp_selfreg, ccndid, 0, prefix);
fe->flags = CCN_FORW_LAST | CCN_FORW_LOCAL;
fe->lifetime = 1;
CcnH_regForwardingEntry(self->ccnh, ccndid, fe, self, &CcnLAC_fetchFaceidCb);
ccn_charbuf_destroy(&prefix);
free(fe);
}
/**
* Initiates a stream to download metadata (relations)
*
* @param id identifier of the ccn stream
* @param pname name of the object containing the metadata
* @param pmetaname name of the meta object to download
* @param pipeline number of parallel requisitions for chunks
*/
bool CCNGet::initMetaStream(string id, string pname, string pmetaname, int pipeline)
{
name = ccn_charbuf_create();
name->length = 0;
ccn_name_from_uri(name, pname.c_str());
templ = make_template(0,-1);
ccn = ccn_create();
if (ccn_connect(ccn,NULL) == -1) return false;
if (ccn_resolve_version(ccn, name, CCN_V_HIGHEST, 1000) < 1) return false;
ccn_name_append(name, meta, sizeof(meta));
ccn_name_append_str(name, pmetaname.c_str());
fetch = ccn_fetch_new(ccn);
stream = ccn_fetch_open(fetch, name, id.c_str(), templ, pipeline, CCN_V_HIGHEST, ASSUMEFIXED);
if (stream == NULL) return false;
else return true;
}
/**
* should probably return a new cob, rather than reusing one.
* should publish link as:
* CCNRID_POLICY_URI("ccnx:/%C1.M.S.localhost/%C1.M.SRV/repository/POLICY)/%C1.M.K--pubid--/--version--/%00
* should have key locator which is the key name of the repository
*/
PUBLIC struct ccn_charbuf *
ccnr_init_policy_link_cob(struct ccnr_handle *ccnr, struct ccn *h,
struct ccn_charbuf *targetname)
{
struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT;
struct ccn_charbuf *name = ccn_charbuf_create();
struct ccn_charbuf *pubid = ccn_charbuf_create();
struct ccn_charbuf *pubkey = ccn_charbuf_create();
struct ccn_charbuf *keyid = ccn_charbuf_create();
struct ccn_charbuf *content = ccn_charbuf_create();
struct ccn_charbuf *cob = ccn_charbuf_create();
struct ccn_charbuf *answer = NULL;
int res;
res = ccn_get_public_key(h, NULL, pubid, pubkey);
if (res < 0)
goto Bail;
if (ccn_name_from_uri(name, CCNRID_POLICY_URI) < 0)
goto Bail;
res |= ccn_charbuf_append_value(keyid, CCN_MARKER_CONTROL, 1);
res |= ccn_charbuf_append_string(keyid, ".M.K");
res |= ccn_charbuf_append_value(keyid, 0, 1);
res |= ccn_charbuf_append_charbuf(keyid, pubid);
res |= ccn_name_append(name, keyid->buf, keyid->length);
res |= ccn_create_version(h, name, CCN_V_NOW, 0, 0);
if (ccn_name_from_uri(name, "%00") < 0)
goto Bail;
sp.sp_flags |= CCN_SP_FINAL_BLOCK;
sp.type = CCN_CONTENT_LINK;
res |= ccnb_append_Link(content, targetname, "Repository Policy", NULL);
if (res != 0)
goto Bail;
res |= ccn_sign_content(h, cob, name, &sp, content->buf, content->length);
if (res != 0)
goto Bail;
answer = cob;
cob = NULL;
Bail:
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&pubid);
ccn_charbuf_destroy(&pubkey);
ccn_charbuf_destroy(&keyid);
ccn_charbuf_destroy(&content);
ccn_charbuf_destroy(&cob);
return (answer);
}
static struct ccn_charbuf *
ccnr_init_service_ccnb(struct ccnr_handle *ccnr, struct ccn *h, const char *baseuri, int freshness)
{
struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT;
struct ccn_charbuf *name = ccn_charbuf_create();
struct ccn_charbuf *pubid = ccn_charbuf_create();
struct ccn_charbuf *pubkey = ccn_charbuf_create();
struct ccn_charbuf *keyid = ccn_charbuf_create();
struct ccn_charbuf *cob = ccn_charbuf_create();
int res;
res = ccn_get_public_key(h, NULL, pubid, pubkey);
if (res < 0) abort();
ccn_name_from_uri(name, baseuri);
ccn_charbuf_append_value(keyid, CCN_MARKER_CONTROL, 1);
ccn_charbuf_append_string(keyid, ".M.K");
ccn_charbuf_append_value(keyid, 0, 1);
ccn_charbuf_append_charbuf(keyid, pubid);
ccn_name_append(name, keyid->buf, keyid->length);
ccn_create_version(h, name, 0, ccnr->starttime, ccnr->starttime_usec * 1000);
sp.template_ccnb = ccn_charbuf_create();
ccnb_element_begin(sp.template_ccnb, CCN_DTAG_SignedInfo);
ccnb_element_begin(sp.template_ccnb, CCN_DTAG_KeyLocator);
ccnb_element_begin(sp.template_ccnb, CCN_DTAG_KeyName);
ccn_charbuf_append_charbuf(sp.template_ccnb, name);
ccnb_element_end(sp.template_ccnb);
// ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_PublisherPublicKeyDigest,
// CCN_DTAG);
// ccn_charbuf_append_charbuf(sp.template_ccnb, pubid);
// ccnb_element_end(sp.template_ccnb);
ccnb_element_end(sp.template_ccnb);
ccnb_element_end(sp.template_ccnb);
sp.sp_flags |= CCN_SP_TEMPL_KEY_LOCATOR;
ccn_name_from_uri(name, "%00");
sp.sp_flags |= CCN_SP_FINAL_BLOCK;
sp.type = CCN_CONTENT_KEY;
sp.freshness = freshness;
res = ccn_sign_content(h, cob, name, &sp, pubkey->buf, pubkey->length);
if (res != 0) abort();
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&pubid);
ccn_charbuf_destroy(&pubkey);
ccn_charbuf_destroy(&keyid);
ccn_charbuf_destroy(&sp.template_ccnb);
return(cob);
}
int sign_interest(struct ccn_charbuf* name_signed, struct ccn_charbuf* name,
struct ccn_charbuf* signed_info, const char* digest_algorithm, struct ccn_pkey* key) {
int res = 0;
// Now assemble a signed Content object
// Use ccn_encode_ContentObject so we can specify the key of our choice
struct ccn_charbuf *tempContentObj = ccn_charbuf_create();
res = ccn_encode_ContentObject(tempContentObj, name, signed_info, NULL /* no data */, 0,
digest_algorithm, key);
if (res < 0) {
fprintf(stderr, "Error building content object (res == %d)\n", res);
return(res);
}
// Call replace_name to knock out the name;
// it would be more efficient to assemble this with no name a modified ccn_encode_ContentObject() call
// but that requires modification to the library function
struct ccn_charbuf *empty_name = ccn_charbuf_create();
struct ccn_charbuf *sigContentObj = ccn_charbuf_create();
ccn_name_init(empty_name);
// First prepend the namespace; (should this be done as a "name component"?)
ccn_charbuf_append(sigContentObj, NS_SIGNATURE, NS_SIGNATURE_LEN);
replace_name(sigContentObj, tempContentObj->buf, tempContentObj->length, empty_name);
//fprintf(stderr, "replace_name == %d (%s)\n", res, (res==0)?"ok":"fail");
/*
// Check that we didn't break things
struct ccn_parsed_ContentObject pco = {0};
res = ccn_parse_ContentObject(&sigContentObj->buf[NS_SIGNATURE_LEN], sigContentObj->length - NS_SIGNATURE_LEN, &pco, NULL);
if (res < 0) {
fprintf(stderr, "Error parsing built content object (res == %d)\n", res);
return(1);
}
*/
ccn_charbuf_destroy(&empty_name);
ccn_charbuf_destroy(&tempContentObj);
// Build the final name for the interest <prefix>/<namespace><contentObj>
ccn_charbuf_append_charbuf(name_signed, name); // Copy the name
ccn_name_append(name_signed, sigContentObj->buf, sigContentObj->length); // Concatenate the new component
// Dump the signature
// print_hex(stderr,&(sigContentObj->buf)[NS_SIGNATURE_LEN],sigContentObj->length - NS_SIGNATURE_LEN,12);
// fprintf(stderr,"\n");
//
ccn_charbuf_destroy(&sigContentObj);
return (res);
}
static void
express_bulkdata_interest(struct ccn *h, struct pending *p)
{
int res;
struct bulkdata *b = NULL;
int prefix_comps = -1;
int addl_comps = -1;
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *templ = NULL;
struct ccn_charbuf *seq = NULL;
b = p->parent;
if (b == NULL)
return;
name = ccn_charbuf_create();
templ = ccn_charbuf_create();
seq = ccn_charbuf_create();
ccn_charbuf_append(name, b->name_prefix->buf, b->name_prefix->length);
seq->length = 0;
(*b->seqfunc)(p->x, b->seqfunc_param, seq);
ccn_name_append(name, seq->buf, seq->length);
prefix_comps = -1;
addl_comps = 1;
ccn_charbuf_append_tt(templ, CCN_DTAG_Interest, CCN_DTAG);
ccn_charbuf_append_tt(templ, CCN_DTAG_Name, CCN_DTAG);
ccn_charbuf_append_closer(templ); /* </Name> */
// XXX - may want to set Min/MaxSuffixComponents
ccn_charbuf_append_closer(templ); /* </Interest> */
res = ccn_express_interest(h, name, &p->closure, templ);
assert(res >= 0); // XXX - handle this better
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&templ);
ccn_charbuf_destroy(&seq);
}
PUBLIC struct content_entry *
r_store_next_child_at_level(struct ccnr_handle *h,
struct content_entry *content, int level)
{
struct content_entry *next = NULL;
struct ccn_charbuf *name;
struct ccn_charbuf *flatname = NULL;
int res;
if (content == NULL)
return(NULL);
name = ccn_charbuf_create();
ccn_name_init(name);
res = ccn_name_append_flatname(name,
content->flatname->buf,
content->flatname->length, 0, level + 1);
if (res < level)
goto Bail;
if (res == level)
res = ccn_name_append(name, NULL, 0);
else if (res == level + 1)
res = ccn_name_next_sibling(name); // XXX - would be nice to have a flatname version of this
if (res < 0)
goto Bail;
if (CCNSHOULDLOG(h, LM_8, CCNL_FINER))
ccnr_debug_ccnb(h, __LINE__, "child_successor", NULL,
name->buf, name->length);
flatname = ccn_charbuf_create();
ccn_flatname_from_ccnb(flatname, name->buf, name->length);
next = r_store_look(h, flatname->buf, flatname->length);
if (next == content) {
// XXX - I think this case should not occur, but just in case, avoid a loop.
ccnr_debug_content(h, __LINE__, "urp", NULL, next);
next = NULL;
}
Bail:
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&flatname);
return(next);
}
void NdnMediaProcess::tick() {
// send new interest for every speaker
ruMutex->lock();
QHash<QString, UserDataBuf *>::const_iterator it = qhRemoteUser.constBegin();
while (it != qhRemoteUser.constEnd()) {
QString userName = it.key();
UserDataBuf *udb = it.value();
if (udb != NULL && udb->seq >= 0) {
udb->seq++;
struct ccn_charbuf *pathbuf = ccn_charbuf_create();
ccn_name_from_uri(pathbuf, userName.toLocal8Bit().constData());
ccn_name_append_str(pathbuf, "audio");
struct ccn_charbuf *temp = ccn_charbuf_create();
ccn_charbuf_putf(temp, "%ld", udb->seq);
ccn_name_append(pathbuf, temp->buf, temp->length);
/*
int c = 0;
while (pthread_mutex_trylock(&ccn_mutex) != 0) {
c++;
if (c > 10000000) {
fprintf(stderr, "cannot obtain lock! %s:%d\n", __FILE__, __LINE__);
std::exit(1);
}
}
*/
pthread_mutex_lock(&ccn_mutex);
int res = ccn_express_interest(ndnState.ccn, pathbuf, udb->data_buf.pipe_callback, NULL);
pthread_mutex_unlock(&ccn_mutex);
if (res < 0) {
fprintf(stderr, "Sending interest failed at normal processor\n");
exit(1);
}
ccn_charbuf_destroy(&pathbuf);
ccn_charbuf_destroy(&temp);
}
it++;
}
ruMutex->unlock();
}
/**
*
* Bind a prefix to a face
*
*/
static int
register_unregister_prefix(struct ccn *h, struct ccn_charbuf *local_scope_template,
struct ccn_charbuf *no_name, struct ccn_charbuf *name_prefix,
struct ccn_face_instance *face_instance, int operation)
{
struct ccn_charbuf *temp = NULL;
struct ccn_charbuf *resultbuf = NULL;
struct ccn_charbuf *signed_info = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *prefixreg = NULL;
struct ccn_parsed_ContentObject pcobuf = {0};
struct ccn_forwarding_entry forwarding_entry_storage = {0};
struct ccn_forwarding_entry *forwarding_entry = &forwarding_entry_storage;
struct ccn_forwarding_entry *new_forwarding_entry;
const unsigned char *ptr = NULL;
size_t length = 0;
int res;
/* Register or unregister the prefix */
forwarding_entry->action = (operation == OP_REG) ? "prefixreg" : "unreg";
forwarding_entry->name_prefix = name_prefix;
forwarding_entry->ccnd_id = face_instance->ccnd_id;
forwarding_entry->ccnd_id_size = face_instance->ccnd_id_size;
forwarding_entry->faceid = face_instance->faceid;
forwarding_entry->flags = -1;
forwarding_entry->lifetime = 2100;
prefixreg = ccn_charbuf_create();
ccnb_append_forwarding_entry(prefixreg, forwarding_entry);
temp = ccn_charbuf_create();
res = ccn_sign_content(h, temp, no_name, NULL, prefixreg->buf, prefixreg->length);
resultbuf = ccn_charbuf_create();
/* construct Interest containing prefixreg request */
name = ccn_charbuf_create();
ccn_name_init(name);
ccn_name_append_str(name, "ccnx");
ccn_name_append(name, face_instance->ccnd_id, face_instance->ccnd_id_size);
ccn_name_append_str(name, (operation == OP_REG) ? "prefixreg" : "unreg");
ccn_name_append(name, temp->buf, temp->length);
/* send Interest, get Data */
res = ccn_get(h, name, local_scope_template, 1000, resultbuf, &pcobuf, NULL, 0);
ON_ERROR_CLEANUP(res);
res = ccn_content_get_value(resultbuf->buf, resultbuf->length, &pcobuf, &ptr, &length);
ON_ERROR_CLEANUP(res);
/* extract new forwarding entry from Data */
new_forwarding_entry = ccn_forwarding_entry_parse(ptr, length);
ON_NULL_CLEANUP(new_forwarding_entry);
res = new_forwarding_entry->faceid;
ccn_forwarding_entry_destroy(&new_forwarding_entry);
ccn_charbuf_destroy(&signed_info);
ccn_charbuf_destroy(&temp);
ccn_charbuf_destroy(&resultbuf);
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&prefixreg);
return res;
cleanup:
ccn_forwarding_entry_destroy(&new_forwarding_entry);
ccn_charbuf_destroy(&signed_info);
ccn_charbuf_destroy(&temp);
ccn_charbuf_destroy(&resultbuf);
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&prefixreg);
return -1;
}
/*
* This upcall gets called for each piece of incoming content that
* matches one of our interests. We need to issue a new interest that
* excludes another component at the current level, and perhaps also
* and interest to start exploring the next level. Thus if the matched
* interest is
* /a/b/c exclude {d,e,f,i,j,k}
* and we get
* /a/b/c/g/h
* we would issue a new interest
* /a/b/c exclude {d,e,f,g,i,j,k}
* to continue exploring the current level, plus a simple interest
* /a/b/c/g
* to start exploring the next level as well.
*
* This does end up fetching each piece of content multiple times, once for
* each level in the name. The repeated requests will be answered from the local
* content store, though, and so should not generate extra network traffic.
* There is a lot of unanswerable interest generated, though.
*
* To prevent the interests from becoming too huge, we may need to split them.
* Thus if the first new interest above were deemed too large, we could instead
* issue the two interests
* /a/b/c exclude {d,e,f,g,*}
* /a/b/c exclude {*,g,i,j,k}
* where * stands for a Bloom filter that excludes anything. Note the
* repetition of g to ensure that these two interests cover disjoint portions
* of the hierarchy. We need to keep track of the endpoint conditions
* as well as the excluded set in our upcall data.
* When a split happens, we need a new closure to track it, as we do when
* we start exploring a new level.
*/
static enum ccn_upcall_res
incoming_content(
struct ccn_closure *selfp,
enum ccn_upcall_kind kind,
struct ccn_upcall_info *info)
{
struct ccn_charbuf *c = NULL;
struct ccn_charbuf *comp = NULL;
struct ccn_charbuf *uri = NULL;
const unsigned char *ccnb = NULL;
size_t ccnb_size = 0;
struct ccn_indexbuf *comps = NULL;
int matched_comps = 0;
int res;
int i;
struct ccn_traversal *data = get_my_data(selfp);
if (kind == CCN_UPCALL_FINAL) {
for (i = 0; i < data->n_excl; i++)
ccn_charbuf_destroy(&(data->excl[i]));
if (data->excl != NULL)
free(data->excl);
free(data);
free(selfp);
return(0);
}
if (kind == CCN_UPCALL_INTEREST_TIMED_OUT)
return(0);
if (kind == CCN_UPCALL_CONTENT_BAD)
return(0);
if (kind == CCN_UPCALL_CONTENT_UNVERIFIED) {
if ((data->flags & MUST_VERIFY) != 0)
return(CCN_UPCALL_RESULT_VERIFY);
}
if (kind != CCN_UPCALL_CONTENT && kind != CCN_UPCALL_CONTENT_UNVERIFIED) abort();
ccnb = info->content_ccnb;
ccnb_size = info->pco->offset[CCN_PCO_E];
comps = info->content_comps;
matched_comps = info->pi->prefix_comps;
c = ccn_charbuf_create();
uri = ccn_charbuf_create();
if (matched_comps + 1 > comps->n) {
ccn_uri_append(c, ccnb, ccnb_size, 1);
fprintf(stderr, "How did this happen? %s\n", ccn_charbuf_as_string(uri));
exit(1);
}
data->counter[0]++; /* Tell main that something new came in */
/* Recover the same prefix as before */
ccn_name_init(c);
ccn_name_append_components(c, ccnb, comps->buf[0], comps->buf[matched_comps]);
comp = ccn_charbuf_create();
ccn_name_init(comp);
if (matched_comps + 1 == comps->n) {
/* Reconstruct the implicit content digest component */
ccn_digest_ContentObject(ccnb, info->pco);
ccn_name_append(comp, info->pco->digest, info->pco->digest_bytes);
}
else {
ccn_name_append_components(comp, ccnb,
comps->buf[matched_comps],
comps->buf[matched_comps + 1]);
}
data->excl = realloc(data->excl, (data->n_excl + 1) * sizeof(data->excl[0]));
data->excl[data->n_excl++] = comp;
comp = NULL;
qsort(data->excl, data->n_excl, sizeof(data->excl[0]), &namecompare);
res = express_my_interest(info->h, selfp, c);
if (res == -1) {
struct ccn_closure *high = split_my_excludes(selfp);
if (high == NULL) abort();
express_my_interest(info->h, selfp, c);
express_my_interest(info->h, high, c);
}
/* Explore the next level, if there is one. */
if (matched_comps + 2 < comps->n) {
struct ccn_traversal *newdat = NULL;
struct ccn_closure *cl;
newdat = calloc(1, sizeof(*newdat));
newdat->magic = 68955871;
newdat->warn = 1492;
newdat->counter = data->counter;
newdat->flags = data->flags & ~(EXCLUDE_LOW | EXCLUDE_HIGH);
newdat->n_excl = 0;
newdat->excl = NULL;
cl = calloc(1, sizeof(*cl));
cl->p = &incoming_content;
cl->data = newdat;
ccn_name_init(c);
ccn_name_append_components(c, ccnb,
comps->buf[0],
comps->buf[matched_comps + 1]);
express_my_interest(info->h, cl, c);
}
else {
res = ccn_uri_append(uri, info->content_ccnb, info->pco->offset[CCN_PCO_E], 1);
if (res < 0)
fprintf(stderr, "*** Error: ccn_traverse line %d res=%d\n", __LINE__, res);
else
printf("%s\n", ccn_charbuf_as_string(uri));
}
ccn_charbuf_destroy(&c);
ccn_charbuf_destroy(&uri);
return(0);
}
enum ccn_upcall_res
incoming_content(
struct ccn_closure *selfp,
enum ccn_upcall_kind kind,
struct ccn_upcall_info *info)
{
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *templ = NULL;
struct ccn_charbuf *temp = NULL;
const unsigned char *ccnb = NULL;
size_t ccnb_size = 0;
const unsigned char *data = NULL;
size_t data_size = 0;
size_t written;
const unsigned char *ib = NULL; /* info->interest_ccnb */
struct ccn_indexbuf *ic = NULL;
int res;
struct mydata *md = selfp->data;
if (kind == CCN_UPCALL_FINAL) {
if (md != NULL) {
selfp->data = NULL;
free(md);
md = NULL;
}
return(CCN_UPCALL_RESULT_OK);
}
if (kind == CCN_UPCALL_INTEREST_TIMED_OUT)
return(CCN_UPCALL_RESULT_REEXPRESS);
if (kind != CCN_UPCALL_CONTENT && kind != CCN_UPCALL_CONTENT_UNVERIFIED)
return(CCN_UPCALL_RESULT_ERR);
if (md == NULL)
selfp->data = md = calloc(1, sizeof(*md));
ccnb = info->content_ccnb;
ccnb_size = info->pco->offset[CCN_PCO_E];
ib = info->interest_ccnb;
ic = info->interest_comps;
/* XXX - must verify sig, and make sure it is LEAF content */
res = ccn_content_get_value(ccnb, ccnb_size, info->pco, &data, &data_size);
if (res < 0) abort();
if (data_size > CHUNK_SIZE) {
/* For us this is spam. Give up now. */
fprintf(stderr, "*** Segment %d found with a data size of %d."
" This program only works with segments of 1024 bytes."
" Try ccncatchunks2 instead.\n",
(int)selfp->intdata, (int)data_size);
exit(1);
}
/* OK, we will accept this block. */
written = fwrite(data, data_size, 1, stdout);
if (written != 1)
exit(1);
/* A short block signals EOF for us. */
if (data_size < CHUNK_SIZE)
exit(0);
/* Ask for the next one */
name = ccn_charbuf_create();
ccn_name_init(name);
if (ic->n < 2) abort();
res = ccn_name_append_components(name, ib, ic->buf[0], ic->buf[ic->n - 2]);
if (res < 0) abort();
temp = ccn_charbuf_create();
ccn_charbuf_putf(temp, "%d", ++(selfp->intdata));
ccn_name_append(name, temp->buf, temp->length);
ccn_charbuf_destroy(&temp);
templ = make_template(md, info);
res = ccn_express_interest(info->h, name, selfp, templ);
if (res < 0) abort();
ccn_charbuf_destroy(&templ);
ccn_charbuf_destroy(&name);
return(CCN_UPCALL_RESULT_OK);
}
int
main(int argc, char **argv)
{
struct ccn *ccn = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *templ = NULL;
struct ccn_closure *incoming = NULL;
const char *arg = NULL;
int res;
int opt;
struct mydata *mydata;
int allow_stale = 0;
while ((opt = getopt(argc, argv, "ha")) != -1) {
switch (opt) {
case 'a':
allow_stale = 1;
break;
case 'h':
default:
usage(argv[0]);
}
}
arg = argv[optind];
if (arg == NULL)
usage(argv[0]);
name = ccn_charbuf_create();
res = ccn_name_from_uri(name, arg);
if (res < 0) {
fprintf(stderr, "%s: bad ccn URI: %s\n", argv[0], arg);
exit(1);
}
if (argv[optind + 1] != NULL)
fprintf(stderr, "%s warning: extra arguments ignored\n", argv[0]);
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
ccn_name_append(name, "0", 1);
incoming = calloc(1, sizeof(*incoming));
incoming->p = &incoming_content;
mydata = calloc(1, sizeof(*mydata));
mydata->allow_stale = allow_stale;
incoming->data = mydata;
templ = make_template(mydata, NULL);
ccn_express_interest(ccn, name, incoming, templ);
ccn_charbuf_destroy(&templ);
ccn_charbuf_destroy(&name);
/* Run a little while to see if there is anything there */
res = ccn_run(ccn, 200);
if (incoming->intdata == 0) {
fprintf(stderr, "%s: not found: %s\n", argv[0], arg);
exit(1);
}
/* We got something, run until end of data or somebody kills us */
while (res >= 0) {
fflush(stdout);
res = ccn_run(ccn, 200);
}
ccn_destroy(&ccn);
exit(res < 0);
}
int
main(int argc, char **argv)
{
struct ccn *h = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *null_name = NULL;
struct ccn_charbuf *name_prefix = NULL;
struct ccn_charbuf *newface = NULL;
struct ccn_charbuf *prefixreg = NULL;
struct ccn_charbuf *resultbuf = NULL;
struct ccn_charbuf *temp = NULL;
struct ccn_charbuf *templ = NULL;
const unsigned char *ptr = NULL;
size_t length = 0;
const char *arg = NULL;
const char *progname = NULL;
struct ccn_parsed_ContentObject pcobuf = {0};
struct ccn_face_instance face_instance_storage = {0};
struct ccn_face_instance *face_instance = &face_instance_storage;
struct ccn_forwarding_entry forwarding_entry_storage = {0};
struct ccn_forwarding_entry *forwarding_entry = &forwarding_entry_storage;
struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT;
struct ccn_charbuf *keylocator_templ = NULL;
struct ccn_keystore *keystore = NULL;
long expire = -1;
int ipproto;
unsigned char ccndid_storage[32] = {0};
const unsigned char *ccndid = NULL;
size_t ccndid_size = 0;
int res;
int opt;
progname = argv[0];
while ((opt = getopt(argc, argv, "h")) != -1) {
switch (opt) {
case 'h':
default:
usage(progname);
}
}
/* Sanity check the URI and argument count */
arg = argv[optind];
if (arg == NULL)
usage(progname);
name = ccn_charbuf_create();
res = ccn_name_from_uri(name, arg);
if (res < 0) {
fprintf(stderr, "%s: bad ccn URI: %s\n", progname, arg);
exit(1);
}
if (argc - optind < 3 || argc - optind > 4)
usage(progname);
h = ccn_create();
res = ccn_connect(h, NULL);
if (res < 0) {
ccn_perror(h, "ccn_connect");
exit(1);
}
newface = ccn_charbuf_create();
temp = ccn_charbuf_create();
templ = ccn_charbuf_create();
keylocator_templ = ccn_charbuf_create();
resultbuf = ccn_charbuf_create();
name_prefix = ccn_charbuf_create();
null_name = ccn_charbuf_create();
CHKRES(ccn_name_init(null_name));
keystore = ccn_keystore_create();
/* We need to figure out our local ccnd's CCIDID */
/* Set up our Interest template to indicate scope 1 */
ccn_charbuf_reset(templ);
ccnb_element_begin(templ, CCN_DTAG_Interest);
ccnb_element_begin(templ, CCN_DTAG_Name);
ccnb_element_end(templ); /* </Name> */
ccnb_tagged_putf(templ, CCN_DTAG_Scope, "1");
ccnb_element_end(templ); /* </Interest> */
ccn_charbuf_reset(name);
CHKRES(res = ccn_name_from_uri(name, "ccnx:/%C1.M.S.localhost/%C1.M.SRV/ccnd/KEY"));
CHKRES(res = ccn_get(h, name, templ, 200, resultbuf, &pcobuf, NULL, 0));
res = ccn_ref_tagged_BLOB(CCN_DTAG_PublisherPublicKeyDigest,
resultbuf->buf,
pcobuf.offset[CCN_PCO_B_PublisherPublicKeyDigest],
pcobuf.offset[CCN_PCO_E_PublisherPublicKeyDigest],
&ccndid, &ccndid_size);
CHKRES(res);
if (ccndid_size > sizeof(ccndid_storage))
CHKRES(-1);
memcpy(ccndid_storage, ccndid, ccndid_size);
ccndid = ccndid_storage;
face_instance->action = "newface";
face_instance->ccnd_id = ccndid;
face_instance->ccnd_id_size = ccndid_size;
if (strcmp(argv[optind + 1], "tcp") == 0)
ipproto = 6;
else if (strcmp(argv[optind + 1], "udp") == 0)
ipproto = 17;
else
ipproto = atoi(argv[optind + 1]);
face_instance->descr.ipproto = ipproto; // XXX - 6 = tcp or 17 = udp
face_instance->descr.address = argv[optind + 2];
face_instance->descr.port = argv[optind + 3];
if (face_instance->descr.port == NULL)
face_instance->descr.port = CCN_DEFAULT_UNICAST_PORT;
face_instance->descr.mcast_ttl = -1;
face_instance->lifetime = (~0U) >> 1;
CHKRES(res = ccnb_append_face_instance(newface, face_instance));
temp->length = 0;
CHKRES(ccn_charbuf_putf(temp, "%s/.ccnx/.ccnx_keystore", getenv("HOME")));
res = ccn_keystore_init(keystore,
ccn_charbuf_as_string(temp),
"Th1s1sn0t8g00dp8ssw0rd.");
CHKRES(res);
ccnb_element_begin(keylocator_templ, CCN_DTAG_SignedInfo);
ccnb_element_begin(keylocator_templ, CCN_DTAG_KeyLocator);
ccnb_element_begin(keylocator_templ, CCN_DTAG_Key);
CHKRES(ccn_append_pubkey_blob(keylocator_templ, ccn_keystore_public_key(keystore)));
ccnb_element_end(keylocator_templ); /* </Key> */
ccnb_element_end(keylocator_templ); /* </KeyLocator> */
ccnb_element_end(keylocator_templ); /* </SignedInfo> */
sp.template_ccnb = keylocator_templ;
sp.sp_flags |= CCN_SP_TEMPL_KEY_LOCATOR;
sp.freshness = expire;
ccn_charbuf_reset(temp);
res = ccn_sign_content(h, temp, null_name, &sp,
newface->buf, newface->length);
CHKRES(res);
/* Create the new face */
CHKRES(ccn_name_init(name));
CHKRES(ccn_name_append_str(name, "ccnx"));
CHKRES(ccn_name_append(name, ccndid, ccndid_size));
CHKRES(ccn_name_append(name, "newface", 7));
CHKRES(ccn_name_append(name, temp->buf, temp->length));
res = ccn_get(h, name, templ, 1000, resultbuf, &pcobuf, NULL, 0);
if (res < 0) {
fprintf(stderr, "no response from face creation request\n");
exit(1);
}
ptr = resultbuf->buf;
length = resultbuf->length;
res = ccn_content_get_value(resultbuf->buf, resultbuf->length, &pcobuf, &ptr, &length);
CHKRES(res);
face_instance = ccn_face_instance_parse(ptr, length);
if (face_instance == NULL)
CHKRES(res = -1);
CHKRES(face_instance->faceid);
/* Finally, register the prefix */
ccn_charbuf_reset(name_prefix);
CHKRES(ccn_name_from_uri(name_prefix, arg));
forwarding_entry->action = "prefixreg";
forwarding_entry->name_prefix = name_prefix;
forwarding_entry->ccnd_id = ccndid;
forwarding_entry->ccnd_id_size = ccndid_size;
forwarding_entry->faceid = face_instance->faceid;
forwarding_entry->flags = -1; /* let ccnd decide */
forwarding_entry->lifetime = (~0U) >> 1;
prefixreg = ccn_charbuf_create();
CHKRES(res = ccnb_append_forwarding_entry(prefixreg, forwarding_entry));
ccn_charbuf_reset(temp);
res = ccn_sign_content(h, temp, null_name, &sp,
prefixreg->buf, prefixreg->length);
CHKRES(res);
CHKRES(ccn_name_init(name));
CHKRES(ccn_name_append_str(name, "ccnx"));
CHKRES(ccn_name_append(name, ccndid, ccndid_size));
CHKRES(ccn_name_append_str(name, "prefixreg"));
CHKRES(ccn_name_append(name, temp->buf, temp->length));
res = ccn_get(h, name, templ, 1000, resultbuf, &pcobuf, NULL, 0);
if (res < 0) {
fprintf(stderr, "no response from prefix registration request\n");
exit(1);
}
fprintf(stderr, "Prefix %s will be forwarded to face %d\n", arg, face_instance->faceid);
/* We're about to exit, so don't bother to free everything. */
ccn_destroy(&h);
exit(res < 0);
}
/**
* Convert a ccnx-scheme URI to a ccnb-encoded Name.
* The converted result is placed in c.
* On input, c may contain a base name, in which case relative URIs are allowed.
* Otherwise c should start out empty, and the URI must be absolute.
* @returns -1 if an error is found, otherwise returns the number of characters
* that were processed.
*/
int
ccn_name_from_uri(struct ccn_charbuf *c, const char *uri)
{
int res = 0;
struct ccn_charbuf *compbuf = NULL;
const char *stop = uri + strlen(uri);
const char *s = uri;
size_t cont = 0;
compbuf = ccn_charbuf_create();
if (compbuf == NULL) return(-1);
if (s[0] != '/') {
res = ccn_append_uri_component(compbuf, s, stop - s, &cont);
if (res < -2)
goto Done;
ccn_charbuf_reserve(compbuf, 1)[0] = 0;
if ((0 == strcasecmp((const char *)(compbuf->buf), "ccnx:") ||
0 == strcasecmp((const char *)(compbuf->buf), "ccn:")) &&
s[cont-1] == ':') {
s += cont;
cont = 0;
}
/// @bug XXX - need to error out on other uri schemes
}
if (s[0] == '/') {
ccn_name_init(c);
if (s[1] == '/') {
/* Skip over hostname part - not used in ccnx scheme */
s += 2;
compbuf->length = 0;
res = ccn_append_uri_component(compbuf, s, stop - s, &cont);
if (res < 0 && res != -2)
goto Done;
s += cont; cont = 0;
}
}
while (s[0] != 0 && s[0] != '?' && s[0] != '#') {
if (s[0] == '/')
s++;
compbuf->length = 0;
res = ccn_append_uri_component(compbuf, s, stop - s, &cont);
s += cont; cont = 0;
if (res < -2)
goto Done;
if (res == -2) {
res = 0; /* process . or equiv in URI */
continue;
}
if (res == -1) {
/* process .. in URI - discard last name component */
res = ccn_name_last_component_offset(c->buf, c->length);
if (res < 0)
goto Done;
c->length = res;
ccn_charbuf_append_closer(c);
continue;
}
res = ccn_name_append(c, compbuf->buf, compbuf->length);
if (res < 0)
goto Done;
}
Done:
ccn_charbuf_destroy(&compbuf);
if (res < 0)
return(-1);
if (c->length < 2 || c->buf[c->length-1] != CCN_CLOSE)
return(-1);
return(s - uri);
}
/**
* Resolve the version, based on existing ccn content.
* @param h is the the ccn handle; it may be NULL, but it is preferable to
* use the handle that the client probably already has.
* @param name is a ccnb-encoded Name prefix. It gets extended in-place with
* one additional Component such that it names highest extant
* version that can be found, subject to the supplied timeout.
* @param versioning_flags presently must be CCN_V_HIGH or CCN_V_HIGHEST,
* possibly combined with CCN_V_NESTOK. If CCN_V_NESTOK is not present
* and the ending component appears to be a version, the routine
* returns 0 immediately, on the assumption that an explicit
* version has already been provided.
* @param timeout_ms is a time value in milliseconds. This is applied per
* fetch attempt, so the total time may be longer by a factor that
* depends on the number of (ccn) hops to the source(s).
* @returns -1 for error, 0 if name could not be extended, 1 if was.
*/
int
ccn_resolve_version(struct ccn *h, struct ccn_charbuf *name,
int versioning_flags, int timeout_ms)
{
int res;
int myres = -1;
struct ccn_parsed_ContentObject pco_space = { 0 };
struct ccn_charbuf *templ = NULL;
struct ccn_charbuf *prefix = ccn_charbuf_create();
struct ccn_charbuf *cobj = ccn_charbuf_create();
struct ccn_parsed_ContentObject *pco = &pco_space;
struct ccn_indexbuf *ndx = ccn_indexbuf_create();
const unsigned char *vers = NULL;
size_t vers_size = 0;
int n;
struct ccn_indexbuf *nix = ccn_indexbuf_create();
unsigned char lowtime[7] = {CCN_MARKER_VERSION, 0, FF, FF, FF, FF, FF};
if ((versioning_flags & ~CCN_V_NESTOK & ~CCN_V_EST) != CCN_V_HIGH) {
ccn_seterror(h, EINVAL);
ccn_perror(h, "ccn_resolve_version is only implemented for versioning_flags = CCN_V_HIGH(EST)");
goto Finish;
}
n = ccn_name_split(name, nix);
if (n < 0)
goto Finish;
if ((versioning_flags & CCN_V_NESTOK) == 0) {
res = ccn_name_comp_get(name->buf, nix, n - 1, &vers, &vers_size);
if (res >= 0 && vers_size == 7 && vers[0] == CCN_MARKER_VERSION) {
myres = 0;
goto Finish;
}
}
templ = resolve_templ(templ, lowtime, sizeof(lowtime));
ccn_charbuf_append(prefix, name->buf, name->length); /* our copy */
cobj->length = 0;
res = ccn_get(h, prefix, templ, timeout_ms, cobj, pco, ndx, 0);
while (cobj->length != 0) {
if (pco->type == CCN_CONTENT_NACK) // XXX - also check for number of components
break;
res = ccn_name_comp_get(cobj->buf, ndx, n, &vers, &vers_size);
if (res < 0)
break;
if (vers_size == 7 && vers[0] == CCN_MARKER_VERSION) {
/* Looks like we have versions. */
name->length = 0;
ccn_charbuf_append(name, prefix->buf, prefix->length);
ccn_name_append(name, vers, vers_size);
myres = 0;
if ((versioning_flags & CCN_V_EST) == 0)
break;
templ = resolve_templ(templ, vers, vers_size);
if (templ == NULL) break;
cobj->length = 0;
res = ccn_get(h, prefix, templ, timeout_ms, cobj, pco, ndx,
CCN_GET_NOKEYWAIT);
}
else break;
}
Finish:
ccn_charbuf_destroy(&prefix);
ccn_charbuf_destroy(&cobj);
ccn_indexbuf_destroy(&ndx);
ccn_indexbuf_destroy(&nix);
ccn_charbuf_destroy(&templ);
return(myres);
}
int
sign_content_with_user_defined_keystore(struct ccn_charbuf *content_name,
struct ccn_charbuf *resultbuf,
const void *data,
size_t data_size,
char *keystore_path,
char *keystore_passphrase,
char *key_repo_name,
char *site_name,
char *router_name){
if ( nlsr->debugging )
printf("sign_content_with_user_defined_keystore called\n");
int res;
struct ccn_charbuf * pubid_out=ccn_charbuf_create();
struct ccn_charbuf * keyname;
struct ccn_keystore *keystore = NULL;
keystore=ccn_keystore_create();
res=ccn_keystore_init(keystore, keystore_path,keystore_passphrase );
if ( res < 0 ){
if ( nlsr->debugging )
printf("Error in initiating keystore :(\n");
ccn_keystore_destroy(&keystore);
return -1;
}
res=ccn_load_private_key (nlsr->ccn,
keystore_path,
keystore_passphrase,
pubid_out);
if(res < 0 ){
if ( nlsr->debugging )
printf("Error in loading keystore :( \n");
ccn_charbuf_destroy(&pubid_out);
return -1;
}
char *baseuri=(char *)calloc(strlen(key_repo_name)+strlen(site_name)+
strlen(router_name)+strlen("/%C1.R.N.Start")+5,sizeof(char));
memcpy(baseuri,key_repo_name,strlen(key_repo_name)+1);
if ( site_name[0] != '/')
memcpy(baseuri+strlen(baseuri),"/",1);
memcpy(baseuri+strlen(baseuri),site_name,strlen(site_name)+1);
memcpy(baseuri+strlen(baseuri),"/%C1.R.N.Start",strlen("/%C1.R.N.Start"));
memcpy(baseuri+strlen(baseuri),router_name,strlen(router_name)+1);
baseuri[strlen(baseuri)]='\0';
keyname=ccn_charbuf_create();
if(keyname == NULL ){
ccn_charbuf_destroy(&pubid_out);
free(baseuri);
return -1;
}
ccn_name_from_uri(keyname,baseuri);
if ( res < 0 ){
if ( nlsr->debugging )
printf("Bad URI format: %s\n",baseuri);
ccn_charbuf_destroy(&pubid_out);
ccn_charbuf_destroy(&keyname);
free(baseuri);
return -1;
}
ccn_name_append_str(keyname,"nlsr");
struct ccn_charbuf *keyid = ccn_charbuf_create();
ccn_charbuf_append_value(keyid, CCN_MARKER_CONTROL, 1);
ccn_charbuf_append_string(keyid, ".M.K");
ccn_charbuf_append_value(keyid, 0, 1);
ccn_charbuf_append_charbuf(keyid, pubid_out);
ccn_name_append(keyname, keyid->buf, keyid->length);
struct ccn_charbuf *uri = ccn_charbuf_create();
ccn_uri_append(uri, keyname->buf, keyname->length, 0);
if ( nlsr->debugging )
printf("Key Name Included when processing content: %s\n", ccn_charbuf_as_string(uri));
ccn_charbuf_destroy(&uri);
struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT;
sp.type = CCN_CONTENT_DATA;
sp.template_ccnb = ccn_charbuf_create();
ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_SignedInfo, CCN_DTAG);
ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_KeyLocator, CCN_DTAG);
ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_KeyName, CCN_DTAG);
ccn_charbuf_append(sp.template_ccnb, keyname->buf, keyname->length);
ccn_charbuf_append_closer(sp.template_ccnb); // KeyName closer
ccn_charbuf_append_closer(sp.template_ccnb); // KeyLocator closer
ccn_charbuf_append_closer(sp.template_ccnb); // SignedInfo closer
sp.sp_flags |= CCN_SP_TEMPL_KEY_LOCATOR;
sp.sp_flags |= CCN_SP_FINAL_BLOCK;
sp.freshness = 60;
if (pubid_out->length != sizeof(sp.pubid)){
if ( nlsr->debugging )
printf("Size of pubid and sp.pubid is not equal");
ccn_charbuf_destroy(&keyname);
ccn_charbuf_destroy(&pubid_out);
free(baseuri);
return -1;
}
memcpy(sp.pubid, pubid_out->buf, pubid_out->length);
res=ccn_sign_content(nlsr->ccn,resultbuf,content_name,&sp,data,data_size);
if( res < 0 ){
if ( nlsr->debugging )
printf("Content signing error \n");
ccn_charbuf_destroy(&sp.template_ccnb);
ccn_charbuf_destroy(&keyid);
ccn_charbuf_destroy(&keyname);
ccn_charbuf_destroy(&pubid_out);
free(baseuri);
return -1;
}
ccn_charbuf_destroy(&sp.template_ccnb);
ccn_charbuf_destroy(&keyid);
ccn_charbuf_destroy(&keyname);
ccn_charbuf_destroy(&pubid_out);
free(baseuri);
return 0;
}
int
main(int argc, char **argv)
{
const char *progname = argv[0];
struct ccn *ccn = NULL;
struct ccn_charbuf *root = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *temp = NULL;
struct ccn_charbuf *templ = NULL;
struct ccn_charbuf *signed_info = NULL;
struct ccn_charbuf *keylocator = NULL;
struct ccn_charbuf *finalblockid = NULL;
struct ccn_keystore *keystore = NULL;
long expire = -1;
long blocksize = 1024;
int i;
int status = 0;
int res;
ssize_t read_res;
unsigned char *buf = NULL;
struct mydata mydata = { 0 };
struct ccn_closure in_content = {.p=&incoming_content, .data=&mydata};
struct ccn_closure in_interest = {.p=&incoming_interest, .data=&mydata};
while ((res = getopt(argc, argv, "hx:b:")) != -1) {
switch (res) {
case 'x':
expire = atol(optarg);
if (expire <= 0)
usage(progname);
break;
case 'b':
blocksize = atol(optarg);
break;
default:
case 'h':
usage(progname);
break;
}
}
argc -= optind;
argv += optind;
if (argv[0] == NULL)
usage(progname);
name = ccn_charbuf_create();
res = ccn_name_from_uri(name, argv[0]);
if (res < 0) {
fprintf(stderr, "%s: bad ccn URI: %s\n", progname, argv[0]);
exit(1);
}
if (argv[1] != NULL)
fprintf(stderr, "%s warning: extra arguments ignored\n", progname);
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
buf = calloc(1, blocksize);
root = name;
name = ccn_charbuf_create();
temp = ccn_charbuf_create();
templ = ccn_charbuf_create();
signed_info = ccn_charbuf_create();
keystore = ccn_keystore_create();
temp->length = 0;
ccn_charbuf_putf(temp, "%s/.ccnx/.ccnx_keystore", getenv("HOME"));
res = ccn_keystore_init(keystore,
ccn_charbuf_as_string(temp),
"Th1s1sn0t8g00dp8ssw0rd.");
if (res != 0) {
printf("Failed to initialize keystore\n");
exit(1);
}
name->length = 0;
ccn_charbuf_append(name, root->buf, root->length);
/* Set up a handler for interests */
ccn_set_interest_filter(ccn, name, &in_interest);
/* Initiate check to see whether there is already something there. */
temp->length = 0;
ccn_charbuf_putf(temp, "%d", 0);
ccn_name_append(name, temp->buf, temp->length);
templ->length = 0;
ccn_charbuf_append_tt(templ, CCN_DTAG_Interest, CCN_DTAG);
ccn_charbuf_append_tt(templ, CCN_DTAG_Name, CCN_DTAG);
ccn_charbuf_append_closer(templ); /* </Name> */
ccn_charbuf_append_tt(templ, CCN_DTAG_MaxSuffixComponents, CCN_DTAG);
ccn_charbuf_append_tt(templ, 1, CCN_UDATA);
ccn_charbuf_append(templ, "1", 1);
ccn_charbuf_append_closer(templ); /* </MaxSuffixComponents> */
// XXX - use pubid
ccn_charbuf_append_closer(templ); /* </Interest> */
res = ccn_express_interest(ccn, name, &in_content, templ);
if (res < 0) abort();
/* Construct a key locator contining the key itself */
keylocator = ccn_charbuf_create();
ccn_charbuf_append_tt(keylocator, CCN_DTAG_KeyLocator, CCN_DTAG);
ccn_charbuf_append_tt(keylocator, CCN_DTAG_Key, CCN_DTAG);
res = ccn_append_pubkey_blob(keylocator, ccn_keystore_public_key(keystore));
if (res < 0)
ccn_charbuf_destroy(&keylocator);
else {
ccn_charbuf_append_closer(keylocator); /* </Key> */
ccn_charbuf_append_closer(keylocator); /* </KeyLocator> */
}
for (i = 0;; i++) {
read_res = read_full(0, buf, blocksize);
if (read_res < 0) {
perror("read");
read_res = 0;
status = 1;
}
signed_info->length = 0;
if (read_res < blocksize) {
temp->length = 0;
ccn_charbuf_putf(temp, "%d", i);
ccn_name_append(name, temp->buf, temp->length);
finalblockid = ccn_charbuf_create();
ccn_charbuf_append_tt(finalblockid, temp->length, CCN_BLOB);
ccn_charbuf_append(finalblockid, temp->buf, temp->length);
}
res = ccn_signed_info_create(signed_info,
/*pubkeyid*/ccn_keystore_public_key_digest(keystore),
/*publisher_key_id_size*/ccn_keystore_public_key_digest_length(keystore),
/*datetime*/NULL,
/*type*/CCN_CONTENT_DATA,
/*freshness*/ expire,
finalblockid,
keylocator);
/* Put the keylocator in the first block only. */
ccn_charbuf_destroy(&keylocator);
if (res < 0) {
fprintf(stderr, "Failed to create signed_info (res == %d)\n", res);
exit(1);
}
name->length = 0;
ccn_charbuf_append(name, root->buf, root->length);
temp->length = 0;
ccn_charbuf_putf(temp, "%d", i);
ccn_name_append(name, temp->buf, temp->length);
temp->length = 0;
ccn_charbuf_append(temp, buf, read_res);
temp->length = 0;
res = ccn_encode_ContentObject(temp,
name,
signed_info,
buf,
read_res,
NULL,
ccn_keystore_private_key(keystore));
if (res != 0) {
fprintf(stderr, "Failed to encode ContentObject (res == %d)\n", res);
exit(1);
}
if (i == 0) {
/* Finish check for old content */
if (mydata.content_received == 0)
ccn_run(ccn, 100);
if (mydata.content_received > 0) {
fprintf(stderr, "%s: name is in use: %s\n", progname, argv[0]);
exit(1);
}
mydata.outstanding++; /* the first one is free... */
}
res = ccn_put(ccn, temp->buf, temp->length);
if (res < 0) {
fprintf(stderr, "ccn_put failed (res == %d)\n", res);
exit(1);
}
if (read_res < blocksize)
break;
if (mydata.outstanding > 0)
mydata.outstanding--;
else
res = 10;
res = ccn_run(ccn, res * 100);
if (res < 0) {
status = 1;
break;
}
}
free(buf);
buf = NULL;
ccn_charbuf_destroy(&root);
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&temp);
ccn_charbuf_destroy(&signed_info);
ccn_charbuf_destroy(&finalblockid);
ccn_keystore_destroy(&keystore);
ccn_destroy(&ccn);
exit(status);
}
int
main(int argc, char **argv)
{
struct ccn_keystore *keystore = NULL;
int res = 0;
struct ccn_charbuf *signed_info = ccn_charbuf_create();
int i;
int sec, usec;
char msgbuf[PAYLOAD_SIZE];
struct timeval start, end;
struct ccn_charbuf *message = ccn_charbuf_create();
struct ccn_charbuf *path = ccn_charbuf_create();
struct ccn_charbuf *seq = ccn_charbuf_create();
struct ccn_charbuf *temp = ccn_charbuf_create();
keystore = ccn_keystore_create();
ccn_charbuf_putf(temp, "%s/.ccnx/.ccnx_keystore", getenv("HOME"));
res = ccn_keystore_init(keystore,
ccn_charbuf_as_string(temp),
"Th1s1sn0t8g00dp8ssw0rd.");
if (res != 0) {
printf("Failed to initialize keystore %s\n", ccn_charbuf_as_string(temp));
exit(1);
}
ccn_charbuf_destroy(&temp);
res = ccn_signed_info_create(signed_info,
/* pubkeyid */ ccn_keystore_public_key_digest(keystore),
/* publisher_key_id_size */ ccn_keystore_public_key_digest_length(keystore),
/* datetime */ NULL,
/* type */ CCN_CONTENT_DATA,
/* freshness */ FRESHNESS,
/*finalblockid*/ NULL,
/* keylocator */ NULL);
srandom(time(NULL));
for (i=0; i<PAYLOAD_SIZE; i++) {
msgbuf[i] = random();
}
printf("Generating %d signed ContentObjects (one . per 100)\n", COUNT);
gettimeofday(&start, NULL);
for (i=0; i<COUNT; i++) {
if (i>0 && (i%100) == 0) {
printf(".");
fflush(stdout);
}
ccn_name_init(path);
ccn_name_append_str(path, "rtp");
ccn_name_append_str(path, "protocol");
ccn_name_append_str(path, "13.2.117.34");
ccn_name_append_str(path, "domain");
ccn_name_append_str(path, "smetters");
ccn_name_append_str(path, "principal");
ccn_name_append_str(path, "2021915340");
ccn_name_append_str(path, "id");
ccn_charbuf_putf(seq, "%u", i);
ccn_name_append(path, seq->buf, seq->length);
ccn_name_append_str(path, "seq");
res = ccn_encode_ContentObject(/* out */ message,
path, signed_info,
msgbuf, PAYLOAD_SIZE,
/* digest_algorithm */ NULL,
ccn_keystore_private_key(keystore));
ccn_charbuf_reset(message);
ccn_charbuf_reset(path);
ccn_charbuf_reset(seq);
}
gettimeofday(&end, NULL);
sec = end.tv_sec - start.tv_sec;
usec = (int)end.tv_usec - (int)start.tv_usec;
while (usec < 0) {
sec--;
usec += 1000000;
}
printf("\nComplete in %d.%06d secs\n", sec, usec);
return(0);
}
// creates a full structure without action, if proto == "face" only the
// faceid (from cmd_host parameter) and lifetime will be filled in.
struct ccn_face_instance *
parse_ccn_face_instance(struct ccndc_data *self,
const char *cmd_proto,
const char *cmd_host, const char *cmd_port,
const char *cmd_mcastttl, const char *cmd_mcastif,
int freshness)
{
struct ccn_face_instance *entry;
struct addrinfo hints = {.ai_family = AF_UNSPEC, .ai_flags = (AI_ADDRCONFIG)};
struct addrinfo mcasthints = {.ai_family = AF_UNSPEC, .ai_flags = (AI_ADDRCONFIG | AI_NUMERICHOST)};
struct addrinfo *raddrinfo = NULL;
struct addrinfo *mcastifaddrinfo = NULL;
char rhostnamebuf [NI_MAXHOST];
char rhostportbuf [NI_MAXSERV];
int off_address = -1, off_port = -1, off_source_address = -1;
int res;
int socktype;
entry = calloc(1, sizeof(*entry));
if (entry == NULL) {
ccndc_warn(__LINE__, "Fatal error: memory allocation failed");
goto ExitOnError;
}
// allocate storage for Face data
entry->store = ccn_charbuf_create();
if (entry->store == NULL) {
ccndc_warn(__LINE__, "Fatal error: memory allocation failed");
goto ExitOnError;
}
// copy static info
entry->ccnd_id = (const unsigned char *)self->ccnd_id;
entry->ccnd_id_size = self->ccnd_id_size;
if (cmd_proto == NULL) {
ccndc_warn(__LINE__, "command error, missing address type\n");
goto ExitOnError;
}
if (strcasecmp(cmd_proto, "udp") == 0) {
entry->descr.ipproto = IPPROTO_UDP;
socktype = SOCK_DGRAM;
} else if (strcasecmp(cmd_proto, "tcp") == 0) {
entry->descr.ipproto = IPPROTO_TCP;
socktype = SOCK_STREAM;
} else if (strcasecmp(cmd_proto, "face") == 0) {
errno = 0;
unsigned long faceid = strtoul(cmd_host, (char **)NULL, 10);
if (errno == ERANGE || errno == EINVAL || faceid > UINT_MAX || faceid == 0) {
ccndc_warn(__LINE__, "command error, face number invalid or out of range '%s'\n", cmd_host);
goto ExitOnError;
}
entry->faceid = (unsigned) faceid;
entry->lifetime = freshness;
return (entry);
} else {
ccndc_warn(__LINE__, "command error, unrecognized address type '%s'\n", cmd_proto);
goto ExitOnError;
}
if (cmd_host == NULL) {
ccndc_warn(__LINE__, "command error, missing hostname\n");
goto ExitOnError;
}
if (cmd_port == NULL || cmd_port[0] == 0)
cmd_port = CCN_DEFAULT_UNICAST_PORT;
hints.ai_socktype = socktype;
res = getaddrinfo(cmd_host, cmd_port, &hints, &raddrinfo);
if (res != 0 || raddrinfo == NULL) {
ccndc_warn(__LINE__, "command error, getaddrinfo for host [%s] port [%s]: %s\n", cmd_host, cmd_port, gai_strerror(res));
goto ExitOnError;
}
res = getnameinfo(raddrinfo->ai_addr, raddrinfo->ai_addrlen,
rhostnamebuf, sizeof(rhostnamebuf),
rhostportbuf, sizeof(rhostportbuf),
NI_NUMERICHOST | NI_NUMERICSERV);
freeaddrinfo(raddrinfo);
if (res != 0) {
ccndc_warn(__LINE__, "command error, getnameinfo: %s\n", gai_strerror(res));
goto ExitOnError;
}
off_address = entry->store->length;
res = ccn_charbuf_append(entry->store, rhostnamebuf, strlen(rhostnamebuf)+1);
if (res != 0) {
ccndc_warn(__LINE__, "Cannot append to charbuf");
goto ExitOnError;
}
off_port = entry->store->length;
res = ccn_charbuf_append(entry->store, rhostportbuf, strlen(rhostportbuf)+1);
if (res != 0) {
ccndc_warn(__LINE__, "Cannot append to charbuf");
goto ExitOnError;
}
entry->descr.mcast_ttl = -1;
if (cmd_mcastttl != NULL) {
char *endptr;
entry->descr.mcast_ttl = strtol(cmd_mcastttl, &endptr, 10);
if ((endptr != &cmd_mcastttl[strlen(cmd_mcastttl)]) ||
entry->descr.mcast_ttl < 0 || entry->descr.mcast_ttl > 255) {
ccndc_warn(__LINE__, "command error, invalid multicast ttl: %s\n", cmd_mcastttl);
goto ExitOnError;
}
}
if (cmd_mcastif != NULL) {
res = getaddrinfo(cmd_mcastif, NULL, &mcasthints, &mcastifaddrinfo);
if (res != 0) {
ccndc_warn(__LINE__, "command error, incorrect multicat interface [%s]: "
"mcastifaddr getaddrinfo: %s\n", cmd_mcastif, gai_strerror(res));
goto ExitOnError;
}
res = getnameinfo(mcastifaddrinfo->ai_addr, mcastifaddrinfo->ai_addrlen,
rhostnamebuf, sizeof(rhostnamebuf),
NULL, 0,
NI_NUMERICHOST | NI_NUMERICSERV);
freeaddrinfo(mcastifaddrinfo);
if (res != 0) {
ccndc_warn(__LINE__, "command error, getnameinfo: %s\n", gai_strerror(res));
goto ExitOnError;
}
off_source_address = entry->store->length;
res = ccn_charbuf_append(entry->store, rhostnamebuf, strlen(rhostnamebuf)+1);
if (res != 0) {
ccndc_warn(__LINE__, "Cannot append to charbuf");
goto ExitOnError;
}
}
entry->descr.address = (const char *)(entry->store->buf + off_address);
entry->descr.port = (const char *)(entry->store->buf + off_port);
if (off_source_address >= 0) {
entry->descr.source_address = (const char *)(entry->store->buf + off_source_address);
}
entry->lifetime = freshness;
return entry;
ExitOnError:
ccn_face_instance_destroy(&entry);
return (NULL);
}
struct ccn_face_instance *
parse_ccn_face_instance_from_face(struct ccndc_data *self,
const char *cmd_faceid)
{
struct ccn_face_instance *entry = calloc(1, sizeof(*entry));
// allocate storage for Face data
entry->store = ccn_charbuf_create();
// copy static info
entry->ccnd_id = (const unsigned char *)self->ccnd_id;
entry->ccnd_id_size = self->ccnd_id_size;
/* destroy a face - the URI field will hold the face number */
if (cmd_faceid == NULL) {
ccndc_warn(__LINE__, "command error, missing face number for destroyface\n");
goto ExitOnError;
}
char *endptr;
int facenumber = strtol(cmd_faceid, &endptr, 10);
if ((endptr != &cmd_faceid[strlen(cmd_faceid)]) ||
facenumber < 0) {
ccndc_warn(__LINE__, "command error invalid face number for destroyface: %d\n", facenumber);
goto ExitOnError;
}
entry->faceid = facenumber;
return entry;
ExitOnError:
ccn_face_instance_destroy(&entry);
return (NULL);
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// "private section
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
int
ccndc_get_ccnd_id(struct ccndc_data *self)
{
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *resultbuf = NULL;
struct ccn_parsed_ContentObject pcobuf = {0};
char ccndid_uri[] = "ccnx:/%C1.M.S.localhost/%C1.M.SRV/ccnd/KEY";
const unsigned char *ccndid_result;
int res = 0;
name = ccn_charbuf_create();
if (name == NULL) {
ccndc_warn(__LINE__, "Unable to allocate storage for service locator name charbuf\n");
return -1;
}
resultbuf = ccn_charbuf_create();
if (resultbuf == NULL) {
ccndc_warn(__LINE__, "Unable to allocate storage for result charbuf");
res = -1;
goto Cleanup;
}
res = ccn_name_from_uri(name, ccndid_uri);
if (res < 0) {
ccndc_warn(__LINE__, "Unable to parse service locator URI for ccnd key");
goto Cleanup;
}
res = ccn_get(self->ccn_handle,
name,
self->local_scope_template,
4500, resultbuf, &pcobuf, NULL, 0);
if (res < 0) {
ccndc_warn(__LINE__, "Unable to get key from ccnd");
goto Cleanup;
}
res = ccn_ref_tagged_BLOB (CCN_DTAG_PublisherPublicKeyDigest,
resultbuf->buf,
pcobuf.offset[CCN_PCO_B_PublisherPublicKeyDigest],
pcobuf.offset[CCN_PCO_E_PublisherPublicKeyDigest],
&ccndid_result, &self->ccnd_id_size);
if (res < 0) {
ccndc_warn(__LINE__, "Unable to parse ccnd response for ccnd id");
goto Cleanup;
}
if (self->ccnd_id_size > sizeof (self->ccnd_id))
{
ccndc_warn(__LINE__, "Incorrect size for ccnd id in response");
goto Cleanup;
}
memcpy(self->ccnd_id, ccndid_result, self->ccnd_id_size);
Cleanup:
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&resultbuf);
return (res);
}
struct ccn_face_instance *
ccndc_do_face_action(struct ccndc_data *self,
const char *action,
struct ccn_face_instance *face_instance)
{
struct ccn_charbuf *newface = NULL;
struct ccn_charbuf *signed_info = NULL;
struct ccn_charbuf *temp = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *resultbuf = NULL;
struct ccn_parsed_ContentObject pcobuf = {0};
struct ccn_face_instance *new_face_instance = NULL;
const unsigned char *ptr = NULL;
size_t length = 0;
int res = 0;
face_instance->action = action;
/* Encode the given face instance */
newface = ccn_charbuf_create();
ON_NULL_CLEANUP(newface);
ON_ERROR_CLEANUP(ccnb_append_face_instance(newface, face_instance));
temp = ccn_charbuf_create();
ON_NULL_CLEANUP(temp);
res = ccn_sign_content(self->ccn_handle, temp, self->no_name, NULL, newface->buf, newface->length);
ON_ERROR_CLEANUP(res);
resultbuf = ccn_charbuf_create();
ON_NULL_CLEANUP(resultbuf);
/* Construct the Interest name that will create the face */
name = ccn_charbuf_create();
ON_NULL_CLEANUP(name);
ON_ERROR_CLEANUP(ccn_name_init(name));
ON_ERROR_CLEANUP(ccn_name_append_str(name, "ccnx"));
ON_ERROR_CLEANUP(ccn_name_append(name, face_instance->ccnd_id, face_instance->ccnd_id_size));
ON_ERROR_CLEANUP(ccn_name_append_str(name, face_instance->action));
ON_ERROR_CLEANUP(ccn_name_append(name, temp->buf, temp->length));
res = ccn_get(self->ccn_handle, name, self->local_scope_template, 1000, resultbuf, &pcobuf, NULL, 0);
ON_ERROR_CLEANUP(res);
ON_ERROR_CLEANUP(ccn_content_get_value(resultbuf->buf, resultbuf->length, &pcobuf, &ptr, &length));
new_face_instance = ccn_face_instance_parse(ptr, length);
ON_NULL_CLEANUP(new_face_instance);
ccn_charbuf_destroy(&newface);
ccn_charbuf_destroy(&signed_info);
ccn_charbuf_destroy(&temp);
ccn_charbuf_destroy(&resultbuf);
ccn_charbuf_destroy(&name);
return (new_face_instance);
Cleanup:
ccn_charbuf_destroy(&newface);
ccn_charbuf_destroy(&signed_info);
ccn_charbuf_destroy(&temp);
ccn_charbuf_destroy(&resultbuf);
ccn_charbuf_destroy(&name);
ccn_face_instance_destroy(&new_face_instance);
return (NULL);
}
int
ccndc_do_prefix_action(struct ccndc_data *self,
const char *action,
struct ccn_forwarding_entry *forwarding_entry)
{
struct ccn_charbuf *temp = NULL;
struct ccn_charbuf *resultbuf = NULL;
struct ccn_charbuf *signed_info = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *prefixreg = NULL;
struct ccn_parsed_ContentObject pcobuf = {0};
struct ccn_forwarding_entry *new_forwarding_entry = NULL;
const unsigned char *ptr = NULL;
size_t length = 0;
int res;
forwarding_entry->action = action;
prefixreg = ccn_charbuf_create();
ON_NULL_CLEANUP(prefixreg);
ON_ERROR_CLEANUP(ccnb_append_forwarding_entry(prefixreg, forwarding_entry));
temp = ccn_charbuf_create();
ON_NULL_CLEANUP(temp);
res = ccn_sign_content(self->ccn_handle, temp, self->no_name, NULL, prefixreg->buf, prefixreg->length);
ON_ERROR_CLEANUP(res);
resultbuf = ccn_charbuf_create();
ON_NULL_CLEANUP(resultbuf);
name = ccn_charbuf_create();
ON_ERROR_CLEANUP(ccn_name_init(name));
ON_ERROR_CLEANUP(ccn_name_append_str(name, "ccnx"));
ON_ERROR_CLEANUP(ccn_name_append(name, forwarding_entry->ccnd_id, forwarding_entry->ccnd_id_size));
ON_ERROR_CLEANUP(ccn_name_append_str(name, forwarding_entry->action));
ON_ERROR_CLEANUP(ccn_name_append(name, temp->buf, temp->length));
res = ccn_get(self->ccn_handle, name, self->local_scope_template, 1000, resultbuf, &pcobuf, NULL, 0);
ON_ERROR_CLEANUP(res);
ON_ERROR_CLEANUP(ccn_content_get_value(resultbuf->buf, resultbuf->length, &pcobuf, &ptr, &length));
new_forwarding_entry = ccn_forwarding_entry_parse(ptr, length);
ON_NULL_CLEANUP(new_forwarding_entry);
res = new_forwarding_entry->faceid;
ccn_forwarding_entry_destroy(&new_forwarding_entry);
ccn_charbuf_destroy(&signed_info);
ccn_charbuf_destroy(&temp);
ccn_charbuf_destroy(&resultbuf);
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&prefixreg);
return (res);
/* This is where ON_ERROR_CLEANUP sends us in case of an error
* and we must free any storage we allocated before returning.
*/
Cleanup:
ccn_charbuf_destroy(&signed_info);
ccn_charbuf_destroy(&temp);
ccn_charbuf_destroy(&resultbuf);
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&prefixreg);
return (-1);
}
static void
ask_set(struct mydata *md, char ** urlList, int flying){
if(DEBUG)
printf("In function askset \n ");
struct ccn_charbuf * name = NULL;
struct ccn_charbuf * templ = NULL;
int i = 0;
int res = -1;
struct ccn_closure * cl = NULL;
/* TODO: Zipf Distribution
//Test the Zipf distribution
printf("Zipf starts \n");
for(i = 1; i < 100000; i++){
printf("%d \n", zipf(5, 100, i));
}
printf("Zipfs ends\n");
*/
int r = 0;
for(r = 0; r < 1; r++){
for(i = 0; i < flying; i++){
cl = &(md->ooo[i].closure);
name = ccn_charbuf_create();
printf("url = %s \n", urlList[i]);
printf("===\n");
res = ccn_name_from_uri(name, urlList[i]);
if(res < 0){
printf("ccn_name_from_uri failed \n");
abort();
}
ccn_name_append(name, "0", 1);
templ = make_template(md);
if(DEBUG){
//Print out the interest's name
printf("Sending Interest : ");
int myres = 0;
struct ccn_indexbuf* ndx = ccn_indexbuf_create();
unsigned char* mycomp = NULL;
size_t mysize = 0;
ndx->n = 0;
myres = ccn_name_split(name, ndx);
if(myres < 0){
fprintf(stderr, "ccn_name_split @ ccntraffic. failed");
}
int it = 0;
for(it = 0; it < ndx->n-1; it++){
mysize = 0;
myres = ccn_name_comp_get(name->buf, ndx, it, &mycomp, &mysize);
printf("%s/", mycomp);
mycomp = NULL;
}
printf("\n");
}
res = ccn_express_interest(md->h, name, cl, templ);
if(res < 0) abort();
ccn_charbuf_destroy(&name);
}
}
printf("Sent!\n");
}
enum ccn_upcall_res
incoming_content(
struct ccn_closure *selfp,
enum ccn_upcall_kind kind,
struct ccn_upcall_info *info)
{
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *templ = NULL;
struct ccn_charbuf *temp = NULL;
const unsigned char *ccnb = NULL;
size_t ccnb_size = 0;
const unsigned char *data = NULL;
size_t data_size = 0;
// TANG: no need to write data to stdout
//size_t written;
const unsigned char *ib = NULL; /* info->interest_ccnb */
struct ccn_indexbuf *ic = NULL;
int res;
struct mydata *md = selfp->data;
if (kind == CCN_UPCALL_FINAL) {
if (md != NULL) {
selfp->data = NULL;
free(md);
md = NULL;
}
return(CCN_UPCALL_RESULT_OK);
}
if (kind == CCN_UPCALL_INTEREST_TIMED_OUT)
return(CCN_UPCALL_RESULT_REEXPRESS);
if (kind != CCN_UPCALL_CONTENT && kind != CCN_UPCALL_CONTENT_UNVERIFIED)
return(CCN_UPCALL_RESULT_ERR);
if (md == NULL)
selfp->data = md = calloc(1, sizeof(*md));
ccnb = info->content_ccnb;
ccnb_size = info->pco->offset[CCN_PCO_E];
ib = info->interest_ccnb;
ic = info->interest_comps;
/* XXX - must verify sig, and make sure it is LEAF content */
res = ccn_content_get_value(ccnb, ccnb_size, info->pco, &data, &data_size);
if (res < 0) abort();
if (data_size > CHUNK_SIZE) {
/* For us this is spam. Give up now. */
fprintf(stderr, "*** Segment %d found with a data size of %d."
" This program only works with segments of 1024 bytes."
" Try ccncatchunks2 instead.\n",
(int)selfp->intdata, (int)data_size);
exit(1);
}
/* OK, we will accept this block. */
//sleep(1);
// TANG: No need to write data to stdout, skip 3 lines
//written = fwrite(data, data_size, 1, stdout);
//if (written != 1)
// exit(1);
/* A short block signals EOF for us. */
// TANG: to support data_size smaller than 1024, skip 2 lines
//if (data_size < CHUNK_SIZE)
// exit(0);
/* Ask for the next one */
name = ccn_charbuf_create();
ccn_name_init(name);
if (ic->n < 2) abort();
res = ccn_name_append_components(name, ib, ic->buf[0], ic->buf[ic->n - 2]);
if (res < 0) abort();
temp = ccn_charbuf_create();
//printf("intdata = %d \n ", selfp->intdata);
ccn_charbuf_putf(temp, "%d", ++(selfp->intdata));
ccn_name_append(name, temp->buf, temp->length);
ccn_charbuf_destroy(&temp);
if(DEBUG){
//Print out the interest's name
printf("Interest name = ");
int myres = 0;
struct ccn_indexbuf* ndx = ccn_indexbuf_create();
unsigned char* mycomp = NULL;
size_t mysize = 0;
ndx->n = 0;
myres = ccn_name_split(name, ndx);
if(myres < 0){
fprintf(stderr, "ccn_name_split @ ccntraffic. failed");
}
int it = 0;
for(it = 0; it < ndx->n-1; it++){
mysize = 0;
myres = ccn_name_comp_get(name->buf, ndx, it, &mycomp, &mysize);
printf("%s/", mycomp);
mycomp = NULL;
}
printf("\n");
}
templ = make_template(md);
res = ccn_express_interest(info->h, name, selfp, templ);
if (res < 0) abort();
ccn_charbuf_destroy(&templ);
ccn_charbuf_destroy(&name);
return(CCN_UPCALL_RESULT_OK);
}
enum ccn_upcall_res
incoming_content(
struct ccn_closure *selfp,
enum ccn_upcall_kind kind,
struct ccn_upcall_info *info)
{
struct ccn_charbuf *c = NULL;
struct ccn_charbuf *comp = NULL;
struct ccn_charbuf *uri = NULL;
struct ccn_charbuf *templ = NULL;
const unsigned char *ccnb = NULL;
size_t ccnb_size = 0;
struct ccn_indexbuf *comps = NULL;
int matched_comps = 0;
int res;
int i;
struct upcalldata *data = selfp->data;
if (data->magic != 856372) abort();
if (kind == CCN_UPCALL_FINAL)
return(CCN_UPCALL_RESULT_OK);
if (kind == CCN_UPCALL_INTEREST_TIMED_OUT)
return(CCN_UPCALL_RESULT_REEXPRESS);
if (kind == CCN_UPCALL_CONTENT_UNVERIFIED) {
if ((data->option & MUST_VERIFY) != 0)
return(CCN_UPCALL_RESULT_VERIFY);
}
else if (kind != CCN_UPCALL_CONTENT) abort();
ccnb = info->content_ccnb;
ccnb_size = info->pco->offset[CCN_PCO_E];
comps = info->content_comps;
matched_comps = info->pi->prefix_comps;
c = ccn_charbuf_create();
uri = ccn_charbuf_create();
templ = ccn_charbuf_create();
/* note that comps->n is 1 greater than the number of explicit components */
if (matched_comps > comps->n) {
ccn_uri_append(c, ccnb, ccnb_size, 1);
fprintf(stderr, "How did this happen? %s\n", ccn_charbuf_as_string(uri));
exit(1);
}
data->counter[0]++;
/* Recover the same prefix as before */
ccn_name_init(c);
res = ccn_name_append_components(c, info->interest_ccnb,
info->interest_comps->buf[0],
info->interest_comps->buf[matched_comps]);
if (res < 0) abort();
comp = ccn_charbuf_create();
ccn_name_init(comp);
if (matched_comps + 1 == comps->n) {
/* Reconstruct the implicit ContentObject digest component */
ccn_digest_ContentObject(ccnb, info->pco);
ccn_name_append(comp, info->pco->digest, info->pco->digest_bytes);
}
else if (matched_comps < comps->n) {
ccn_name_append_components(comp, ccnb,
comps->buf[matched_comps],
comps->buf[matched_comps + 1]);
}
res = ccn_uri_append(uri, comp->buf, comp->length, 0);
if (res < 0 || uri->length < 1)
fprintf(stderr, "*** Error: ccnls line %d res=%d\n", __LINE__, res);
else {
if (uri->length == 1)
ccn_charbuf_append(uri, ".", 1);
printf("%s%s\n", ccn_charbuf_as_string(uri) + 1,
kind == CCN_UPCALL_CONTENT ? " [verified]" : " [unverified]");
}
ccn_charbuf_append_tt(templ, CCN_DTAG_Interest, CCN_DTAG);
ccn_charbuf_append(templ, c->buf, c->length); /* Name */
if (matched_comps == comps->n) {
/* The interest supplied the digest component */
ccn_charbuf_destroy(&comp);
/*
* We can't rely on the Exclude filter to keep from seeing this, so
* say that we need at least one more name component.
*/
ccn_charbuf_append_tt(templ, CCN_DTAG_MinSuffixComponents, CCN_DTAG);
ccn_charbuf_append_tt(templ, 1, CCN_UDATA);
ccn_charbuf_append(templ, "1", 1);
ccn_charbuf_append_closer(templ); /* </MinSuffixComponents> */
}
else {
data->excl = realloc(data->excl, (data->n_excl + 1) * sizeof(data->excl[0]));
data->excl[data->n_excl++] = comp;
comp = NULL;
}
qsort(data->excl, data->n_excl, sizeof(data->excl[0]), &namecompare);
ccn_charbuf_append_tt(templ, CCN_DTAG_Exclude, CCN_DTAG);
for (i = 0; i < data->n_excl; i++) {
comp = data->excl[i];
if (comp->length < 4) abort();
ccn_charbuf_append(templ, comp->buf + 1, comp->length - 2);
}
comp = NULL;
ccn_charbuf_append_closer(templ); /* </Exclude> */
ccnb_tagged_putf(templ, CCN_DTAG_AnswerOriginKind, "%d", CCN_AOK_CS);
if (data->scope > -1)
ccnb_tagged_putf(templ, CCN_DTAG_Scope, "%d", data->scope);
ccn_charbuf_append_closer(templ); /* </Interest> */
if (templ->length > data->warn) {
fprintf(stderr, "*** Interest packet is %d bytes\n", (int)templ->length);
data->warn = data->warn * 8 / 5;
}
ccn_express_interest(info->h, c, selfp, templ);
ccn_charbuf_destroy(&templ);
ccn_charbuf_destroy(&c);
ccn_charbuf_destroy(&uri);
return(CCN_UPCALL_RESULT_OK);
}
