int
main(int argc, char **argv)
{
struct ccn *ccn = NULL;
struct ccn_charbuf *name = NULL;
int opt;
int res;
while ((opt = getopt(argc, argv, "h")) != -1) {
switch (opt) {
case 'h':
default:
usage(argv[0]);
}
}
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
name = ccn_charbuf_create();
res = ccn_guest_prefix(ccn, name, 500);
if (res < 0)
exit(1);
printf("%s\n", ccn_charbuf_as_string(name));
exit(0);
}
int main()
{
struct ccn *ccn = NULL;
struct ccn_charbuf *name = NULL;
int res;
struct ccn_closure *incoming = NULL;
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1)
{
perror("Could not connect to ccnd");
exit(1);
}
incoming = calloc(1, sizeof(*incoming));
incoming->p = &incoming_content;
name = ccn_charbuf_create();
res = ccn_name_from_uri(name, "ccnx:/FOX/test");
//ccn_express_persistent_interest(ccn, name, incoming, NULL, 1);
ccn_express_interest(ccn, name, incoming, NULL);
printf("Interests send\n", res);
res = ccn_run(ccn, 10000);
return 0;
}
struct ccndc_data *
ccndc_initialize_data(void) {
struct ccndc_data *self;
const char *msg = "Unable to initialize ccndc";
int res;
self = calloc(1, sizeof(*self));
if (self == NULL) {
ON_ERROR_EXIT (-1, msg);
}
self->ccn_handle = ccn_create();
ON_ERROR_EXIT(ccn_connect(self->ccn_handle, NULL), "Unable to connect to local ccnd");
ON_ERROR_EXIT(ccndc_get_ccnd_id(self), "Unable to obtain ID of local ccnd");
/* Set up an Interest template to indicate scope 1 (Local) */
self->local_scope_template = ccn_charbuf_create();
res = ccnb_element_begin(self->local_scope_template, CCN_DTAG_Interest);
res |= ccnb_element_begin(self->local_scope_template, CCN_DTAG_Name);
res |= ccnb_element_end(self->local_scope_template); /* </Name> */
res |= ccnb_tagged_putf(self->local_scope_template, CCN_DTAG_Scope, "1");
res |= ccnb_element_end(self->local_scope_template); /* </Interest> */
ON_ERROR_EXIT(res, msg);
/* Create a null name */
self->no_name = ccn_charbuf_create();
ON_ERROR_EXIT(ccn_name_init(self->no_name), msg);
self->lifetime = (~0U) >> 1;
return self;
}
void CcnLAC_initialize(CcnLAC self, CCNDID ccndid, PollMgr pm) {
int res = ccn_connect(self->ccnh, NULL);
if (res == -1) {
self->error = true;
return;
}
self->nbs = NBS_ctor(res, res, false);
self->ccnbor = CcnbOR_ctor(self->nbs);
self->pm = pm;
PollMgr_attach(pm, res, &CcnLAC_initPollCb, self);
CcnLAC_fetchFaceid(self, ccndid);
}
/**
* Base loop for the background CCN task
*
* This is the main execution loop for the background task responsible for
* interacting with the CCN network. It is from this point that many of the above methods are
* called to work the inbound messages from ccnx as well as sending out the data messages.
*
* \param data the task context information setup by the parent sink element thread
*/
static void
ccn_event_thread (void *data)
{
Gstccnxsink *me = (Gstccnxsink *) data;
struct ccn_charbuf *filtName;
struct ccn_charbuf *temp;
int res = 0;
GST_DEBUG ("CCNxSink event: *** event thread starting");
temp = ccn_charbuf_create ();
filtName = ccn_charbuf_create ();
/* A closure is what defines what to do when an inbound interest arrives */
if ((me->ccn_closure = calloc (1, sizeof (struct ccn_closure))) == NULL) {
GST_ELEMENT_ERROR (me, RESOURCE, READ, (NULL), ("closure alloc failed"));
return;
}
/* We setup the closure to contain the sink element context reference, and also tell it what function to call */
me->ccn_closure->data = me;
me->ccn_closure->p = new_interests;
me->timeouts = 0;
ccn_charbuf_append (filtName, me->name->buf, me->name->length);
/* This call will set up a handler for interests we expect to get from clients */
// hDump(DUMP_ADDR(filtName->buf), DUMP_SIZE(filtName->length));
ccn_set_interest_filter (me->ccn, filtName, me->ccn_closure);
GST_DEBUG ("CCNxSink event: interest filter registered\n");
/* Some debugging information */
temp->length = 0;
ccn_uri_append (temp, me->name->buf, me->name->length, TRUE);
GST_DEBUG ("CCNxSink event: using uri: %s\n", ccn_charbuf_as_string (temp));
/* Now that the interest is registered, we loop around waiting for something to do */
/* We pass control to ccnx for a while so it can work with any incoming or outgoing data */
/* and then we check our fifo queue for work to do. That's about it! */
/* We check to see if any problems have caused our ccnd connection to fail, and we reconnect */
while (res >= 0) {
GST_DEBUG ("CCNxSink event: *** looping");
res = ccn_run (me->ccn, 50);
check_fifo (me);
if (res < 0 && ccn_get_connection_fd (me->ccn) == -1) {
GST_DEBUG ("CCNxSink event: need to reconnect...");
/* Try reconnecting, after a bit of delay */
msleep ((30 + (getpid () % 30)) * 1000);
res = ccn_connect (me->ccn, ccndHost ());
}
}
GST_DEBUG ("CCNxSink event: *** event thread ending");
}
/**
* Initiates a stream to download data
*
* @param id identifier of the ccn stream
* @param pname name of the object to download
* @param pipeline number of parallel requisitions for chunks
*/
bool CCNGet::initStream(string id, string pname, 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;
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;
}
int
main(int argc, char *argv[])
{
int res;
struct ccn *ccn = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_closure *incoming;
if (argc != 2)
usage(argv[0]);
name = ccn_charbuf_create();
res = ccn_name_from_uri(name, argv[1]);
if (res < 0) {
fprintf(stderr, "invalid ccn URI: %s\n", argv[1]);
usage(argv[0]);
}
ccn = ccn_create();
res = ccn_connect(ccn, NULL);
if (res < 0) {
fprintf(stderr, "can't connect to ccn: %d\n", res);
ccn_perror(ccn, "ccn_connect");
exit(1);
}
incoming = calloc(1, sizeof(*incoming));
incoming->p = incoming_handler;
g_working = true;
gettimeofday(&g_start, NULL);
res = ccn_express_interest(ccn, name, incoming, NULL);
while (g_working && res >= 0)
res = ccn_run(ccn, 100);
free(incoming);
if (res < 0) {
ccn_perror(ccn, "ccn_run");
exit(1);
}
ccn_charbuf_destroy(&name);
ccn_destroy(&ccn);
return 0;
}
/**
* Creates a new ccn_fetch object using the given ccn connection.
* If h == NULL, attempts to create a new connection automatically.
* @returns NULL if the creation was not successful
* (only can happen for the h == NULL case).
*/
extern struct ccn_fetch *
ccn_fetch_new(struct ccn *h) {
struct ccn_fetch *f = calloc(1, sizeof(*f));
if (h == NULL) {
h = ccn_create();
int connRes = ccn_connect(h, NULL);
if (connRes < 0) {
ccn_destroy(&h);
free(f);
return NULL;
}
f->localConnect = 1;
}
f->h = h;
return f;
}
/**
* 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;
}
int NdnMediaProcess::startThread() {
struct ccn *h;
/* Shut down any lingering session */
while (ndnState.ccn != NULL) {
ndnState.active = 0;
printf("waiting for old session to die\n");
}
h = ccn_create();
if (ccn_connect(h, NULL) == -1) {
ccn_perror(h, "Failed to contact ccnd");
ccn_destroy(&h);
return (-1);
}
pthread_mutexattr_init(&ccn_attr);
pthread_mutexattr_settype(&ccn_attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&ccn_mutex, &ccn_attr);
ndnState.ccn = h;
pfds[0].fd = ccn_get_connection_fd(ndnState.ccn);
pfds[0].events = POLLIN;
clock = new QTimer(this);
connect(clock, SIGNAL(timeout()), this, SLOT(tick()));
clock->start(PER_PACKET_LEN);
if (! isRunning()) {
fprintf(stderr, "Starting voice thread in media_pro\n");
ndnState.active = true;
start(QThread::HighestPriority);
#ifdef Q_OS_LINUX
int policy;
struct sched_param param;
if (pthread_getschedparam(pthread_self(), &policy, ¶m) == 0) {
if (policy == SCHED_OTHER) {
policy = SCHED_FIFO;
param.sched_priority = 1;
pthread_setschedparam(pthread_self(), policy, ¶m);
}
}
#endif
}
else
fprintf(stderr, "what the hell\n");
return 0;
}
/**
* Set up a connection with the ccnd router
*
* During this setup we establish a basic connection with the router service
* over an IP connection.
* This is also a good time to setup the ccn name for the content we will
* produce; that is the prefix name and the timestamp [Tnow], since the
* segment portion of the name is added just as the packet is being sent.
*
* Lastly we also load our security keys and create our signing parameters.
*
* \param me context sink element for which the socket is for
*/
static void
setup_ccn (Gstccnxsink * me)
{
struct ccn *ccn;
GST_DEBUG ("CCNxSink: setup name...");
if ((me->name = ccn_charbuf_create ()) == NULL) {
GST_ELEMENT_ERROR (me, RESOURCE, READ, (NULL), ("name alloc failed"));
return;
}
if (ccn_name_from_uri (me->name, me->uri) < 0) {
GST_ELEMENT_ERROR (me, RESOURCE, READ, (NULL), ("name from uri failed"));
return;
}
GST_DEBUG ("CCNxSink: creating ccn object");
if ((ccn = ccn_create ()) == NULL) {
GST_ELEMENT_ERROR (me, RESOURCE, READ, (NULL), ("ccn_create failed"));
return;
}
me->ccn = ccn;
GST_DEBUG ("CCNxSink: connecting");
if (-1 == ccn_connect (me->ccn, ccndHost ())) {
GST_ELEMENT_ERROR (me, RESOURCE, READ, (NULL), ("ccn_connect failed to %s",
ccndHost ()));
return;
}
GST_DEBUG ("CCNxSink: setting name version");
if (0 > ccn_create_version (ccn, me->name,
CCN_V_REPLACE | CCN_V_NOW | CCN_V_HIGH, 0, 0)) {
GST_ELEMENT_ERROR (me, RESOURCE, READ, (NULL),
("ccn_create_version() failed"));
return;
}
GST_DEBUG ("CCNxSink: setting up keystore");
/*
me->keystore = fetchStore();
if( me->keystore ) me->keylocator = makeLocator( ccn_keystore_public_key(me->keystore) );
*/
loadKey (me->ccn, &me->sp);
GST_DEBUG ("CCNxSink: done; have keys!");
}
CcnCC CcnCC_ctor(void) {
CcnCC self = ALLOCSELF;
self->ccnh = ccn_create();
int res = ccn_connect(self->ccnh, NULL);
if (res == -1) {
self->error = true;
CcnCC_dtor(self);
return NULL;
}
self->ccndid = self->ccndid_storage;
CcnCC_fetchCcndid(self);
if (self->error) {
CcnCC_dtor(self);
return NULL;
}
return self;
}
/**
* Base loop for the background CCN task
*
* This is the main execution loop for the background task responsible for
* interacting with the CCN network. It is from this point that many of the above methods are
* called to work the inbound messages from ccnx as well as sending new interest messages.
*
* \param data the task context information setup by the parent sink element thread
*/
static void
ccn_event_thread (void *data)
{
Gstccnxsrc *src = (Gstccnxsrc *) data;
struct ccn *ccn = src->ccn;
int res = 0;
GST_DEBUG ("*** event thread starting");
/* We pass control to ccnx for a while so it can work with any incoming or outgoing data */
/* We check to see if any problems have caused our ccnd connection to fail, and we reconnect */
while (res >= 0) {
res = ccn_run (ccn, 1000);
if (res < 0 && ccn_get_connection_fd (ccn) == -1) {
/* Try reconnecting, after a bit of delay */
msleep ((30 + (getpid () % 30)) * 1000);
res = ccn_connect (ccn, ccndHost ());
}
}
GST_DEBUG ("*** event thread ending");
}
int
ccn_proxy_connect(struct ccn_proxy *proxy)
{
DEBUG_PRINT("IN %d %s\n", __LINE__, __func__);
if ((proxy->handle = ccn_create()) == NULL) {
DEBUG_PRINT("OUT %d %s failed to create %s ccn handle\n", __LINE__, __func__, proxy->handle_name->buf);
return(-1);
}
if (ccn_connect(proxy->handle, NULL) == -1) {
DEBUG_PRINT("OUT %d %s failed to connect %s ccn handle\n", __LINE__, __func__, proxy->handle_name->buf);
return(-2);
}
DEBUG_PRINT("%d %s setting up interest handler\n", __LINE__, __func__);
ccn_set_interest_filter(proxy->handle, proxy->filter, proxy->int_handler);
DEBUG_PRINT("%d %s interest printer setup\n", __LINE__, __func__);
DEBUG_PRINT("OUT %d %s\n", __LINE__, __func__);
return(0);
}
int GroupManager::ccn_init() {
ccn = NULL;
ccn = ccn_create();
if (ccn == NULL || ccn_connect(ccn, NULL) == -1) {
DPRINT("Failed to initialize ccn agent connection");
return -1;
}
req_closure = NULL;
join_closure = NULL;
cached_keystore = NULL;
init_cached_keystore();
leave_closure = NULL;
leave_closure = (struct ccn_closure *)calloc(1, sizeof(struct ccn_closure));
leave_closure->p = &handle_leave;
join_closure = (struct ccn_closure *)calloc(1, sizeof(struct ccn_closure));
join_closure->p = &incoming_content;
req_closure = (struct ccn_closure *)calloc(1, sizeof(struct ccn_closure));
req_closure->p = &incoming_interest;
return 0;
}
int main (int argc, char **argv) {
int res;
//check if user supplied uri to trace
if(argv[1] == NULL) {
printf("Usage: trace URI\n");
exit(1);
}
//get the length of user provided URI
int argv_length = strlen(argv[1]);
//check first six chars for ccnx:/, if present, skip them
int skip = 0;
res = strncmp("ccnx:/", argv[1], 6);
if(res == 0) {
skip = 5;
}
//if URI does not begins with /, exit
if (argv[1][skip] != '/') {
printf("URI must begin with /\n");
exit(1);
}
//check if uri ends with slash, append if missing
char *slash = "";
if (argv[1][argv_length-1] != '/') {
slash = "/";
}
//allocate memory for trace URI = /trace/user_input/random_number
char *URI = (char *) malloc(sizeof(char)* argv_length+1); //find size of rand
if(URI == NULL) {
fprintf(stderr, "Can not allocate memory for URI\n");
exit(1);
}
//put together the trace URI, add a random number to end of URI
srand ((unsigned int)time (NULL)*getpid());
sprintf(URI, "%s%s", argv[1]+skip, slash);
//allocate memory for interest
struct ccn_charbuf *ccnb = ccn_charbuf_create();
if(ccnb == NULL) {
fprintf(stderr, "Can not allocate memory for interest\n");
exit(1);
}
//adding name to interest
res = ccn_name_from_uri(ccnb, URI);
if(res == -1) {
fprintf(stderr, "Failed to assign name to interest");
exit(1);
}
//create the ccn handle
struct ccn *ccn = ccn_create();
if(ccn == NULL) {
fprintf(stderr, "Can not create ccn handle\n");
exit(1);
}
//connect to ccnd
res = ccn_connect(ccn, NULL);
if (res == -1) {
fprintf(stderr, "Could not connect to ccnd... exiting\n");
exit(1);
}
#ifdef DEBUG
printf("Connected to CCND, return code: %d\n", res);
#endif
//allocate buffer for response
struct ccn_charbuf *resultbuf = ccn_charbuf_create();
if(resultbuf == NULL) {
fprintf(stderr, "Can not allocate memory for URI\n");
exit(1);
}
//setting the parameters for ccn_get
struct ccn_parsed_ContentObject pcobuf = { 0 };
int timeout_ms = 6000;
//express interest
//res = ccn_get(ccn, ccnb, NULL, timeout_ms, resultbuf, &pcobuf, NULL, 0);
//if cached answer is not allowed, set the template
//make sure AnswerOriginKind is 0x0
if(!ALLOW_CACHE) {
struct ccn_charbuf *templ = ccn_charbuf_create();
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_AnswerOriginKind, CCN_DTAG);
ccnb_append_number(templ,0x0);
ccn_charbuf_append_closer(templ); /* </AnswerOriginKind> */
ccn_charbuf_append_closer(templ);
//send out the interest
res = ccn_get(ccn, ccnb, templ, timeout_ms, resultbuf, &pcobuf, NULL, 0);
}
//cached answer is allowed, don't set template
else {
res = ccn_get(ccn, ccnb, NULL, timeout_ms, resultbuf, &pcobuf, NULL, 0);
}
if (res == -1) {
fprintf(stderr, "Did not receive answer for trace to %s\n", argv[1]);
#ifdef DEBUG
fprintf(stderr, "Did not receive answer for trace to URI: %s\n", URI);
#endif
exit(1);
}
//extract data from the response
const unsigned char *ptr;
size_t length;
ptr = resultbuf->buf;
length = resultbuf->length;
ccn_content_get_value(ptr, length, &pcobuf, &ptr, &length);
//check if received some data
if(length == 0) {
fprintf(stderr, "Received empty answer for trace to %s\n", argv[1]);
#ifdef DEBUG
fprintf(stderr, "Received empty answer for trace to URI: %s\n", URI);
#endif
exit(1);
}
//print the data
printf("Reply: %s\n", ptr);
printf("Length of data: %Zu\n", length);
exit(0);
}
int
main(int argc, char **argv)
{
int opt;
int res;
struct ccn *h;
struct ccns_slice *slice;
struct ccns_handle *ccns;
struct ccn_charbuf *prefix = ccn_charbuf_create();
struct ccn_charbuf *roothash = NULL;
struct ccn_charbuf *topo = ccn_charbuf_create();
struct ccn_charbuf *clause = ccn_charbuf_create();
int timeout = 10*1000;
unsigned i, j, n;
slice = ccns_slice_create();
ccn_charbuf_reset(prefix);
ccn_charbuf_reset(topo);
while ((opt = getopt(argc, argv, "hf:p:r:t:w:")) != -1) {
switch (opt) {
case 'f':
ccn_charbuf_reset(clause);
if (0 > ccn_name_from_uri(clause, optarg)) usage(argv[0]);
ccns_slice_add_clause(slice, clause);
break;
case 'p':
ccn_charbuf_reset(prefix);
if (0 > ccn_name_from_uri(prefix, optarg)) usage(argv[0]);
break;
case 'r':
n = strlen(optarg);
if (n == 0) {
roothash = ccn_charbuf_create();
break;
}
if ((n % 2) != 0)
usage(argv[0]);
roothash = ccn_charbuf_create_n(n / 2);
for (i = 0; i < (n / 2); i++) {
j = (hex_value(optarg[2*i]) << 4) | hex_value(optarg[1+2*i]);
ccn_charbuf_append_value(roothash, j, 1);
}
break;
case 't':
ccn_charbuf_reset(topo);
if (0 > ccn_name_from_uri(topo, optarg)) usage(argv[0]);
break;
case 'w':
timeout = atoi(optarg);
if (timeout < -1) usage(argv[0]);
timeout *= 1000;
break;
default:
case 'h':
usage(argv[0]);
}
}
ccns_slice_set_topo_prefix(slice, topo, prefix);
h = ccn_create();
res = ccn_connect(h, NULL);
ccns = ccns_open(h, slice, &sync_cb, roothash, NULL);
ccn_run(h, timeout);
ccns_close(&ccns, NULL, NULL);
ccns_slice_destroy(&slice);
ccn_destroy(&h);
exit(res);
}
int
main(int argc, char **argv)
{
struct ccn *ccn = NULL;
struct ccn_charbuf *c = NULL;
struct ccn_charbuf *templ = NULL;
struct upcalldata *data = NULL;
int i;
int n;
int res;
long counter = 0;
struct ccn_closure *cl = NULL;
int timeout_ms = 500;
const char *env_timeout = getenv("CCN_LINGER");
const char *env_verify = getenv("CCN_VERIFY");
const char *env_scope = getenv("CCN_SCOPE");
if (argv[1] == NULL || argv[2] != NULL)
usage(argv[0]);
if (env_timeout != NULL && (i = atoi(env_timeout)) > 0)
timeout_ms = i * 1000;
c = ccn_charbuf_create();
res = ccn_name_from_uri(c, argv[1]);
if (res < 0)
usage(argv[0]);
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
data = calloc(1, sizeof(*data));
data->magic = 856372;
data->warn = 1492;
data->counter = &counter;
data->option = 0;
if (env_verify && *env_verify)
data->option |= MUST_VERIFY;
data->scope = -1;
if (env_scope != NULL && (i = atoi(env_scope)) >= 0)
data->scope = i;
cl = calloc(1, sizeof(*cl));
cl->p = &incoming_content;
cl->data = data;
if (data->scope > -1) {
templ = ccn_charbuf_create();
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> */
ccnb_tagged_putf(templ, CCN_DTAG_Scope, "%d", data->scope);
ccn_charbuf_append_closer(templ); /* </Interest> */
}
ccn_express_interest(ccn, c, cl, templ);
ccn_charbuf_destroy(&templ);
cl = NULL;
data = NULL;
for (i = 0;; i++) {
n = counter;
ccn_run(ccn, timeout_ms); /* stop if we run dry for 1/2 sec */
fflush(stdout);
if (counter == n)
break;
}
ccn_destroy(&ccn);
ccn_charbuf_destroy(&c);
exit(0);
}
int main(void) {
int res;
struct ccn *ccn= NULL;
struct ccn_charbuf *name = NULL;
struct ccn_charbuf *result = NULL;
struct ccn_closure in_interest = {.p=&incoming_interest};
struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; // Parameters for creating signed content objects.
char rawcontentbuf[1024] = "";
size_t content_size;
// 1. Name
name = ccn_charbuf_create();
res = ccn_name_from_uri(name, URI);
if (res < 0) {
fprintf(stderr, "bad ccn URI: %s\n", URI);
exit(1);
}
// 2. ccn_create, and ccn_connect
ccn = ccn_create();
res = ccn_connect(ccn, NULL);
if (res < 0) {
fprintf(stderr, "can't connect to ccnd: %d\n", res);
ccn_perror(ccn, "ccn_connect");
exit(1);
}
// 3. Create the signed content object, set up &sp - signing params;
// Extend a Name with a new version stamp if requested
/*int versioned = 0;
const char *postver = NULL;
memcmp(postver, "%00", 3);
if (versioned) {
res = ccn_create_version(ccn, name, CCN_V_REPLACE | CCN_V_NOW | CCN_V_HIGH, 0, 0);
if (res < 0) {
fprintf(stderr, "%s: ccn_create_version() failed\n");
exit(1);
}
if (postver != NULL) {
res = ccn_name_from_uri(name, postver);
if (res < 0) {
fprintf(stderr, "-V %s: invalid name suffix\n", postver);
exit(0);
}
}
} */
// Ask for a FinalBlockID if appropriate
/*int setfinal = 0;
if (setfinal)
sp.sp_flags |= CCN_SP_FINAL_BLOCK;
*/
// Set content type
//sp.type = content_type;
// Set freshness
/* The template_ccnb may contain a ccnb-encoded SignedInfo to supply selected fields from under
* the direction of sp_flags.
*/
/*int expire = -1;
if (expire >= 0) {
if (sp.template_ccnb == NULL) {
sp.template_ccnb = ccn_charbuf_create();
ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_SignedInfo, CCN_DTAG);
}
else if (sp.template_ccnb -> length > 0) {
sp.template_ccnb -> length--;
}
ccnb_tagged_putf(sp.template_ccnb, CCN_DTAG_FreshnessSeconds, "%ld", expire);
sp.sp_flags |= CCN_SP_TEMPL_FRESHNESS;
ccn_charbuf_append_closer(sp.template_ccnb);
}
*/
// Set key locator, if supplied
/*const char *key_uri = NULL;
//key_uri = optarg;
if (key_uri != NULL) {
struct ccn_charbuf *c = ccn_charbuf_create();
res = ccn_name_from_uri(c, key_uri);
if (res < 0) {
fprintf(stderr, "%s is not a valid ccnx URI\n", key_uri);
exit(1);
}
if (sp.template_ccnb == NULL) {
sp.template_ccnb = ccn_charbuf_create();
ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_SignedInfo, CCN_DTAG);
}
else if (sp.template_ccnb -> length > 0) {
sp.template_ccnb -> length--;
}
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, c->buf, c->length);
ccn_charbuf_append_closer(sp.template_ccnb);
ccn_charbuf_append_closer(sp.template_ccnb);
sp.sp_flags |= CCN_SP_TEMPL_KEY_LOCATOR;
ccn_charbuf_append_closer(sp.template_ccnb);
ccn_charbuf_destroy(&c);
}
*/
// Set up a handler for interest
ccn_set_interest_filter(ccn, name, &in_interest);
// 4. Use ccn_sign_content to create the signed content object with composed &sp,
// if (force) { ccn_put; } # ccn_get means send ccn binary. For normal clients, this should be a ContentObject sent in response to an Interest.
// else { ccn_set_interest_filter; ccn_run; }
result = ccn_charbuf_create();
result -> length = 0;
strcat(rawcontentbuf, CONTENTDATA);
content_size = strlen(rawcontentbuf);
//sp.sp_flags |= CCN_SP_FINAL_BLOCK;
res = ccn_sign_content(ccn, result, name, &sp, rawcontentbuf, content_size);
if (res < 0) {
ccn_perror(ccn, "ccn_sign_content");
exit(1);
}
printf("Content signed, trying to send the data...\n");
res = ccn_put(ccn, result->buf, result->length);
if (res < 0) {
ccn_perror(ccn, "ccn_put");
printf("Failed to send content object: res = %d\n", res);
exit(1);
}
else
printf("ccn_put done, content object sent.\n");
// ccn_run serves as the event loop when timeout = -1
res = ccn_run(ccn, -1); // Loop here all the time until it is killed, then "Event loop..."
printf("Event loop...\n");
if (res < 0) {
ccn_perror(ccn, "ccn_run");
printf("Error: ccn_run\n");
exit(1);
}
ccn_destroy(&ccn);
ccn_charbuf_destroy(&name);
ccn_charbuf_destroy(&result);
ccn_charbuf_destroy(&sp.template_ccnb);
printf("ccn handle is destroyed... \n");
return 0;
}
int
main(int argc, char **argv)
{
int opt;
int res;
char *prog = argv[0];
struct ccn *h;
struct ccns_slice *slice;
struct ccn_charbuf *prefix = ccn_charbuf_create();
struct ccn_charbuf *topo = ccn_charbuf_create();
struct ccn_charbuf *clause = ccn_charbuf_create();
struct ccn_charbuf *slice_name = ccn_charbuf_create();
struct ccn_charbuf *slice_uri = ccn_charbuf_create();
enum {
CREATE = 0,
DELETE = 1
} cmd = CREATE;
unsigned verbose = 0;
unsigned i;
if (prefix == NULL || topo == NULL || clause == NULL ||
slice_name == NULL || slice_uri == NULL) {
fprintf(stderr, "Unable to allocate required memory.\n");
exit(1);
}
while ((opt = getopt(argc, argv, "vh")) != -1) {
switch (opt) {
case 'v':
verbose = 1;
break;
default:
case 'h':
usage(prog);
break;
}
}
argc -= optind;
argv += optind;
if (argc < 3)
usage(prog);
if (strcmp(argv[0], "create") == 0)
cmd = CREATE;
else if (strcmp(argv[0], "delete") == 0)
cmd = DELETE;
else
usage(prog);
slice = ccns_slice_create();
ccn_charbuf_reset(topo);
if (0 > ccn_name_from_uri(topo, argv[1])) usage(prog);
ccn_charbuf_reset(prefix);
if (0 > ccn_name_from_uri(prefix, argv[2])) usage(prog);
if (0 > ccns_slice_set_topo_prefix(slice, topo, prefix)) usage(prog);
for (i = 3; i < argc; i++) {
ccn_charbuf_reset(clause);
if (0 > ccn_name_from_uri(clause, argv[i])) usage(prog);
else
if (0 > ccns_slice_add_clause(slice, clause)) usage(prog);
}
h = ccn_create();
res = ccn_connect(h, NULL);
if (0 > res) {
fprintf(stderr, "Unable to connect to ccnd.\n");
exit(1);
}
switch(cmd) {
case CREATE:
res = ccns_write_slice(h, slice, slice_name);
break;
case DELETE:
ccns_slice_name(slice_name, slice);
res = ccns_delete_slice(h, slice_name);
break;
}
if (verbose || res < 0) {
ccn_uri_append(slice_uri, slice_name->buf, slice_name->length, 1);
printf("%s slice %s %s\n",
cmd == CREATE ? "create" : "delete",
ccn_charbuf_as_string(slice_uri),
(res < 0) ? "failed" : "succeeded");
}
ccns_slice_destroy(&slice);
ccn_destroy(&h);
ccn_charbuf_destroy(&prefix);
ccn_charbuf_destroy(&topo);
ccn_charbuf_destroy(&clause);
ccn_charbuf_destroy(&slice_name);
ccn_charbuf_destroy(&slice_uri);
exit(res);
}
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)
{
const char *progname = argv[0];
struct ccn *ccn = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_seqwriter *w = NULL;
int blocksize = 1024;
int torepo = 0;
int scope = 1;
int i;
int status = 0;
int res;
ssize_t read_res;
size_t blockread;
unsigned char *buf = NULL;
struct ccn_charbuf *templ;
while ((res = getopt(argc, argv, "hrb:s:")) != -1) {
switch (res) {
case 'b':
blocksize = atoi(optarg);
if (blocksize <= 0 || blocksize > 4096)
usage(progname);
break;
case 'r':
torepo = 1;
break;
case 's':
scope = atoi(optarg);
if (scope < 1 || scope > 3)
usage(progname);
break;
default:
case 'h':
usage(progname);
break;
}
}
argc -= optind;
argv += optind;
if (argc != 1)
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);
}
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
buf = calloc(1, blocksize);
w = ccn_seqw_create(ccn, name);
if (w == NULL) {
fprintf(stderr, "ccn_seqw_create failed\n");
exit(1);
}
ccn_seqw_set_block_limits(w, blocksize, blocksize);
if (torepo) {
struct ccn_charbuf *name_v = ccn_charbuf_create();
ccn_seqw_get_name(w, name_v);
ccn_name_from_uri(name_v, "%C1.R.sw");
ccn_name_append_nonce(name_v);
templ = make_template(scope);
res = ccn_get(ccn, name_v, templ, 60000, NULL, NULL, NULL, 0);
ccn_charbuf_destroy(&templ);
ccn_charbuf_destroy(&name_v);
if (res < 0) {
fprintf(stderr, "No response from repository\n");
exit(1);
}
}
blockread = 0;
for (i = 0;; i++) {
while (blockread < blocksize) {
ccn_run(ccn, 1);
read_res = read(0, buf + blockread, blocksize - blockread);
if (read_res == 0)
goto cleanup;
if (read_res < 0) {
perror("read");
status = 1;
goto cleanup;
}
blockread += read_res;
}
res = ccn_seqw_write(w, buf, blockread);
while (res == -1) {
ccn_run(ccn, 100);
res = ccn_seqw_write(w, buf, blockread);
}
if (res != blockread)
abort(); /* hmm, ccn_seqw_write did a short write or something */
blockread = 0;
}
cleanup:
// flush out any remaining data and close
if (blockread > 0) {
res = ccn_seqw_write(w, buf, blockread);
while (res == -1) {
ccn_run(ccn, 100);
res = ccn_seqw_write(w, buf, blockread);
}
}
ccn_seqw_close(w);
ccn_run(ccn, 1);
free(buf);
buf = NULL;
ccn_charbuf_destroy(&name);
ccn_destroy(&ccn);
exit(status);
}
int
main(int argc, char **argv)
{
struct ccn *ccn = NULL;
struct ccn_charbuf *c = NULL;
struct ccn_charbuf *templ = NULL;
int i;
int res;
int opt;
FILE* closethis = NULL;
while ((opt = getopt(argc, argv, "ho:")) != -1) {
switch (opt) {
case 'o':
if (strcmp(optarg, "-") == 0)
mydata.output = stdout;
else
mydata.output = closethis = fopen(optarg, "wb");
if (mydata.output == NULL) {
perror(optarg);
exit(1);
}
break;
case 'h': /* FALLTHRU */
default: usage(argv[0]);
}
}
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
c = ccn_charbuf_create();
/* set scope to only address ccnd, expire anything we get */
templ = local_scope_rm_template();
for (i = optind; argv[i] != NULL; i++) {
c->length = 0;
res = ccn_name_from_uri(c, argv[i]);
if (res < 0) {
fprintf(stderr, "%s: bad ccn URI: %s\n", argv[0], argv[i]);
exit(1);
}
ccn_express_interest(ccn, c, &incoming_content_action, templ);
}
if (i == optind)
usage(argv[0]);
ccn_charbuf_destroy(&templ);
ccn_charbuf_destroy(&c);
for (i = 0;; i++) {
res = mydata.nseen;
ccn_run(ccn, 100); /* stop if we run dry for 1/10 sec */
if (res == mydata.nseen)
break;
}
if (closethis != NULL)
fclose(closethis);
ccn_destroy(&ccn);
fprintf(stderr, "marked stale: %d\n", mydata.nseen);
exit(0);
}
int cli_main(int argc, char ** argv) {
#else
int main(int argc, char ** argv) {
#endif
#if 0
int sock_in, sock_out;
char* error = NULL;
#endif
_dropbear_exit = cli_dropbear_exit;
_dropbear_log = cli_dropbear_log;
disallow_core();
cli_getopts(argc, argv);
#if 0
TRACE(("user='******' host='%s' port='%s'", cli_opts.username,
cli_opts.remotehost, cli_opts.remoteport))
#endif
TRACE(("user='******' remotehost='%s'", cli_opts.username,
cli_opts.remote_name_str));
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
dropbear_exit("signal() error");
}
#if 0
#ifdef ENABLE_CLI_PROXYCMD
if (cli_opts.proxycmd) {
cli_proxy_cmd(&sock_in, &sock_out);
m_free(cli_opts.proxycmd);
} else
#endif
{
int sock = connect_remote(cli_opts.remotehost, cli_opts.remoteport,
0, &error);
sock_in = sock_out = sock;
}
if (sock_in < 0) {
dropbear_exit("%s", error);
}
cli_session(sock_in, sock_out);
#endif
srand(time(NULL));
cli_opts.ssh_ccn = ccn_create();
cli_opts.ccn_cached_keystore = ccn_init_keystore();
if( cli_opts.ssh_ccn == NULL || ccn_connect(cli_opts.ssh_ccn,NULL) == -1 )
dropbear_exit("Failed to connect to ccnd");
ccn_publish_host_key();
ccn_publish_client_mountpoint();
ccn_ssh_connect(cli_opts.remote_name_str);
// Wait for server response
ccn_run(cli_opts.ssh_ccn,-1);
/* not reached */
return -1;
}
int
main(int argc, char **argv)
{
const char *progname = argv[0];
struct ccn *ccn = NULL;
struct ccn_charbuf *c = NULL;
struct upcalldata *data = NULL;
int opt;
int i;
long n;
int res;
long counter = 0;
struct ccn_closure *cl = NULL;
while ((opt = getopt(argc, argv, "h")) != -1) {
switch (opt) {
case 'h':
default:
usage(argv[0]);
}
}
if (argv[optind] == NULL || argv[optind + 1] != NULL)
usage(argv[0]);
passive_templ = create_passive_templ();
c = ccn_charbuf_create();
res = ccn_name_from_uri(c, argv[optind]);
if (res < 0) {
fprintf(stderr, "%s: bad ccn URI: %s\n", progname, argv[optind]);
exit(1);
}
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
data = calloc(1, sizeof(*data));
data->magic = 856372;
data->warn = 1492;
data->counter = &counter;
cl = calloc(1, sizeof(*cl));
cl->p = &incoming_content;
cl->data = data;
ccn_express_interest(ccn, c, cl, passive_templ);
cl = NULL;
data = NULL;
ccn_charbuf_destroy(&c);
for (i = 0;; i++) {
n = counter;
ccn_run(ccn, 1000); /* stop if we run dry for 1 sec */
fflush(stdout);
if (counter == n)
break;
}
ccn_destroy(&ccn);
ccn_charbuf_destroy(&passive_templ);
exit(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);
}
int main(int argc, char** argv){
struct ccn * ccn = NULL;
//struct ccn_charbuf * name = NULL;
struct ccn_closure * incoming = NULL;
//const char * arg = NULL;
int res;
int micros;
char ch;
struct mydata * mydata = NULL;
int allow_stale = 0;
int use_decimal = 1;
// TANG: comment out unused variables
//int lineMarker = -1;
int start = 0;
int flying = -1;
int i = 0;
char* urlFile = NULL;
//By default, we will send all the urls listed in the file starting from position 0
while ((ch = getopt(argc, argv, "n:s:f:hd")) != -1) {
switch (ch) {
case 'f':
urlFile = optarg;
//printf("file name = %s \n", optarg);
break;
case 's':
start = atoi(optarg);
//printf("start = %d \n", start);
break;
case 'n':
res = atoi(optarg);
if (1 <= res)
flying = res;
else
usage(argv[0]);
//printf("flying = %d \n", flying);
break;
case 'd':
DEBUG = 1;
break;
case 'h':
default:
usage(argv[0]);
}
}
//Initialize the URL list
char ** urlList = NULL;
int lineCount = getLineCount(urlFile);
// printf("There are %d URLs in the file %s\n", lineCount, urlFile);
if(flying == -1)
flying = lineCount; //By default, all the URLs in the urlFile will be queried
urlList = malloc(lineCount * sizeof(char*));
char line[2000];
int idx = 0;
int lineIdx = 0;
FILE *file = fopen(urlFile, "r");
if(file == NULL){
printf("Cannot open file %s, exiting...\n", urlFile);
exit(-1);
}
while(fgets(line, sizeof line, file) != NULL){ /* read a line */
if(lineIdx >= start && lineIdx < start + flying){
urlList[idx] = malloc((strlen(line)) * sizeof(char));
strcpy(urlList[idx], line);
urlList[idx][strlen(line)-1] = '\0';
if(DEBUG){
printf("URL %d = %s \n", idx, line);
printf("URL length = %zu \n", strlen(line));
}
idx++;
}
lineIdx++;
}
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
mydata = calloc(1, sizeof(*mydata));
mydata->h = ccn;
mydata->allow_stale = allow_stale;
mydata->use_decimal = use_decimal;
mydata->excl = NULL;
//Initialize the ooo data
mydata->ooo = malloc(sizeof(struct ooodata) * flying);
for (i = 0; i < flying; i++) {
incoming = &mydata->ooo[i].closure;
incoming->p = &incoming_content;
incoming->data = mydata;
incoming->intdata = -1;
}
//Build and send out a group of interests
ask_set(mydata, urlList, flying);
/* Run a little while to see if there is anything there*/
res = ccn_run(ccn, 500);
/* We got something, run until end of data or somebody kills us */
while (res >= 0) {
micros = 50000000;
res = ccn_run(ccn, micros / 1000);
}
printf("Exiting....");
fclose(urlFile);
//Release the dynamically allocated memory
free(mydata->ooo);
free(mydata);
ccn_destroy(&ccn);
exit(res < 0);
}
/**
* Process options and then loop through command line CCNx URIs retrieving
* the data and writing it to stdout.
*/
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 i;
int res;
int opt;
struct mydata *mydata;
int allow_stale = 0;
int *done;
int exit_status = 0;
done = calloc(1, sizeof(*done));
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();
/* Check the args first */
for (i = optind; argv[i] != NULL; i++) {
name->length = 0;
res = ccn_name_from_uri(name, argv[i]);
if (res < 0) {
fprintf(stderr, "%s: bad ccn URI: %s\n", argv[0], argv[i]);
exit(1);
}
}
for (i = optind; (arg = argv[i]) != NULL; i++) {
*done = 0;
name->length = 0;
res = ccn_name_from_uri(name, arg);
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
ccn_resolve_version(ccn, name, CCN_V_HIGHEST, 50);
ccn_name_append_numeric(name, CCN_MARKER_SEQNUM, 0);
incoming = calloc(1, sizeof(*incoming));
incoming->p = &incoming_content;
mydata = calloc(1, sizeof(*mydata));
mydata->allow_stale = allow_stale;
mydata->done = done;
incoming->data = mydata;
templ = make_template(mydata, NULL);
ccn_express_interest(ccn, name, incoming, templ);
ccn_charbuf_destroy(&templ);
/* Run a little while to see if there is anything there */
res = ccn_run(ccn, 200);
if ((!*done) && incoming->intdata == 0) {
fprintf(stderr, "%s: not found: %s\n", argv[0], arg);
res = -1;
}
/* We got something; run until end of data or somebody kills us */
while (res >= 0 && !*done) {
fflush(stdout);
res = ccn_run(ccn, 333);
}
if (res < 0)
exit_status = 1;
ccn_destroy(&ccn);
fflush(stdout);
free(incoming);
incoming = NULL;
}
ccn_charbuf_destroy(&name);
free(done);
exit(exit_status);
}
int
main(int argc, char **argv)
{
const char *progname = argv[0];
struct ccn *ccn = NULL;
struct ccn_charbuf *name = NULL;
struct ccn_seqwriter *w = NULL;
int blocksize = CCN_MAX_CONTENT_PAYLOAD / 2;
int freshness = -1;
int torepo = 0;
int scope = 1;
int i;
int status = 0;
int res;
ssize_t read_res;
size_t blockread;
unsigned char *buf = NULL;
struct ccn_charbuf *templ;
char *symmetric_suffix = NULL;
const char *password = NULL;
char *dir = NULL;
while ((res = getopt(argc, argv, "hrb:s:x:d:p:o:")) != -1) {
switch (res) {
case 'b':
blocksize = atoi(optarg);
if (blocksize <= 0 || blocksize > CCN_MAX_CONTENT_PAYLOAD)
usage(progname);
break;
case 'r':
torepo = 1;
break;
case 's':
scope = atoi(optarg);
if (scope < 1 || scope > 3)
usage(progname);
break;
case 'x':
freshness = atoi(optarg);
if (freshness < 0)
usage(progname);
break;
case 'd':
symmetric_suffix = optarg;
break;
case 'p':
password = optarg;
break;
case 'o':
dir = optarg;
break;
case 'h':
usage(progname);
break;
}
}
argc -= optind;
argv += optind;
if (argc != 1)
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);
}
ccn = ccn_create();
if (ccn_connect(ccn, NULL) == -1) {
perror("Could not connect to ccnd");
exit(1);
}
buf = calloc(1, blocksize);
w = ccn_seqw_create(ccn, name);
if (w == NULL) {
fprintf(stderr, "ccn_seqw_create failed\n");
exit(1);
}
if (symmetric_suffix != NULL) {
struct ccn_charbuf *key_digest = ccn_charbuf_create();
if (ccn_get_key_digest_from_suffix(ccn, dir, symmetric_suffix, password, key_digest)) {
perror("Can't access keystore");
exit(1);
}
ccn_seqw_set_key_digest(w, key_digest->buf, key_digest->length);
ccn_charbuf_destroy(&key_digest);
}
ccn_seqw_set_block_limits(w, blocksize, blocksize);
if (freshness > -1)
ccn_seqw_set_freshness(w, freshness);
if (torepo) {
struct ccn_charbuf *name_v = ccn_charbuf_create();
ccn_seqw_get_name(w, name_v);
ccn_name_from_uri(name_v, "%C1.R.sw");
ccn_name_append_nonce(name_v);
templ = make_template(scope);
res = ccn_get(ccn, name_v, templ, 60000, NULL, NULL, NULL, 0);
ccn_charbuf_destroy(&templ);
ccn_charbuf_destroy(&name_v);
if (res < 0) {
fprintf(stderr, "No response from repository\n");
exit(1);
}
}
blockread = 0;
for (i = 0;; i++) {
while (blockread < blocksize) {
if (ccn_run(ccn, 1) < 0) {
fprintf(stderr, "Lost connection to ccnd: %s\n",
strerror(ccn_geterror(ccn)));
exit(1);
}
read_res = read(0, buf + blockread, blocksize - blockread);
if (read_res == 0)
goto cleanup;
if (read_res < 0) {
perror("read");
status = 1;
goto cleanup;
}
blockread += read_res;
}
res = ccn_seqw_write(w, buf, blockread);
while (res == -1) {
if (ccn_run(ccn, 100) < 0) {
fprintf(stderr, "Lost connection to ccnd: %s\n",
strerror(ccn_geterror(ccn)));
exit(1);
}
res = ccn_seqw_write(w, buf, blockread);
}
if (res != blockread)
abort(); /* hmm, ccn_seqw_write did a short write or something */
blockread = 0;
}
cleanup:
// flush out any remaining data and close
if (blockread > 0) {
res = ccn_seqw_write(w, buf, blockread);
while (res == -1) {
if (ccn_run(ccn, 100) < 0) {
fprintf(stderr, "Lost connection to ccnd: %s\n",
strerror(ccn_geterror(ccn)));
exit(1);
}
res = ccn_seqw_write(w, buf, blockread);
}
}
ccn_seqw_close(w);
ccn_run(ccn, 1);
free(buf);
buf = NULL;
ccn_charbuf_destroy(&name);
ccn_destroy(&ccn);
exit(status);
}
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);
}