void
ccnl_simu_cleanup(void *dummy, void *dummy2)
{
printf("Simulation ended; press ENTER to terminate\n");
while (getchar() != '\n');
int i;
for (i = 0; i < 5; i++) {
struct ccnl_relay_s *relay = relays + i;
if (relay->aux) {
ccnl_free(relay->aux);
relay->aux = NULL;
}
ccnl_core_cleanup(relay);
}
while(eventqueue)
ccnl_rem_timer(eventqueue);
while(etherqueue) {
struct ccnl_ethernet_s *e = etherqueue->next;
ccnl_free(etherqueue);
etherqueue = e;
}
#ifdef USE_SCHEDULER
ccnl_sched_cleanup();
#endif
#ifdef USE_DEBUG_MALLOC
debug_memdump();
#endif
}
void free_4ptr_list(void *a, void *b, void *c, void *d)
{
ccnl_free(a);
ccnl_free(b);
ccnl_free(c);
ccnl_free(d);
}
void
ccnl_core_cleanup(struct ccnl_relay_s *ccnl)
{
int k;
DEBUGMSG_CORE(TRACE, "ccnl_core_cleanup %p\n", (void *) ccnl);
while (ccnl->pit)
ccnl_interest_remove(ccnl, ccnl->pit);
while (ccnl->faces)
ccnl_face_remove(ccnl, ccnl->faces); // removes allmost all FWD entries
while (ccnl->fib) {
struct ccnl_forward_s *fwd = ccnl->fib->next;
ccnl_prefix_free(ccnl->fib->prefix);
ccnl_free(ccnl->fib);
ccnl->fib = fwd;
}
while (ccnl->contents)
ccnl_content_remove(ccnl, ccnl->contents);
while (ccnl->nonces) {
struct ccnl_buf_s *tmp = ccnl->nonces->next;
ccnl_free(ccnl->nonces);
ccnl->nonces = tmp;
}
for (k = 0; k < ccnl->ifcount; k++)
ccnl_interface_cleanup(ccnl->ifs + k);
}
struct ccnl_interest_s*
ccnl_interest_remove(struct ccnl_relay_s *ccnl, struct ccnl_interest_s *i)
{
struct ccnl_interest_s *i2;
/*
if (!i)
return NULL;
*/
DEBUGMSG_CORE(TRACE, "ccnl_interest_remove %p\n", (void *) i);
/*
#ifdef USE_NFN
if (!(i->flags & CCNL_PIT_COREPROPAGATES))
return i->next;
#endif
*/
while (i->pending) {
struct ccnl_pendint_s *tmp = i->pending->next; \
ccnl_free(i->pending);
i->pending = tmp;
}
i2 = i->next;
DBL_LINKED_LIST_REMOVE(ccnl->pit, i);
free_packet(i->pkt);
ccnl_free(i);
return i2;
}
// executes (loops over) a Lambda expression: tries to run to termination,
// or returns after having emitted further remote lookup/reduction requests
// the return val is a buffer with the result stack's (concatenated) content
struct ccnl_buf_s*
Krivine_reduction(struct ccnl_relay_s *ccnl, char *expression,
int start_locally,
struct configuration_s **config,
struct ccnl_prefix_s *prefix, int suite)
{
int steps = 0, halt = 0, restart = 1;
int len = strlen("CLOSURE(HALT);RESOLVENAME()") + strlen(expression) + 1;
char *dummybuf;
DEBUGMSG(TRACE, "Krivine_reduction()\n");
if (!*config && strlen(expression) == 0)
return 0;
dummybuf = ccnl_malloc(2000);
if (!*config) {
char *prog;
struct environment_s *global_dict = NULL;
prog = ccnl_malloc(len*sizeof(char));
sprintf(prog, "CLOSURE(HALT);RESOLVENAME(%s)", expression);
setup_global_environment(&global_dict);
DEBUGMSG(DEBUG, "PREFIX %s\n", ccnl_prefix_to_path(prefix));
*config = new_config(ccnl, prog, global_dict,
start_locally,
prefix, ccnl->km->configid, suite);
DBL_LINKED_LIST_ADD(ccnl->km->configuration_list, (*config));
restart = 0;
--ccnl->km->configid;
}
DEBUGMSG(INFO, "Prog: %s\n", (*config)->prog);
while ((*config)->prog && !halt) {
char *oldprog = (*config)->prog;
steps++;
DEBUGMSG(DEBUG, "Step %d (%d/%d): %s\n", steps,
stack_len((*config)->argument_stack),
stack_len((*config)->result_stack), (*config)->prog);
(*config)->prog = ZAM_term(ccnl, *config, &halt, dummybuf, &restart);
ccnl_free(oldprog);
}
ccnl_free(dummybuf);
if (halt < 0) { //HALT < 0 means pause computation
DEBUGMSG(INFO,"Pause computation: %d\n", -(*config)->configid);
return NULL;
}
//HALT > 0 means computation finished
DEBUGMSG(INFO, "end-of-computation (%d/%d)\n",
stack_len((*config)->argument_stack),
stack_len((*config)->result_stack));
/*
print_argument_stack((*config)->argument_stack);
print_result_stack((*config)->result_stack);
*/
return Krivine_exportResultStack(ccnl, *config);
}
void ccnl_frag_destroy(struct ccnl_frag_s *e)
{
if (e) {
ccnl_free(e->bigpkt);
ccnl_free(e->defrag);
ccnl_free(e);
}
}
void
ccnl_lambdaFreeTerm(struct ccnl_lambdaTerm_s *t)
{
if (t) {
ccnl_free(t->v);
ccnl_lambdaFreeTerm(t->m);
ccnl_lambdaFreeTerm(t->n);
ccnl_free(t);
}
}
void ccnl_populate_cache(struct ccnl_relay_s *ccnl, unsigned char *buf, int datalen)
{
if (buf[0] == 0x04 && buf[1] == 0x82) {
struct ccnl_prefix_s *prefix = 0;
struct ccnl_content_s *c = 0;
struct ccnl_buf_s *nonce = 0, *ppkd = 0, *pkt = 0;
unsigned char *content, *data = buf + 2;
int contlen;
datalen -= 2;
pkt = ccnl_extract_prefix_nonce_ppkd(&data, &datalen, 0, 0,
0, 0, &prefix, &nonce, &ppkd, &content, &contlen);
if (!pkt) {
DEBUGMSG(6, " parsing error\n");
goto Done;
}
if (!prefix) {
DEBUGMSG(6, " no prefix error\n");
goto Done;
}
printf("populating: %s\n", ccnl_prefix_to_path(prefix));
c = ccnl_content_new(ccnl, &pkt, &prefix, &ppkd, content,
contlen);
if (!c) {
goto Done;
}
c->flags |= CCNL_CONTENT_FLAGS_STATIC;
if (!ccnl_content_add2cache(ccnl, c)) {
// content store error
free_content(c);
}
Done:
free_prefix(prefix);
ccnl_free(pkt);
ccnl_free(nonce);
ccnl_free(ppkd);
}
else {
DEBUGMSG(6, " not a content object\n");
}
}
int ccnl_riot_client_register_prefix(kernel_pid_t relay_pid, char *prefix, char *faceid,
unsigned char *reply_buf)
{
DEBUGMSG(1, "riot_register_prefix: mkPrefixregRequest\n");
int len = mkPrefixregRequest(reply_buf, 1, prefix, faceid);
riot_ccnl_msg_t rmsg;
rmsg.payload = reply_buf;
rmsg.size = len;
msg_t m, rep;
m.content.ptr = (char *) &rmsg;
m.type = CCNL_RIOT_MSG;
DEBUGMSG(1, " sending prefix req to relay\n");
msg_send(&m, relay_pid, 1);
/* ######################################################################### */
msg_receive(&rep);
DEBUGMSG(1, " received reply from relay\n");
riot_ccnl_msg_t *rmsg_reply = (riot_ccnl_msg_t *) rep.content.ptr;
memcpy(reply_buf, rmsg_reply->payload, rmsg_reply->size);
reply_buf[rmsg_reply->size] = '\0';
int size = rmsg_reply->size;
ccnl_free(rmsg_reply);
return size;
}
int ccnl_riot_client_new_face(kernel_pid_t relay_pid, char *type, char *faceid,
unsigned char *reply_buf)
{
DEBUGMSG(1, "riot_new_face: mkNewFaceRquest\n");
int len = mkNewFaceRequest(reply_buf, type, NULL, NULL, faceid, NULL);
riot_ccnl_msg_t rmsg;
rmsg.payload = reply_buf;
rmsg.size = len;
msg_t m, rep;
m.content.ptr = (char *) &rmsg;
m.type = CCNL_RIOT_MSG;
DEBUGMSG(1, " sending face req to relay\n");
msg_send(&m, relay_pid, 1);
/* ######################################################################### */
msg_receive(&rep);
DEBUGMSG(1, " received reply from relay\n");
riot_ccnl_msg_t *rmsg_reply = (riot_ccnl_msg_t *) rep.content.ptr;
memcpy(reply_buf, rmsg_reply->payload, rmsg_reply->size);
int size = rmsg_reply->size;
ccnl_free(rmsg_reply);
return size;
}
struct ccnl_content_s*
ccnl_content_add2cache(struct ccnl_relay_s *ccnl, struct ccnl_content_s *c)
{
struct ccnl_content_s *cit;
char *s = NULL;
DEBUGMSG_CORE(DEBUG, "ccnl_content_add2cache (%d/%d) --> %p = %s [%d]\n",
ccnl->contentcnt, ccnl->max_cache_entries,
(void*)c, (s = ccnl_prefix_to_path(c->pkt->pfx)), (c->pkt->pfx->chunknum)? *(c->pkt->pfx->chunknum) : -1);
ccnl_free(s);
for (cit = ccnl->contents; cit; cit = cit->next) {
if (c == cit) {
DEBUGMSG_CORE(DEBUG, "--- Already in cache ---\n");
return NULL;
}
}
#ifdef USE_NACK
if (ccnl_nfnprefix_contentIsNACK(c))
return NULL;
#endif
if (ccnl->max_cache_entries > 0 &&
ccnl->contentcnt >= ccnl->max_cache_entries) { // remove oldest content
struct ccnl_content_s *c2;
int age = 0;
for (c2 = ccnl->contents; c2; c2 = c2->next)
if (!(c2->flags & CCNL_CONTENT_FLAGS_STATIC) &&
((age == 0) || c2->last_used < age))
age = c2->last_used;
if (c2)
ccnl_content_remove(ccnl, c2);
}
DBL_LINKED_LIST_ADD(ccnl->contents, c);
ccnl->contentcnt++;
return c;
}
int ccnl_face_enqueue(struct ccnl_relay_s *ccnl, struct ccnl_face_s *to,
struct ccnl_buf_s *buf)
{
struct ccnl_buf_s *msg;
DEBUGMSG(20, "ccnl_face_enqueue face=%p (id=%d.%d) buf=%p len=%d\n",
(void *) to, ccnl->id, to->faceid, (void *) buf, buf->datalen);
for (msg = to->outq; msg; msg = msg->next) // already in the queue?
if (buf_equal(msg, buf)) {
DEBUGMSG(31, " not enqueued because already there\n");
ccnl_free(buf);
return -1;
}
buf->next = NULL;
if (to->outqend) {
to->outqend->next = buf;
}
else {
to->outq = buf;
}
to->outqend = buf;
ccnl_face_CTS(ccnl, to);
return 0;
}
struct timeval *
ccnl_run_events(void)
{
static struct timeval now;
long usec;
ccnl_get_timeval(&now);
//DEBUGMSG(1, "ccnl_run_events now: %ld:%ld\n", now.tv_sec, now.tv_usec);
while (eventqueue) {
struct ccnl_timer_s *t = eventqueue;
usec = timevaldelta(&(t->timeout), &now);
if (usec >= 0) {
//DEBUGMSG(1, "ccnl_run_events nothing to do: %ld:%ld\n", now.tv_sec, now.tv_usec);
now.tv_sec = usec / 1000000;
now.tv_usec = usec % 1000000;
return &now;
}
//DEBUGMSG(1, "ccnl_run_events run event handler: %ld:%ld\n", now.tv_sec, now.tv_usec);
if (t->fct) {
(t->fct)(t->node, t->intarg);
}
else if (t->fct2) {
(t->fct2)(t->aux1, t->aux2);
}
eventqueue = t->next;
ccnl_free(t);
}
return NULL;
}
static void riot_ccnl_appserver_ioloop(void)
{
DEBUGMSG(1, "starting appserver main event and IO loop\n");
if (msg_init_queue(msg_buffer_appserver, APPSERVER_MSG_BUFFER_SIZE) != 0) {
DEBUGMSG(1, "msg init queue failed...abording\n");
}
msg_t in;
riot_ccnl_msg_t *m;
while (1) {
DEBUGMSG(1, "appserver: waiting for incomming msg\n");
msg_receive(&in);
switch (in.type) {
case (CCNL_RIOT_MSG):
m = (riot_ccnl_msg_t *) in.content.ptr;
DEBUGMSG(1, "new msg: size=%" PRIu16 " sender_pid=%" PRIu16 "\n",
m->size, in.sender_pid);
appserver_handle_interest(m->payload, m->size, in.sender_pid);
ccnl_free(m);
break;
default:
DEBUGMSG(1,
"received unknown msg type: '%" PRIu16 "' dropping it\n",
in.type);
break;
}
}
}
void
ccnl_simu_add_fwd(char node, const char *name, char dstnode)
{
struct ccnl_relay_s *relay = char2relay(node), *dst = char2relay(dstnode);
struct ccnl_forward_s *fwd;
sockunion sun;
char *cp;
DEBUGMSG(TRACE, "ccnl_simu_add_fwd\n");
sun.eth.sll_family = AF_PACKET;
memcpy(sun.eth.sll_addr, dst->ifs[0].addr.eth.sll_addr, ETH_ALEN);
fwd = (struct ccnl_forward_s *) ccnl_calloc(1, sizeof(*fwd));
// fwd->prefix = ccnl_path_to_prefix(name);
cp = ccnl_strdup(name);
fwd->prefix = ccnl_URItoPrefix(cp, theSuite, NULL, NULL);
ccnl_free(cp);
fwd->suite = theSuite;
fwd->face = ccnl_get_face_or_create(relay, 0, &sun.sa, sizeof(sun.eth));
#ifdef USE_FRAG
// fwd->face->frag = ccnl_frag_new(CCNL_FRAG_SEQUENCED2012, 1500);
fwd->face->frag = ccnl_frag_new(CCNL_FRAG_CCNx2013, 1200);
#endif
fwd->face->flags |= CCNL_FACE_FLAGS_STATIC;
fwd->next = relay->fib;
relay->fib = fwd;
}
/**
*
* @param ccnl
* @param content
* @param content_len
* @param sig
* @param sig_len
* @param callback function which should be called when crypto system returns
* for a new callback function you have to extend ccnl_crypto()!!!!
* @return
*/
int
ccnl_crypto_verify(struct ccnl_relay_s *ccnl, char *content, int content_len,
char *sig, int sig_len, char* callback, int sequnum)
{
char *msg = 0;
int len = 0, ret = 0;
struct ccnl_buf_s *retbuf;
//int plen;
//unsigned char *buf;
plen = 0;
memset(buf,0,sizeof(buf));
if(!ccnl->crypto_face) return ret;
msg = (char *)ccnl_malloc(sizeof(char)*(content_len+sig_len)+3000);
len = ccnl_crypto_create_ccnl_sign_verify_msg("verify", sequnum, content,
content_len, sig, sig_len, msg, callback);
if(len > CCNL_MAX_PACKET_SIZE){
DEBUGMSG(DEBUG,"Ignored, packet size too large");
return 0;
}
//send ccn_msg to crytoserver
retbuf = ccnl_buf_new((char *)msg, len);
ccnl_face_enqueue(ccnl, ccnl->crypto_face, retbuf);
if(msg) ccnl_free(msg);
return ret;
}
void
ccnl_interface_enqueue(void (tx_done)(void*, int, int), struct ccnl_face_s *f,
struct ccnl_relay_s *ccnl, struct ccnl_if_s *ifc,
struct ccnl_buf_s *buf, sockunion *dest)
{
struct ccnl_txrequest_s *r;
DEBUGMSG_CORE(TRACE, "enqueue interface=%p buf=%p len=%d (qlen=%d)\n",
(void*)ifc, (void*)buf,
buf ? buf->datalen : -1, ifc ? ifc->qlen : -1);
if (ifc->qlen >= CCNL_MAX_IF_QLEN) {
DEBUGMSG_CORE(WARNING, " DROPPING buf=%p\n", (void*)buf);
ccnl_free(buf);
return;
}
r = ifc->queue + ((ifc->qfront + ifc->qlen) % CCNL_MAX_IF_QLEN);
r->buf = buf;
memcpy(&r->dst, dest, sizeof(sockunion));
r->txdone = tx_done;
r->txdone_face = f;
ifc->qlen++;
#ifdef USE_SCHEDULER
ccnl_sched_RTS(ifc->sched, 1, buf->datalen, ccnl, ifc);
#else
ccnl_interface_CTS(ccnl, ifc);
#endif
}
void
ccnl_client_TX(char node, char *name, int seqn, int nonce)
{
char tmp[512];
struct ccnl_prefix_s *p;
struct ccnl_buf_s *buf;
struct ccnl_relay_s *relay = char2relay(node);
DEBUGMSG(TRACE, "ccnl_client_tx node=%c: request %s #%d\n",
node, name, seqn);
if (!relay)
return;
sprintf(tmp, "%s/.%d", name, seqn);
// p = ccnl_path_to_prefix(tmp);
// p->suite = suite;
p = ccnl_URItoPrefix(tmp, theSuite, NULL, NULL);
DEBUGMSG(TRACE, " create interest for %s\n", ccnl_prefix_to_path(p));
buf = ccnl_mkSimpleInterest(p, &nonce);
free_prefix(p);
// inject it into the relay:
if (buf) {
ccnl_core_RX(relay, -1, buf->data, buf->datalen, 0, 0);
ccnl_free(buf);
}
}
void
ccnl_interface_CTS(void *aux1, void *aux2)
{
struct ccnl_relay_s *ccnl = (struct ccnl_relay_s *)aux1;
struct ccnl_if_s *ifc = (struct ccnl_if_s *)aux2;
struct ccnl_txrequest_s *r, req;
DEBUGMSG_CORE(TRACE, "interface_CTS interface=%p, qlen=%d, sched=%p\n",
(void*)ifc, ifc->qlen, (void*)ifc->sched);
if (ifc->qlen <= 0)
return;
#ifdef USE_STATS
ifc->tx_cnt++;
#endif
r = ifc->queue + ifc->qfront;
memcpy(&req, r, sizeof(req));
ifc->qfront = (ifc->qfront + 1) % CCNL_MAX_IF_QLEN;
ifc->qlen--;
ccnl_ll_TX(ccnl, ifc, &req.dst, req.buf);
#ifdef USE_SCHEDULER
ccnl_sched_CTS_done(ifc->sched, 1, req.buf->datalen);
if (req.txdone)
req.txdone(req.txdone_face, 1, req.buf->datalen);
#endif
ccnl_free(req.buf);
}
struct ccnl_sched_s*
ccnl_sched_pktrate_new(void (cts)(void *aux1, void *aux2),
struct ccnl_relay_s *ccnl, int inter_packet_interval)
{
struct ccnl_sched_s *s;
DEBUGMSG(TRACE, "ccnl_sched_pktrate_new()\n");
s = (struct ccnl_sched_s*) ccnl_calloc(1, sizeof(struct ccnl_sched_s));
if (!s)
return NULL;
s->mode = 1;
s->cts = cts;
s->ccnl = ccnl;
#ifdef USE_CHEMFLOW
if (cfnl_sched_create_default_rnet(s, inter_packet_interval)) {
ccnl_free(s);
return NULL;
}
#else
ccnl_get_timeval(&(s->nextTX));
s->ipi = inter_packet_interval;
#endif
return s;
}
/**
* @brief initializing routing system
* @param pointer to count transceiver pids
*
*/
void *ccnl_riot_relay_start(void *arg)
{
(void) arg;
theRelay = calloc(1, sizeof(struct ccnl_relay_s));
ccnl_get_timeval(&theRelay->startup_time);
theRelay->riot_pid = sched_active_pid;
mutex_init(&theRelay->global_lock);
DEBUGMSG(1, "This is ccn-lite-relay, starting at %lu:%lu\n", theRelay->startup_time.tv_sec, theRelay->startup_time.tv_usec);
DEBUGMSG(1, " compile time: %s %s\n", __DATE__, __TIME__);
DEBUGMSG(1, " max_cache_entries: %d\n", CCNL_DEFAULT_MAX_CACHE_ENTRIES);
DEBUGMSG(1, " threshold_prefix: %d\n", CCNL_DEFAULT_THRESHOLD_PREFIX);
DEBUGMSG(1, " threshold_aggregate: %d\n", CCNL_DEFAULT_THRESHOLD_AGGREGATE);
ccnl_relay_config(theRelay, CCNL_DEFAULT_MAX_CACHE_ENTRIES, CCNL_DEFAULT_THRESHOLD_PREFIX, CCNL_DEFAULT_THRESHOLD_AGGREGATE);
theRelay->riot_helper_pid = riot_start_helper_thread();
ccnl_io_loop(theRelay);
DEBUGMSG(1, "ioloop stopped\n");
while (eventqueue) {
ccnl_rem_timer(eventqueue);
}
ccnl_core_cleanup(theRelay);
mutex_lock(&theRelay->stop_lock);
ccnl_free(theRelay);
return NULL;
}
static int
ccnl_crypto_create_ccnl_sign_verify_msg(char *typ, int txid, char *content, int content_len,
char *sig, int sig_len, char *msg, char *callback)
{
int len = 0, len2 = 0, len3 = 0;
char *component_buf, *contentobj_buf;
char h[100];
component_buf = ccnl_malloc(sizeof(char)*(content_len)+2000);
contentobj_buf = ccnl_malloc(sizeof(char)*(content_len)+1000);
len = ccnl_ccnb_mkHeader(msg, CCN_DTAG_INTEREST, CCN_TT_DTAG); // interest
len += ccnl_ccnb_mkHeader(msg+len, CCN_DTAG_NAME, CCN_TT_DTAG); // name
len += ccnl_ccnb_mkStrBlob(msg+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "ccnx");
len += ccnl_ccnb_mkStrBlob(msg+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "crypto");
// prepare FACEINSTANCE
len3 += ccnl_ccnb_mkStrBlob(component_buf+len3, CCNL_DTAG_CALLBACK, CCN_TT_DTAG, callback);
len3 += ccnl_ccnb_mkStrBlob(component_buf+len3, CCN_DTAG_TYPE, CCN_TT_DTAG, typ);
memset(h, 0, 100);
sprintf(h, "%d", txid);
len3 += ccnl_ccnb_mkStrBlob(component_buf+len3, CCN_DTAG_SEQNO, CCN_TT_DTAG, h);
if(!strcmp(typ, "verify"))
len3 += ccnl_ccnb_mkBlob(component_buf+len3, CCN_DTAG_SIGNATURE, CCN_TT_DTAG, // content
(char*) sig, sig_len);
len3 += ccnl_ccnb_mkBlob(component_buf+len3, CCN_DTAG_CONTENTDIGEST, CCN_TT_DTAG, // content
(char*) content, content_len);
// prepare CONTENTOBJ with CONTENT
len2 = ccnl_ccnb_mkHeader(contentobj_buf, CCN_DTAG_CONTENTOBJ, CCN_TT_DTAG); // contentobj
len2 += ccnl_ccnb_mkBlob(contentobj_buf+len2, CCN_DTAG_CONTENT, CCN_TT_DTAG, // content
(char*) component_buf, len3);
contentobj_buf[len2++] = 0; // end-of-contentobj
// add CONTENTOBJ as the final name component
len += ccnl_ccnb_mkBlob(msg+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, // comp
(char*) contentobj_buf, len2);
msg[len++] = 0; // end-of-name
msg[len++] = 0; // end-o
ccnl_free(component_buf);
ccnl_free(contentobj_buf);
return len;
}
struct ccnl_content_s*
ccnl_content_remove(struct ccnl_relay_s *ccnl, struct ccnl_content_s *c)
{
struct ccnl_content_s *c2;
c2 = c->next;
DBL_LINKED_LIST_REMOVE(ccnl->contents, c);
// free_content(c);
if (c->pkt) {
free_prefix(c->pkt->pfx);
ccnl_free(c->pkt->buf);
ccnl_free(c->pkt);
}
// free_prefix(c->name);
ccnl_free(c);
ccnl->contentcnt--;
DEBUGMSG_CORE(INFO, " ICNIoT: remove_contentFromCache:%d\n",ccnl->contentcnt);
return c2;
}
struct ccnl_http_s*
ccnl_http_cleanup(struct ccnl_http_s *http)
{
if (!http)
return NULL;
if (http->server)
close(http->server);
if (http->client)
close(http->client);
ccnl_free(http);
return NULL;
}
struct ccnl_content_s*
ccnl_content_remove(struct ccnl_relay_s *ccnl, struct ccnl_content_s *c)
{
struct ccnl_content_s *c2;
DEBUGMSG_CORE(TRACE, "ccnl_content_remove\n");
c2 = c->next;
DBL_LINKED_LIST_REMOVE(ccnl->contents, c);
// free_content(c);
if (c->pkt) {
free_prefix(c->pkt->pfx);
ccnl_free(c->pkt->buf);
ccnl_free(c->pkt);
}
// free_prefix(c->name);
ccnl_free(c);
ccnl->contentcnt--;
return c2;
}
int
ccnl_prefix_appendCmp(struct ccnl_prefix_s *prefix, unsigned char *cmp,
int cmplen)
{
int lastcmp = prefix->compcnt, i;
int *oldcomplen = prefix->complen;
unsigned char **oldcomp = prefix->comp;
unsigned char *oldbytes = prefix->bytes;
int prefixlen = 0;
if (prefix->compcnt + 1 > CCNL_MAX_NAME_COMP)
return -1;
for (i = 0; i < lastcmp; i++) {
prefixlen += prefix->complen[i];
}
prefix->compcnt++;
prefix->comp = (unsigned char**) ccnl_malloc(prefix->compcnt * sizeof(unsigned char*));
prefix->complen = (int*) ccnl_malloc(prefix->compcnt * sizeof(int));
prefix->bytes = (unsigned char*) ccnl_malloc(prefixlen + cmplen);
memcpy(prefix->bytes, oldbytes, prefixlen);
memcpy(prefix->bytes + prefixlen, cmp, cmplen);
prefixlen = 0;
for (i = 0; i < lastcmp; i++) {
prefix->comp[i] = &prefix->bytes[prefixlen];
prefix->complen[i] = oldcomplen[i];
prefixlen += oldcomplen[i];
}
prefix->comp[lastcmp] = &prefix->bytes[prefixlen];
prefix->complen[lastcmp] = cmplen;
ccnl_free(oldcomp);
ccnl_free(oldcomplen);
ccnl_free(oldbytes);
return 0;
}
// consumes the result stack, exports its content to a buffer
struct ccnl_buf_s*
Krivine_exportResultStack(struct ccnl_relay_s *ccnl,
struct configuration_s *config)
{
char res[64000]; //TODO longer???
int pos = 0;
struct stack_s *stack;
struct ccnl_content_s *cont;
while ((stack = pop_or_resolve_from_result_stack(ccnl, config))) {
if (stack->type == STACK_TYPE_PREFIX) {
cont = ccnl_nfn_local_content_search(ccnl, config, stack->content);
if (cont) {
memcpy(res+pos, (char*)cont->pkt->content, cont->pkt->contlen);
pos += cont->pkt->contlen;
}
} else if (stack->type == STACK_TYPE_PREFIXRAW) {
cont = ccnl_nfn_local_content_search(ccnl, config, stack->content);
if (cont) {
/*
DEBUGMSG(DEBUG, " PREFIXRAW packet: %p %d\n", (void*) cont->buf,
cont->buf ? cont->buf->datalen : -1);
*/
memcpy(res+pos, (char*)cont->pkt->buf->data,
cont->pkt->buf->datalen);
pos += cont->pkt->buf->datalen;
}
} else if (stack->type == STACK_TYPE_INT) {
//h = ccnl_buf_new(NULL, 10);
//sprintf((char*)h->data, "%d", *(int*)stack->content);
//h->datalen = strlen((char*)h->data);
pos += sprintf(res + pos, "%d", *(int*)stack->content);
}
ccnl_free(stack->content);
ccnl_free(stack);
}
return ccnl_buf_new(res, pos);
}
void
ccnl_interface_cleanup(struct ccnl_if_s *i)
{
int j;
DEBUGMSG_CORE(TRACE, "ccnl_interface_cleanup\n");
ccnl_sched_destroy(i->sched);
for (j = 0; j < i->qlen; j++) {
struct ccnl_txrequest_s *r = i->queue + (i->qfront+j)%CCNL_MAX_IF_QLEN;
ccnl_free(r->buf);
}
ccnl_close_socket(i->sock);
}
struct ccnl_buf_s*
ccnl_frag_getnextBE2015(struct ccnl_frag_s *fr, int *ifndx, sockunion *su)
{
struct ccnl_buf_s *buf = 0;
unsigned int datalen = 0;
DEBUGMSG_EFRA(VERBOSE, "ccnl_frag_getnextBE2015: remaining=%d\n",
fr->bigpkt->datalen - fr->sendoffs);
switch(fr->outsuite) {
#ifdef USE_SUITE_CCNTLV
case CCNL_SUITE_CCNTLV:
buf = ccnl_ccntlv_mkFrag(fr, &datalen);
break;
#endif
#ifdef USE_SUITE_IOTTLV
case CCNL_SUITE_IOTTLV:
buf = ccnl_iottlv_mkFrag(fr, &datalen);
break;
#endif
#ifdef USE_SUITE_NDNTLV
case CCNL_SUITE_NDNTLV:
buf = ccnl_ndntlv_mkFrag(fr, &datalen);
break;
#endif
default:
break;
}
if (buf) {
fr->sendseq++;
fr->sendoffs += datalen;
if (fr->sendoffs >= fr->bigpkt->datalen) {
ccnl_free(fr->bigpkt);
fr->bigpkt = NULL;
}
if (ifndx)
*ifndx = fr->ifndx;
if (su)
memcpy(su, &fr->dest, sizeof(*su));
DEBUGMSG_EFRA(VERBOSE, " produced %d bytes fragment, seqnr=%d-1\n",
buf->datalen, fr->sendseq);
} else
DEBUGMSG_EFRA(VERBOSE, " produced NO fragment, seqnr remains at =%d-1\n",
fr->sendseq);
return buf;
}
void
ccnl_rem_timer(void *h)
{
struct ccnl_timer_s **pp;
for (pp = &eventqueue; *pp; pp = &((*pp)->next)) {
if ((void*)*pp == h) {
struct ccnl_timer_s *e = *pp;
*pp = e->next;
ccnl_free(e);
break;
}
}
}
