void ccnl_simu_add2cache(char node, const char *name, int seqn, void *data, int len) { struct ccnl_relay_s *relay; char tmp[100]; int dataoffset; struct ccnl_content_s *c; struct ccnl_pkt_s *pkt; relay = char2relay(node); if (!relay) return; sprintf(tmp, "%s/.%d", name, seqn); DEBUGMSG(VERBOSE, " %s\n", tmp); // p = ccnl_path_to_prefix(tmp); // p->suite = suite; pkt = ccnl_calloc(1, sizeof(*pkt)); pkt->pfx = ccnl_URItoPrefix(tmp, theSuite, NULL, NULL); DEBUGMSG(VERBOSE, " %s\n", ccnl_prefix_to_path(pkt->pfx)); pkt->buf = ccnl_mkSimpleContent(pkt->pfx, data, len, &dataoffset); pkt->content = pkt->buf->data + dataoffset; pkt->contlen = len; c = ccnl_content_new(relay, &pkt); if (c) ccnl_content_add2cache(relay, c); return; }
void ccnl_simu_add2cache(char node, const char *name, int seqn, void *data, int len) { struct ccnl_relay_s *relay; char tmp[100]; struct ccnl_prefix_s *p; struct ccnl_buf_s *buf; int dataoffset; struct ccnl_content_s *c; relay = char2relay(node); if (!relay) return; sprintf(tmp, "%s/.%d", name, seqn); DEBUGMSG(VERBOSE, " %s\n", tmp); // p = ccnl_path_to_prefix(tmp); // p->suite = suite; p = ccnl_URItoPrefix(tmp, theSuite, NULL, NULL); DEBUGMSG(VERBOSE, " %s\n", ccnl_prefix_to_path(p)); buf = ccnl_mkSimpleContent(p, data, len, &dataoffset); c = ccnl_content_new(relay, theSuite, &buf, &p, NULL, buf->data + dataoffset, len); if (c) ccnl_content_add2cache(relay, c); return; }
int _ccnl_content(int argc, char **argv) { char *body = (char*) _default_content; int arg_len = strlen(_default_content) + 1; int offs = CCNL_MAX_PACKET_SIZE; if (argc < 2) { _content_usage(argv[0]); return -1; } if (argc > 2) { char buf[BUF_SIZE]; memset(buf, ' ', BUF_SIZE); char *buf_ptr = buf; for (int i = 2; (i < argc) && (buf_ptr < (buf + BUF_SIZE)); i++) { arg_len = strlen(argv[i]); if ((buf_ptr + arg_len) > (buf + BUF_SIZE)) { arg_len = (buf + BUF_SIZE) - buf_ptr; } strncpy(buf_ptr, argv[i], arg_len); buf_ptr += arg_len + 1; } *buf_ptr = '\0'; body = buf; arg_len = strlen(body); } int suite = CCNL_SUITE_NDNTLV; struct ccnl_prefix_s *prefix = ccnl_URItoPrefix(argv[1], suite, NULL, NULL); arg_len = ccnl_ndntlv_prependContent(prefix, (unsigned char*) body, arg_len, NULL, NULL, &offs, _out); unsigned char *olddata; unsigned char *data = olddata = _out + offs; int len; unsigned typ; if (ccnl_ndntlv_dehead(&data, &arg_len, (int*) &typ, &len) || typ != NDN_TLV_Data) { return -1; } struct ccnl_content_s *c = 0; struct ccnl_pkt_s *pk = ccnl_ndntlv_bytes2pkt(typ, olddata, &data, &arg_len); c = ccnl_content_new(&ccnl_relay, &pk); /* Remove the following line later */ ccnl_relay.max_cache_entries = 10; ccnl_content_add2cache(&ccnl_relay, c); c->flags |= CCNL_CONTENT_FLAGS_STATIC; return 0; }
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_mgmt_crypto(struct ccnl_relay_s *ccnl, char *type, unsigned char *buf, int buflen) { struct ccnl_face_s *from; DEBUGMSG(DEBUG,"ccnl_crypto type: %s\n", type); if(!strcmp(type, "verify")){ int seqnum = 0; int verified = ccnl_crypto_extract_verify_reply(&buf, &buflen, &seqnum); unsigned char *msg, *msg2; char cmd[500]; int len = ccnl_crypto_extract_msg(&buf, &buflen, &msg), len2 = 0; struct ccnl_face_s *from; //DEBUGMSG(DEBUG,"VERIFIED: %d, MSG_LEN: %d\n", verified, len); int scope=3, aok=3, minsfx=0, maxsfx=CCNL_MAX_NAME_COMP, contlen; struct ccnl_buf_s *buf1 = 0, *nonce=0, *ppkd=0; struct ccnl_prefix_s *p = 0; struct ccnl_buf_s *msg2_buf; unsigned char *content = 0; msg2 = (char *) ccnl_malloc(sizeof(char) * len + 200); len2 = ccnl_ccnb_mkHeader(msg2,CCN_DTAG_NAME, CCN_TT_DTAG); memcpy(msg2+len2, msg, len); len2 +=len; msg2[len2++] = 0; from = ccnl->faces; while(from){ if(from->faceid == seqnum) break; from = from->next; } buf1 = ccnl_ccnb_extract(&msg2, &len2, &scope, &aok, &minsfx, &maxsfx, &p, &nonce, &ppkd, &content, &contlen); if (p->complen[2] < sizeof(cmd)) { memcpy(cmd, p->comp[2], p->complen[2]); cmd[p->complen[2]] = '\0'; } else strcpy(cmd, "cmd-is-too-long-to-display"); msg2_buf = ccnl_buf_new((char *)msg2, len2); ccnl_mgmt_handle(ccnl, msg2_buf, p, from, cmd, verified); ccnl_free(msg2_buf); }else if(!strcmp(type, "sign")){ char *sig = (char *) ccnl_malloc(sizeof(char)* CCNL_MAX_PACKET_SIZE); unsigned char *out; unsigned char *msg; int siglen = 0, seqnum = 0, len, len1; struct ccnl_buf_s *retbuf; ccnl_crypto_extract_sign_reply(&buf, &buflen, sig, &siglen, &seqnum); len = ccnl_crypto_extract_msg(&buf, &buflen, &msg); out = (char *) ccnl_malloc(sizeof(unsigned char)*len + sizeof(unsigned char)*siglen + 4096); len1 = ccnl_ccnb_mkHeader(out, CCN_DTAG_CONTENTOBJ, CCN_TT_DTAG); // content if(siglen > 0) len1 += ccnl_crypto_add_signature(out+len1, sig, siglen); memcpy(out+len1, msg, len); len1 +=len; out[len1++] = 0; // end-of-interest from = ccnl->faces; while(from){ if(from->faceid == seqnum) break; from = from->next; } retbuf = ccnl_buf_new((char *)out, len1); if(seqnum >= 0){ ccnl_face_enqueue(ccnl, from, retbuf); }else{ struct ccnl_prefix_s *prefix_a = 0; struct ccnl_content_s *c = 0; struct ccnl_buf_s *nonce=0, *ppkd=0, *pkt = 0; unsigned char *content = 0; char *ht = (char *) ccnl_malloc(sizeof(char)*20); int contlen; pkt = ccnl_ccnb_extract(&out, &len1, 0, 0, 0, 0, &prefix_a, &nonce, &ppkd, &content, &contlen); if (!pkt) { DEBUGMSG(WARNING, " parsing error\n"); goto Done; } if (prefix_a) { //DEBUGMSG(DEBUG, "%s", prefix_a->comp); //ccnl_free(prefix_a); } //prefix_a = (struct ccnl_prefix_s *)ccnl_malloc(sizeof(struct ccnl_prefix_s)); prefix_a->compcnt = 2; prefix_a->comp = (unsigned char **) ccnl_malloc(sizeof(unsigned char*)*2); prefix_a->comp[0] = "mgmt"; sprintf(ht, "seqnum-%d", -seqnum); prefix_a->comp[1] = ht; prefix_a->complen = (int *) ccnl_malloc(sizeof(int)*2); prefix_a->complen[0] = strlen("mgmt"); prefix_a->complen[1] = strlen(ht); c = ccnl_content_new(ccnl, CCNL_SUITE_CCNB, &pkt, &prefix_a, &ppkd, content, contlen); if (!c) goto Done; ccnl_content_serve_pending(ccnl, c); ccnl_content_add2cache(ccnl, c); } Done: ccnl_free(out); } return 0; }
int ccnl_ccnb_forwarder(struct ccnl_relay_s *relay, struct ccnl_face_s *from, unsigned char **data, int *datalen) { int rc= -1, scope=3, aok=3, minsfx=0, maxsfx=CCNL_MAX_NAME_COMP, contlen; struct ccnl_buf_s *buf = 0, *nonce=0, *ppkd=0; struct ccnl_interest_s *i = 0; struct ccnl_content_s *c = 0; struct ccnl_prefix_s *p = 0; unsigned char *content = 0; DEBUGMSG(99, "ccnl/ccnb forwarder (%d bytes left)\n", *datalen); buf = ccnl_ccnb_extract(data, datalen, &scope, &aok, &minsfx, &maxsfx, &p, &nonce, &ppkd, &content, &contlen); if (!buf) { DEBUGMSG(6, " parsing error or no prefix\n"); goto Done; } if (nonce && ccnl_nonce_find_or_append(relay, nonce)) { DEBUGMSG(6, " dropped because of duplicate nonce\n"); goto Skip; } if (buf->data[0] == 0x01 && buf->data[1] == 0xd2) { // interest DEBUGMSG(6, " interest=<%s>\n", ccnl_prefix_to_path(p)); ccnl_print_stats(relay, STAT_RCV_I); //log count recv_interest if (p->compcnt > 0 && p->comp[0][0] == (unsigned char) 0xc1) goto Skip; if (p->compcnt == 4 && !memcmp(p->comp[0], "ccnx", 4)) { rc = ccnl_mgmt(relay, buf, p, from); goto Done; } // CONFORM: Step 1: if ( aok & 0x01 ) { // honor "answer-from-existing-content-store" flag for (c = relay->contents; c; c = c->next) { if (c->suite != CCNL_SUITE_CCNB) continue; if (!ccnl_i_prefixof_c(p, minsfx, maxsfx, c)) continue; if (ppkd && !buf_equal(ppkd, c->details.ccnb.ppkd)) continue; // FIXME: should check stale bit in aok here DEBUGMSG(7, " matching content for interest, content %p\n", (void *) c); ccnl_print_stats(relay, STAT_SND_C); //log sent_c if (from->ifndx >= 0) ccnl_face_enqueue(relay, from, buf_dup(c->pkt)); else ccnl_app_RX(relay, c); goto Skip; } } // CONFORM: Step 2: check whether interest is already known for (i = relay->pit; i; i = i->next) { if (i->suite == CCNL_SUITE_CCNB && !ccnl_prefix_cmp(i->prefix, NULL, p, CMP_EXACT) && i->details.ccnb.minsuffix == minsfx && i->details.ccnb.maxsuffix == maxsfx && ((!ppkd && !i->details.ccnb.ppkd) || buf_equal(ppkd, i->details.ccnb.ppkd)) ) break; } if (!i) { // this is a new/unknown I request: create and propagate i = ccnl_interest_new(relay, from, CCNL_SUITE_CCNB, &buf, &p, minsfx, maxsfx); if (ppkd) i->details.ccnb.ppkd = ppkd, ppkd = NULL; if (i) { // CONFORM: Step 3 (and 4) DEBUGMSG(7, " created new interest entry %p\n", (void *) i); if (scope > 2) ccnl_interest_propagate(relay, i); } } else if (scope > 2 && (from->flags & CCNL_FACE_FLAGS_FWDALLI)) { DEBUGMSG(7, " old interest, nevertheless propagated %p\n", (void *) i); ccnl_interest_propagate(relay, i); } if (i) { // store the I request, for the incoming face (Step 3) DEBUGMSG(7, " appending interest entry %p\n", (void *) i); ccnl_interest_append_pending(i, from); } } else { // content DEBUGMSG(6, " content=<%s>\n", ccnl_prefix_to_path(p)); ccnl_print_stats(relay, STAT_RCV_C); //log count recv_content #ifdef USE_SIGNATURES if (p->compcnt == 2 && !memcmp(p->comp[0], "ccnx", 4) && !memcmp(p->comp[1], "crypto", 6) && from == relay->crypto_face) { rc = ccnl_crypto(relay, buf, p, from); goto Done; } #endif /*USE_SIGNATURES*/ // CONFORM: Step 1: for (c = relay->contents; c; c = c->next) if (buf_equal(c->pkt, buf)) goto Skip; // content is dup c = ccnl_content_new(relay, CCNL_SUITE_CCNB, &buf, &p, &ppkd, content, contlen); if (c) { // CONFORM: Step 2 (and 3) if (!ccnl_content_serve_pending(relay, c)) { // unsolicited content // CONFORM: "A node MUST NOT forward unsolicited data [...]" DEBUGMSG(7, " removed because no matching interest\n"); free_content(c); goto Skip; } if (relay->max_cache_entries != 0) { // it's set to -1 or a limit DEBUGMSG(7, " adding content to cache\n"); ccnl_content_add2cache(relay, c); } else { DEBUGMSG(7, " content not added to cache\n"); free_content(c); } } } Skip: rc = 0; Done: free_prefix(p); free_3ptr_list(buf, nonce, ppkd); return rc; }
void ccnl_populate_cache(struct ccnl_relay_s *ccnl, char *path) { DIR *dir; struct dirent *de; int datalen; DEBUGMSG(99, "ccnl_populate_cache %s\n", path); dir = opendir(path); if (!dir) return; while ((de = readdir(dir))) { if (!fnmatch("*.ccnb", de->d_name, FNM_NOESCAPE)) { char fname[1000]; struct stat s; strcpy(fname, path); strcat(fname, "/"); strcat(fname, de->d_name); if (stat(fname, &s)) { perror("stat"); } else { struct ccnl_buf_s *buf = 0; int fd; DEBUGMSG(6, "loading file %s, %d bytes\n", de->d_name, (int) s.st_size); fd = open(fname, O_RDONLY); if (!fd) { perror("open"); continue; } buf = (struct ccnl_buf_s *) ccnl_malloc(sizeof(*buf) + s.st_size); datalen = read(fd, buf->data, s.st_size); close(fd); if (datalen == s.st_size && datalen >= 2 && buf->data[0] == 0x04 && buf->data[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->data + 2; int contlen; buf->datalen = datalen; 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; } c = ccnl_content_new(ccnl, &pkt, &prefix, &ppkd, content, contlen); if (!c) goto Done; ccnl_content_add2cache(ccnl, c); c->flags |= CCNL_CONTENT_FLAGS_STATIC; Done: free_prefix(prefix); ccnl_free(buf); ccnl_free(pkt); ccnl_free(nonce); ccnl_free(ppkd); } else { DEBUGMSG(6, " not a content object\n"); ccnl_free(buf); } } } } }
int ccnl_core_RX_i_or_c(struct ccnl_relay_s *relay, struct ccnl_face_s *from, unsigned char **data, int *datalen) { int rc = -1, scope = 3, aok = 3, minsfx = 0, maxsfx = CCNL_MAX_NAME_COMP, contlen; struct ccnl_buf_s *buf = 0, *nonce = 0, *ppkd = 0; struct ccnl_interest_s *i = 0; struct ccnl_content_s *c = 0; struct ccnl_prefix_s *p = 0; unsigned char *content = 0; DEBUGMSG(1, "ccnl_core_RX_i_or_c: (%d bytes left)\n", *datalen); buf = ccnl_extract_prefix_nonce_ppkd(data, datalen, &scope, &aok, &minsfx, &maxsfx, &p, &nonce, &ppkd, &content, &contlen); if (!buf) { DEBUGMSG(6, " parsing error or no prefix\n"); goto Done; } if (nonce && ccnl_nonce_find_or_append(relay, nonce)) { DEBUGMSG(6, " dropped because of duplicate nonce\n"); goto Skip; } if (buf->data[0] == 0x01 && buf->data[1] == 0xd2) { // interest DEBUGMSG(1, "ccnl_core_RX_i_or_c: interest=<%s>\n", ccnl_prefix_to_path(p)); from->stat.received_interest++; if (p->compcnt > 0 && p->comp[0][0] == (unsigned char) 0xc1) { goto Skip; } if (p->compcnt == 4 && !memcmp(p->comp[0], "ccnx", 4)) { DEBUGMSG(1, "it's a mgnt msg!\n"); rc = ccnl_mgmt(relay, buf, p, from); DEBUGMSG(1, "mgnt processing done!\n"); goto Done; } // CONFORM: Step 1: if (aok & 0x01) { // honor "answer-from-existing-content-store" flag for (c = relay->contents; c; c = c->next) { if (!ccnl_i_prefixof_c(p, ppkd, minsfx, maxsfx, c)) { continue; } // FIXME: should check stale bit in aok here DEBUGMSG(7, " matching content for interest, content %p\n", (void *) c); from->stat.send_content[c->served_cnt % CCNL_MAX_CONTENT_SERVED_STAT]++; c->served_cnt++; if (from->ifndx >= 0) { ccnl_face_enqueue(relay, from, buf_dup(c->pkt)); } goto Skip; } } // CONFORM: Step 2: check whether interest is already known for (i = relay->pit; i; i = i->next) { if (!ccnl_prefix_cmp(i->prefix, NULL, p, CMP_EXACT) && i->minsuffix == minsfx && i->maxsuffix == maxsfx && ((!ppkd && !i->ppkd) || buf_equal(ppkd, i->ppkd))) { break; } } if (!i) { // this is a new/unknown I request: create and propagate i = ccnl_interest_new(relay, from, &buf, &p, minsfx, maxsfx, &ppkd); if (i) { // CONFORM: Step 3 (and 4) DEBUGMSG(7, " created new interest entry %p\n", (void *) i); if (scope > 2) { ccnl_interest_propagate(relay, i); } } } else if (scope > 2 && (from->flags & CCNL_FACE_FLAGS_FWDALLI)) { DEBUGMSG(7, " old interest, nevertheless propagated %p\n", (void *) i); ccnl_interest_propagate(relay, i); } if (i) { // store the I request, for the incoming face (Step 3) DEBUGMSG(7, " appending interest entry %p\n", (void *) i); ccnl_interest_append_pending(i, from); } } else { // content DEBUGMSG(6, " content=<%s>\n", ccnl_prefix_to_path(p)); from->stat.received_content++; // CONFORM: Step 1: for (c = relay->contents; c; c = c->next) { if (buf_equal(c->pkt, buf)) { DEBUGMSG(1, "content is dup: skip\n"); goto Skip; } } c = ccnl_content_new(relay, &buf, &p, &ppkd, content, contlen); if (c) { // CONFORM: Step 2 (and 3) if (!ccnl_content_serve_pending(relay, c, from)) { // unsolicited content // CONFORM: "A node MUST NOT forward unsolicited data [...]" DEBUGMSG(7, " removed because no matching interest\n"); free_content(c); goto Skip; } #if CCNL_DYNAMIC_FIB else { /* content has matched an interest, we consider this name as available on this face */ ccnl_content_learn_name_route(relay, c->name, from, relay->fib_threshold_prefix, 0); } #endif if (relay->max_cache_entries != 0) { // it's set to -1 or a limit DEBUGMSG(7, " adding content to cache\n"); ccnl_content_add2cache(relay, c); } else { DEBUGMSG(7, " content not added to cache\n"); free_content(c); } } } Skip: rc = 0; Done: free_prefix(p); free_3ptr_list(buf, nonce, ppkd); DEBUGMSG(1, "leaving\n"); return rc; }
void ccnl_populate_cache(struct ccnl_relay_s *ccnl, char *path, int suite) { DIR *dir; struct dirent *de; int datalen; char *suffix; DEBUGMSG(99, "ccnl_populate_cache %s\n", path); switch (suite) { #ifdef USE_SUITE_CCNB case CCNL_SUITE_CCNB: suffix = "*.ccnb"; break; #endif #ifdef USE_SUITE_NDNTLV case CCNL_SUITE_NDNTLV: suffix = "*.ndntlv"; break; #endif default: fprintf(stderr, "unknown suite and encoding, cannot populate cache.\n"); return; } dir = opendir(path); if (!dir) return; while ((de = readdir(dir))) { if (!fnmatch(suffix, de->d_name, FNM_NOESCAPE)) { char fname[1000]; struct stat s; strcpy(fname, path); strcat(fname, "/"); strcat(fname, de->d_name); if (stat(fname, &s)) { perror("stat"); } else { struct ccnl_buf_s *buf = 0; int fd; DEBUGMSG(6, "loading file %s, %d bytes\n", de->d_name, (int) s.st_size); fd = open(fname, O_RDONLY); if (!fd) { perror("open"); continue; } buf = (struct ccnl_buf_s *) ccnl_malloc(sizeof(*buf) + s.st_size); datalen = read(fd, buf->data, s.st_size); close(fd); if (datalen == s.st_size && datalen >= 2) { 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; int contlen, typ, len; buf->datalen = datalen; switch (suite) { #ifdef USE_SUITE_CCNB case CCNL_SUITE_CCNB: if (buf->data[0] != 0x04 || buf->data[1] != 0x82) goto notacontent; data = buf->data + 2; datalen -= 2; pkt = ccnl_ccnb_extract(&data, &datalen, 0, 0, 0, 0, &prefix, &nonce, &ppkd, &content, &contlen); break; #endif #ifdef USE_SUITE_NDNTLV case CCNL_SUITE_NDNTLV: data = buf->data; if (ccnl_ndntlv_dehead(&data, &datalen, &typ, &len) || typ != NDN_TLV_Data) goto notacontent; pkt = ccnl_ndntlv_extract(data - buf->data, &data, &datalen, 0, 0, 0, 0, &prefix, &nonce, &ppkd, &content, &contlen); break; #endif default: goto Done; } if (!pkt) { DEBUGMSG(6, " parsing error\n"); goto Done; } if (!prefix) { DEBUGMSG(6, " no prefix error\n"); goto Done; } c = ccnl_content_new(ccnl, suite, &pkt, &prefix, &ppkd, content, contlen); if (!c) goto Done; ccnl_content_add2cache(ccnl, c); c->flags |= CCNL_CONTENT_FLAGS_STATIC; Done: free_prefix(prefix); ccnl_free(buf); ccnl_free(pkt); ccnl_free(nonce); ccnl_free(ppkd); } else { notacontent: DEBUGMSG(6, " not a content object\n"); ccnl_free(buf); } } } } }
void ccnl_populate_cache(struct ccnl_relay_s *ccnl, char *path) { DIR *dir; struct dirent *de; dir = opendir(path); if (!dir) { DEBUGMSG(ERROR, "could not open directory %s\n", path); return; } DEBUGMSG(INFO, "populating cache from directory %s\n", path); while ((de = readdir(dir))) { char fname[1000]; struct stat s; struct ccnl_buf_s *buf = 0; // , *nonce=0, *ppkd=0, *pkt = 0; struct ccnl_content_s *c = 0; int fd, datalen, suite, skip; unsigned char *data; (void) data; // silence compiler warning (if any USE_SUITE_* is not set) #if defined(USE_SUITE_IOTTLV) || defined(USE_SUITE_NDNTLV) unsigned int typ; int len; #endif struct ccnl_pkt_s *pk; if (de->d_name[0] == '.') continue; strcpy(fname, path); strcat(fname, "/"); strcat(fname, de->d_name); if (stat(fname, &s)) { perror("stat"); continue; } if (S_ISDIR(s.st_mode)) continue; DEBUGMSG(INFO, "loading file %s, %d bytes\n", de->d_name, (int) s.st_size); fd = open(fname, O_RDONLY); if (!fd) { perror("open"); continue; } buf = (struct ccnl_buf_s *) ccnl_malloc(sizeof(*buf) + s.st_size); if (buf) datalen = read(fd, buf->data, s.st_size); else datalen = -1; close(fd); if (!buf || datalen != s.st_size || datalen < 2) { DEBUGMSG(WARNING, "size mismatch for file %s, %d/%d bytes\n", de->d_name, datalen, (int) s.st_size); continue; } buf->datalen = datalen; suite = ccnl_pkt2suite(buf->data, datalen, &skip); pk = NULL; switch (suite) { #ifdef USE_SUITE_CCNB case CCNL_SUITE_CCNB: { unsigned char *start; data = start = buf->data + skip; datalen -= skip; if (data[0] != 0x04 || data[1] != 0x82) goto notacontent; data += 2; datalen -= 2; pk = ccnl_ccnb_bytes2pkt(start, &data, &datalen); break; } #endif #ifdef USE_SUITE_CCNTLV case CCNL_SUITE_CCNTLV: { int hdrlen; unsigned char *start; data = start = buf->data + skip; datalen -= skip; hdrlen = ccnl_ccntlv_getHdrLen(data, datalen); data += hdrlen; datalen -= hdrlen; pk = ccnl_ccntlv_bytes2pkt(start, &data, &datalen); break; } #endif #ifdef USE_SUITE_CISTLV case CCNL_SUITE_CISTLV: { int hdrlen; unsigned char *start; data = start = buf->data + skip; datalen -= skip; hdrlen = ccnl_cistlv_getHdrLen(data, datalen); data += hdrlen; datalen -= hdrlen; pk = ccnl_cistlv_bytes2pkt(start, &data, &datalen); break; } #endif #ifdef USE_SUITE_IOTTLV case CCNL_SUITE_IOTTLV: { unsigned char *olddata; data = olddata = buf->data + skip; datalen -= skip; if (ccnl_iottlv_dehead(&data, &datalen, &typ, &len) || typ != IOT_TLV_Reply) goto notacontent; pk = ccnl_iottlv_bytes2pkt(typ, olddata, &data, &datalen); break; } #endif #ifdef USE_SUITE_NDNTLV case CCNL_SUITE_NDNTLV: { unsigned char *olddata; data = olddata = buf->data + skip; datalen -= skip; if (ccnl_ndntlv_dehead(&data, &datalen, (int*) &typ, &len) || typ != NDN_TLV_Data) goto notacontent; pk = ccnl_ndntlv_bytes2pkt(typ, olddata, &data, &datalen); break; } #endif default: DEBUGMSG(WARNING, "unknown packet format (%s)\n", de->d_name); goto Done; } if (!pk) { DEBUGMSG(DEBUG, " parsing error in %s\n", de->d_name); goto Done; } c = ccnl_content_new(ccnl, &pk); if (!c) { DEBUGMSG(WARNING, "could not create content (%s)\n", de->d_name); goto Done; } ccnl_content_add2cache(ccnl, c); c->flags |= CCNL_CONTENT_FLAGS_STATIC; Done: free_packet(pk); ccnl_free(buf); continue; #if defined(USE_SUITE_CCNB) || defined(USE_SUITE_IOTTLV) || defined(USE_SUITE_NDNTLV) notacontent: DEBUGMSG(WARNING, "not a content object (%s)\n", de->d_name); ccnl_free(buf); #endif } closedir(dir); }