/** * Use standard mkdtemp() to create a subdirectory of the * current working directory, and set the TEST_DIRECTORY environment * variable with its name. */ static int test_directory_creation(void) { int res; struct ccn_charbuf *dirbuf; char *temp; dirbuf = ccn_charbuf_create(); CHKPTR(dirbuf); res = ccn_charbuf_putf(dirbuf, "./%s", "_bt_XXXXXX"); CHKSYS(res); temp = mkdtemp(ccn_charbuf_as_string(dirbuf)); CHKPTR(temp); res = ccn_charbuf_putf(dirbuf, "/%s", "_test"); CHKSYS(res); res = mkdir(ccn_charbuf_as_string(dirbuf), 0777); CHKSYS(res); printf("Created directory %s\n", ccn_charbuf_as_string(dirbuf)); setenv("TEST_DIRECTORY", ccn_charbuf_as_string(dirbuf), 1); ccn_charbuf_destroy(&dirbuf); return(res); }
static void collect_meter_xml(struct ccnd_handle *h, struct ccn_charbuf *b, struct ccnd_meter *m) { uintmax_t total; unsigned rate; if (m == NULL) return; total = ccnd_meter_total(m); rate = ccnd_meter_rate(h, m); ccn_charbuf_putf(b, "<%s><total>%ju</total><persec>%u</persec></%s>", m->what, total, rate, m->what); }
static void init_all_chars_mixed_encoded(void) { struct ccn_charbuf *c; int i; c = ccn_charbuf_create(); ccn_charbuf_append(c, "=", 1); for (i = 0; i < 256; i+=2) { ccn_charbuf_putf(c, "%02x%02X", i, i+1); } if (c->length >= sizeof(all_chars_mixed_encoded)) c->length = sizeof(all_chars_mixed_encoded) - 1; memcpy(all_chars_mixed_encoded, c->buf, c->length); ccn_charbuf_destroy(&c); }
/** * Read the contents of the repository config file * * Calls r_init_fail and returns NULL in case of error. * @returns unparsed content of config file in a newly allocated charbuf */ struct ccn_charbuf * r_init_read_config(struct ccnr_handle *h) { struct ccn_charbuf *path = NULL; struct ccn_charbuf *contents = NULL; size_t sz = 800; ssize_t sres = -1; int fd; h->directory = getenv("CCNR_DIRECTORY"); if (h->directory == NULL || h->directory[0] == 0) h->directory = "."; path = ccn_charbuf_create(); contents = ccn_charbuf_create(); if (path == NULL || contents == NULL) return(NULL); ccn_charbuf_putf(path, "%s/config", h->directory); fd = open(ccn_charbuf_as_string(path), O_RDONLY); if (fd == -1) { if (errno == ENOENT) sres = 0; else r_init_fail(h, __LINE__, ccn_charbuf_as_string(path), errno); } else { for (;;) { sres = read(fd, ccn_charbuf_reserve(contents, sz), sz); if (sres == 0) break; if (sres < 0) { r_init_fail(h, __LINE__, "Read failed reading config", errno); break; } contents->length += sres; if (contents->length > 999999) { r_init_fail(h, __LINE__, "config file too large", 0); sres = -1; break; } } close(fd); } ccn_charbuf_destroy(&path); if (sres < 0) ccn_charbuf_destroy(&contents); return(contents); }
static void collect_forwarding_html(struct ccnd_handle *h, struct ccn_charbuf *b) { struct hashtb_enumerator ee; struct hashtb_enumerator *e = ⅇ struct ccn_forwarding *f; int res; struct ccn_charbuf *name = ccn_charbuf_create(); ccn_charbuf_putf(b, "<h4>Forwarding</h4>" NL); ccn_charbuf_putf(b, "<ul>"); hashtb_start(h->nameprefix_tab, e); for (; e->data != NULL; hashtb_next(e)) { struct nameprefix_entry *ipe = e->data; ccn_name_init(name); res = ccn_name_append_components(name, e->key, 0, e->keysize); if (res < 0) abort(); if (0) { ccn_charbuf_putf(b, " <li>"); ccn_uri_append(b, name->buf, name->length, 1); ccn_charbuf_putf(b, "</li>" NL); } for (f = ipe->forwarding; f != NULL; f = f->next) { if ((f->flags & (CCN_FORW_ACTIVE | CCN_FORW_PFXO)) != 0) { ccn_name_init(name); ccn_name_append_components(name, e->key, 0, e->keysize); ccn_charbuf_putf(b, " <li>"); ccn_uri_append(b, name->buf, name->length, 1); ccn_charbuf_putf(b, " <b>face:</b> %u" " <b>flags:</b> 0x%x" " <b>expires:</b> %d", f->faceid, f->flags & CCN_FORW_PUBMASK, f->expires); ccn_charbuf_putf(b, "</li>" NL); } } } hashtb_end(e); ccn_charbuf_destroy(&name); ccn_charbuf_putf(b, "</ul>"); }
static void init_cached_keystore() { ccn_keystore *keystore = cached_keystore; int res; if (keystore == NULL) { ccn_charbuf *temp = ccn_charbuf_create(); keystore = ccn_keystore_create(); ccn_charbuf_putf(temp, "%s/.ccnx/.ccnx_keystore", getenv("HOME")); res = ccn_keystore_init(keystore, ccn_charbuf_as_string(temp), (char *)"Th1s1sn0t8g00dp8ssw0rd."); if (res != 0) { printf("Failed to initialize keystore %s\n", ccn_charbuf_as_string(temp)); exit(1); } ccn_charbuf_destroy(&temp); cached_keystore = keystore; } }
static void collect_forwarding_xml(struct ccnd_handle *h, struct ccn_charbuf *b) { struct hashtb_enumerator ee; struct hashtb_enumerator *e = ⅇ struct ccn_forwarding *f; int res; struct ccn_charbuf *name = ccn_charbuf_create(); ccn_charbuf_putf(b, "<forwarding>"); hashtb_start(h->nameprefix_tab, e); for (; e->data != NULL; hashtb_next(e)) { struct nameprefix_entry *ipe = e->data; for (f = ipe->forwarding, res = 0; f != NULL && !res; f = f->next) { if ((f->flags & (CCN_FORW_ACTIVE | CCN_FORW_PFXO)) != 0) res = 1; } if (res) { ccn_name_init(name); ccn_name_append_components(name, e->key, 0, e->keysize); ccn_charbuf_putf(b, "<fentry>"); ccn_charbuf_putf(b, "<prefix>"); ccn_uri_append(b, name->buf, name->length, 1); ccn_charbuf_putf(b, "</prefix>"); for (f = ipe->forwarding; f != NULL; f = f->next) { if ((f->flags & (CCN_FORW_ACTIVE | CCN_FORW_PFXO)) != 0) { ccn_charbuf_putf(b, "<dest>" "<faceid>%u</faceid>" "<flags>%x</flags>" "<expires>%d</expires>" "</dest>", f->faceid, f->flags & CCN_FORW_PUBMASK, f->expires); } } ccn_charbuf_putf(b, "</fentry>"); } } hashtb_end(e); ccn_charbuf_destroy(&name); ccn_charbuf_putf(b, "</forwarding>"); }
/** * Read the former size of repoFile1 from index/stable, and remove * the latter. */ static void r_store_read_stable_point(struct ccnr_handle *h) { struct ccn_charbuf *path = NULL; struct ccn_charbuf *cb = NULL; int fd; int i; ssize_t rres; uintmax_t val; unsigned char c; path = ccn_charbuf_create(); cb = ccn_charbuf_create(); ccn_charbuf_putf(path, "%s/index/stable", h->directory); fd = open(ccn_charbuf_as_string(path), O_RDONLY, 0666); if (fd != -1) { rres = read(fd, ccn_charbuf_reserve(cb, 80), 80); if (rres > 0) cb->length = rres; close(fd); if (CCNSHOULDLOG(h, dfsdf, CCNL_INFO)) ccnr_msg(h, "Last stable at %s", ccn_charbuf_as_string(cb)); } for (val = 0, i = 0; i < cb->length; i++) { c = cb->buf[i]; if ('0' <= c && c <= '9') val = val * 10 + (c - '0'); else break; } if (i == 0 || i < cb->length) { ccnr_msg(h, "Bad stable mark - %s", ccn_charbuf_as_string(cb)); h->stable = 0; } else { h->stable = val; unlink(ccn_charbuf_as_string(path)); } ccn_charbuf_destroy(&path); ccn_charbuf_destroy(&cb); }
void NdnMediaProcess::tick() { // send new interest for every speaker ruMutex->lock(); QHash<QString, UserDataBuf *>::const_iterator it = qhRemoteUser.constBegin(); while (it != qhRemoteUser.constEnd()) { QString userName = it.key(); UserDataBuf *udb = it.value(); if (udb != NULL && udb->seq >= 0) { udb->seq++; struct ccn_charbuf *pathbuf = ccn_charbuf_create(); ccn_name_from_uri(pathbuf, userName.toLocal8Bit().constData()); ccn_name_append_str(pathbuf, "audio"); struct ccn_charbuf *temp = ccn_charbuf_create(); ccn_charbuf_putf(temp, "%ld", udb->seq); ccn_name_append(pathbuf, temp->buf, temp->length); /* int c = 0; while (pthread_mutex_trylock(&ccn_mutex) != 0) { c++; if (c > 10000000) { fprintf(stderr, "cannot obtain lock! %s:%d\n", __FILE__, __LINE__); std::exit(1); } } */ pthread_mutex_lock(&ccn_mutex); int res = ccn_express_interest(ndnState.ccn, pathbuf, udb->data_buf.pipe_callback, NULL); pthread_mutex_unlock(&ccn_mutex); if (res < 0) { fprintf(stderr, "Sending interest failed at normal processor\n"); exit(1); } ccn_charbuf_destroy(&pathbuf); ccn_charbuf_destroy(&temp); } it++; } ruMutex->unlock(); }
PUBLIC int r_io_open_repo_data_file(struct ccnr_handle *h, const char *name, int output) { struct ccn_charbuf *temp = NULL; int fd = -1; struct fdholder *fdholder = NULL; temp = ccn_charbuf_create(); ccn_charbuf_putf(temp, "%s/%s", h->directory, name); fd = open(ccn_charbuf_as_string(temp), output ? (O_CREAT | O_WRONLY | O_APPEND) : O_RDONLY, 0666); if (fd == -1) { if (CCNSHOULDLOG(h, sdf, CCNL_FINE)) ccnr_msg(h, "open(%s): %s", ccn_charbuf_as_string(temp), strerror(errno)); ccn_charbuf_destroy(&temp); return(-1); } fdholder = r_io_record_fd(h, fd, temp->buf, temp->length, CCNR_FACE_REPODATA | (output ? CCNR_FACE_NORECV : CCNR_FACE_NOSEND)); if (fdholder == NULL) close_fd(&fd); else { if (!output) { /* Use a larger buffer for indexing an existing repo file */ if (fdholder->inbuf == NULL) { fdholder->inbuf = ccn_charbuf_create(); fdholder->bufoffset = 0; } if (fdholder->inbuf != NULL) ccn_charbuf_reserve(fdholder->inbuf, 256 * 1024); } if (CCNSHOULDLOG(h, sdf, CCNL_INFO)) ccnr_msg(h, "opened fd=%d file=%s", fd, ccn_charbuf_as_string(temp)); } ccn_charbuf_destroy(&temp); return(fd); }
static void collect_faces_xml(struct ccnd_handle *h, struct ccn_charbuf *b) { int i; int m; int port; struct ccn_charbuf *nodebuf; nodebuf = ccn_charbuf_create(); ccn_charbuf_putf(b, "<faces>"); for (i = 0; i < h->face_limit; i++) { struct face *face = h->faces_by_faceid[i]; if (face != NULL && (face->flags & CCN_FACE_UNDECIDED) == 0) { ccn_charbuf_putf(b, "<face>"); ccn_charbuf_putf(b, "<faceid>%u</faceid>" "<faceflags>%04x</faceflags>", face->faceid, face->flags); ccn_charbuf_putf(b, "<pending>%d</pending>", face->pending_interests); ccn_charbuf_putf(b, "<recvcount>%d</recvcount>", face->recvcount); nodebuf->length = 0; port = ccn_charbuf_append_sockaddr(nodebuf, face->addr); if (port > 0) { const char *node = ccn_charbuf_as_string(nodebuf); ccn_charbuf_putf(b, "<ip>%s:%d</ip>", node, port); } if (face->sendface != face->faceid && face->sendface != CCN_NOFACEID) ccn_charbuf_putf(b, "<via>%u</via>", face->sendface); if (face != NULL && (face->flags & CCN_FACE_PASSIVE) == 0) { ccn_charbuf_putf(b, "<meters>"); for (m = 0; m < CCND_FACE_METER_N; m++) collect_meter_xml(h, b, face->meter[m]); ccn_charbuf_putf(b, "</meters>"); } ccn_charbuf_putf(b, "</face>" NL); } } ccn_charbuf_putf(b, "</faces>"); ccn_charbuf_destroy(&nodebuf); }
enum ccn_upcall_res ccn_text_handler(struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { UserDataBuf *userBuf = (UserDataBuf *)selfp->data; if (userBuf == NULL || userBuf->iNeedDestroy) { //if (userBuf != NULL) delete userBuf; //selfp->data = NULL; return CCN_UPCALL_RESULT_OK; } switch (kind) { case CCN_UPCALL_INTEREST_TIMED_OUT: { // if it's short Interest without seq, reexpress // TODO: check whether the user is still in the conference // don't re-express if it is not return (CCN_UPCALL_RESULT_REEXPRESS); } case CCN_UPCALL_CONTENT_UNVERIFIED: fprintf(stderr, "unverified content received\n"); return CCN_UPCALL_RESULT_OK; case CCN_UPCALL_FINAL: return CCN_UPCALL_RESULT_OK; case CCN_UPCALL_CONTENT: break; default: return CCN_UPCALL_RESULT_OK; } struct data_buffer *buffer = &userBuf->data_buf; const unsigned char *content_value; size_t len; NDNState *state = buffer->state; const unsigned char *ccnb = info->content_ccnb; size_t ccnb_size = info->pco->offset[CCN_PCO_E]; struct ccn_indexbuf *comps = info->content_comps; ccn_content_get_value(ccnb, ccnb_size, info->pco, &content_value, &len); unsigned char *msg = (unsigned char *)calloc((len + 1), sizeof(char)); memcpy(msg, content_value, len); msg[len] = '\0'; QString textMsg = (const char *)msg; state->emitTextMsgArrival(userBuf->user_name, textMsg); free(msg); long seq; const unsigned char *seqptr = NULL; char *endptr = NULL; size_t seq_size = 0; int k = comps->n - 2; seq = ccn_ref_tagged_BLOB(CCN_DTAG_Component, ccnb, comps->buf[k], comps->buf[k + 1], &seqptr, &seq_size); if (seq >= 0) { seq = strtol((const char *)seqptr, &endptr, 10); if (endptr != ((const char *)seqptr) + seq_size) seq = -1; } if (seq < 0) { return CCN_UPCALL_RESULT_OK; } seq++; struct ccn_charbuf *path = ccn_charbuf_create(); ccn_name_init(path); ccn_name_append_components(path, ccnb, comps->buf[0], comps->buf[k]); struct ccn_charbuf *temp = ccn_charbuf_create(); ccn_charbuf_putf(temp, "%ld", seq); ccn_name_append(path, temp->buf, temp->length); int res = ccn_express_interest(info->h, path, selfp, NULL); if (res < 0) { fprintf(stderr, "sending the first interest failed\n"); exit(1); } ccn_charbuf_destroy(&path); ccn_charbuf_destroy(&temp); return CCN_UPCALL_RESULT_OK; }
static struct ccn_charbuf * collect_stats_html(struct ccnd_handle *h) { struct ccnd_stats stats = {0}; struct ccn_charbuf *b = ccn_charbuf_create(); int pid; struct utsname un; const char *portstr; portstr = getenv(CCN_LOCAL_PORT_ENVNAME); if (portstr == NULL || portstr[0] == 0 || strlen(portstr) > 10) portstr = CCN_DEFAULT_UNICAST_PORT; uname(&un); pid = getpid(); ccnd_collect_stats(h, &stats); ccn_charbuf_putf(b, "<html xmlns='http://www.w3.org/1999/xhtml'>" "<head>" "<title>%s ccnd[%d]</title>" //"<meta http-equiv='refresh' content='3'>" "<style type='text/css'>" "/*<![CDATA[*/" "p.header {color: white; background-color: blue; width: 100%%} " "table.tbl {border-style: solid; border-width: 1.0px 1.0px 1.0px 1.0px; border-color: black} " "td {border-style: solid; " "border-width: 1.0px 1.0px 1.0px 1.0px; " "border-color: #808080 #808080 #808080 #808080; " "padding: 6px 6px 6px 6px; " "margin-left: auto; margin-right: auto; " "text-align: center" "} " "td.left {text-align: left} " "/*]]>*/" "</style>" "</head>" NL "<body bgcolor='#%06X'>" "<p class='header'>%s ccnd[%d] local port %s api %d start %ld.%06u now %ld.%06u</p>" NL "<div><b>Content items:</b> %llu accessioned," " %d stored, %lu stale, %d sparse, %lu duplicate, %lu sent</div>" NL "<div><b>Interests:</b> %d names," " %ld pending, %ld propagating, %ld noted</div>" NL "<div><b>Interest totals:</b> %lu accepted," " %lu dropped, %lu sent, %lu stuffed</div>" NL, un.nodename, pid, ccnd_colorhash(h), un.nodename, pid, portstr, (int)CCN_API_VERSION, h->starttime, h->starttime_usec, h->sec, h->usec, (unsigned long long)h->accession, hashtb_n(h->content_tab), h->n_stale, hashtb_n(h->sparse_straggler_tab), h->content_dups_recvd, h->content_items_sent, hashtb_n(h->nameprefix_tab), stats.total_interest_counts, hashtb_n(h->interest_tab) - stats.total_flood_control, stats.total_flood_control, h->interests_accepted, h->interests_dropped, h->interests_sent, h->interests_stuffed); if (0) ccn_charbuf_putf(b, "<div><b>Active faces and listeners:</b> %d</div>" NL, hashtb_n(h->faces_by_fd) + hashtb_n(h->dgram_faces)); collect_faces_html(h, b); collect_face_meter_html(h, b); collect_forwarding_html(h, b); ccn_charbuf_putf(b, "</body>" "</html>" NL); return(b); }
static void collect_face_meter_html(struct ccnd_handle *h, struct ccn_charbuf *b) { int i; ccn_charbuf_putf(b, "<h4>Face Activity Rates</h4>"); ccn_charbuf_putf(b, "<table cellspacing='0' cellpadding='0' class='tbl' summary='face activity rates'>"); ccn_charbuf_putf(b, "<tbody>" NL); ccn_charbuf_putf(b, " <tr><td> </td>\t" " <td>Bytes/sec In/Out</td>\t" " <td>recv data/intr sent</td>\t" " <td>sent data/intr recv</td></tr>" NL); for (i = 0; i < h->face_limit; i++) { struct face *face = h->faces_by_faceid[i]; if (face != NULL && (face->flags & (CCN_FACE_UNDECIDED|CCN_FACE_PASSIVE)) == 0) { ccn_charbuf_putf(b, " <tr>"); ccn_charbuf_putf(b, "<td><b>face:</b> %u</td>\t", face->faceid); ccn_charbuf_putf(b, "<td>%6u / %u</td>\t\t", ccnd_meter_rate(h, face->meter[FM_BYTI]), ccnd_meter_rate(h, face->meter[FM_BYTO])); ccn_charbuf_putf(b, "<td>%9u / %u</td>\t\t", ccnd_meter_rate(h, face->meter[FM_DATI]), ccnd_meter_rate(h, face->meter[FM_INTO])); ccn_charbuf_putf(b, "<td>%9u / %u</td>", ccnd_meter_rate(h, face->meter[FM_DATO]), ccnd_meter_rate(h, face->meter[FM_INTI])); ccn_charbuf_putf(b, "</tr>" NL); } } ccn_charbuf_putf(b, "</tbody>"); ccn_charbuf_putf(b, "</table>"); }
static void collect_faces_html(struct ccnd_handle *h, struct ccn_charbuf *b) { int i; struct ccn_charbuf *nodebuf; int port; nodebuf = ccn_charbuf_create(); ccn_charbuf_putf(b, "<h4>Faces</h4>" NL); ccn_charbuf_putf(b, "<ul>"); for (i = 0; i < h->face_limit; i++) { struct face *face = h->faces_by_faceid[i]; if (face != NULL && (face->flags & CCN_FACE_UNDECIDED) == 0) { ccn_charbuf_putf(b, " <li>"); ccn_charbuf_putf(b, "<b>face:</b> %u <b>flags:</b> 0x%x", face->faceid, face->flags); ccn_charbuf_putf(b, " <b>pending:</b> %d", face->pending_interests); if (face->recvcount != 0) ccn_charbuf_putf(b, " <b>activity:</b> %d", face->recvcount); nodebuf->length = 0; port = ccn_charbuf_append_sockaddr(nodebuf, face->addr); if (port > 0) { const char *node = ccn_charbuf_as_string(nodebuf); int chk = CCN_FACE_MCAST | CCN_FACE_UNDECIDED | CCN_FACE_NOSEND | CCN_FACE_GG | CCN_FACE_PASSIVE; if ((face->flags & chk) == 0) ccn_charbuf_putf(b, " <b>remote:</b> " "<a href='http://%s:%s/'>" "%s:%d</a>", node, CCN_DEFAULT_UNICAST_PORT, node, port); else if ((face->flags & CCN_FACE_PASSIVE) == 0) ccn_charbuf_putf(b, " <b>remote:</b> %s:%d", node, port); else ccn_charbuf_putf(b, " <b>local:</b> %s:%d", node, port); if (face->sendface != face->faceid && face->sendface != CCN_NOFACEID) ccn_charbuf_putf(b, " <b>via:</b> %u", face->sendface); } ccn_charbuf_putf(b, "</li>" NL); } } ccn_charbuf_putf(b, "</ul>"); ccn_charbuf_destroy(&nodebuf); }
int ccnr_init_repo_keystore(struct ccnr_handle *ccnr, struct ccn *h) { struct ccn_charbuf *temp = NULL; struct ccn_charbuf *culprit = NULL; struct stat statbuf; int res = -1; char *keystore_path = NULL; struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; temp = ccn_charbuf_create(); culprit = temp; ccn_charbuf_putf(temp, "%s/", ccnr->directory); res = stat(ccn_charbuf_as_string(temp), &statbuf); if (res == -1) goto Finish; if ((statbuf.st_mode & S_IFDIR) == 0) { res = -1; errno = ENOTDIR; goto Finish; } ccn_charbuf_putf(temp, "ccnx_repository_keystore"); keystore_path = strdup(ccn_charbuf_as_string(temp)); res = stat(keystore_path, &statbuf); if (res == 0 && h != NULL) res = ccn_load_default_key(h, keystore_path, CCNR_KEYSTORE_PASS); if (res >= 0) { culprit = NULL; goto Finish; } /* No stored keystore that we can access. Create one if we can.*/ res = ccn_keystore_file_init(keystore_path, CCNR_KEYSTORE_PASS, "Repository", 0, 0); if (res != 0) { res = -1; goto Finish; } if (CCNSHOULDLOG(ccnr, keystore, CCNL_WARNING)) ccnr_msg(ccnr, "New repository private key saved in %s", keystore_path); if (h != NULL) res = ccn_load_default_key(h, keystore_path, CCNR_KEYSTORE_PASS); Finish: if (res >= 0 && h != NULL) res = ccn_chk_signing_params(h, NULL, &sp, NULL, NULL, NULL, NULL); if (res >= 0 && h != NULL) { memcpy(ccnr->ccnr_id, sp.pubid, sizeof(ccnr->ccnr_id)); if (ccnr->ccnr_keyid == NULL) ccnr->ccnr_keyid = ccn_charbuf_create(); else ccnr->ccnr_keyid->length = 0; ccn_charbuf_append_value(ccnr->ccnr_keyid, CCN_MARKER_CONTROL, 1); ccn_charbuf_append_string(ccnr->ccnr_keyid, ".M.K"); ccn_charbuf_append_value(ccnr->ccnr_keyid, 0, 1); ccn_charbuf_append(ccnr->ccnr_keyid, ccnr->ccnr_id, sizeof(ccnr->ccnr_id)); } if (res < 0) { ccnr->running = -1; /* Make note of init failure */ if (culprit != NULL) ccnr_msg(ccnr, "Error accessing keystore - %s: %s\n", strerror(errno), ccn_charbuf_as_string(temp)); } ccn_charbuf_destroy(&temp); if (keystore_path != NULL) free(keystore_path); return(res); }
int NdnMediaProcess::sendNdnText(const char *text) { #define CHARBUF_DESTROY \ ccn_charbuf_destroy(&message);\ ccn_charbuf_destroy(&path); \ ccn_charbuf_destroy(&seq); UserDataBuf *userBuf = localUdb; if (userBuf == NULL) return -1; int res = 0; int seq_num = -1; struct ccn_charbuf *message = ccn_charbuf_create(); struct ccn_charbuf *path = ccn_charbuf_create(); struct ccn_charbuf *seq = ccn_charbuf_create(); ccn_name_init(path); seq_num = textSeq++; ccn_name_from_uri(path, localUdb->user_name.toLocal8Bit().constData()); ccn_name_append_str(path, "text"); if (seq_num < 0) { res = -1; CHARBUF_DESTROY; return res; } ccn_charbuf_putf(seq, "%ld", seq_num); ccn_name_append(path, seq->buf, seq->length); struct ccn_charbuf *signed_info = ccn_charbuf_create(); if (cached_keystore == NULL) init_cached_keystore(); ccn_charbuf *keylocator = ccn_charbuf_create(); ccn_create_keylocator(keylocator, ccn_keystore_public_key(cached_keystore)); /* Create signed_info */ res = ccn_signed_info_create(signed_info, /* pubkeyid */ get_my_publisher_key_id(), /* publisher_key_id_size */ get_my_publisher_key_id_length(), /* datetime */ NULL, /* type */ CCN_CONTENT_DATA, /* freshness */ FRESHNESS, /* finalblockid */ NULL, /* keylocator */ keylocator); if (res != 0) { fprintf(stderr, "signed_info_create failed %d (line %d)\n", res, __LINE__); } res = ccn_encode_ContentObject( /* out */ message, path, signed_info, text, strlen(text), /* keyLocator */ NULL, get_my_private_key()); if (res != 0) { fprintf(stderr, "encode_ContentObject failed %d (line %d)\n", res, __LINE__); CHARBUF_DESTROY; return res; } ccn_charbuf_destroy(&signed_info); ccn_charbuf_destroy(&keylocator); pthread_mutex_lock(&ccn_mutex); res = ccn_put(ndnState.ccn, message->buf, message->length); pthread_mutex_unlock(&ccn_mutex); }
enum ccn_upcall_res incoming_content( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { struct ccn_charbuf *name = NULL; struct ccn_charbuf *templ = NULL; struct ccn_charbuf *temp = NULL; const unsigned char *ccnb = NULL; size_t ccnb_size = 0; const unsigned char *data = NULL; size_t data_size = 0; size_t written; const unsigned char *ib = NULL; /* info->interest_ccnb */ struct ccn_indexbuf *ic = NULL; int res; struct mydata *md = selfp->data; if (kind == CCN_UPCALL_FINAL) { if (md != NULL) { selfp->data = NULL; free(md); md = NULL; } return(CCN_UPCALL_RESULT_OK); } if (kind == CCN_UPCALL_INTEREST_TIMED_OUT) return(CCN_UPCALL_RESULT_REEXPRESS); if (kind != CCN_UPCALL_CONTENT && kind != CCN_UPCALL_CONTENT_UNVERIFIED) return(CCN_UPCALL_RESULT_ERR); if (md == NULL) selfp->data = md = calloc(1, sizeof(*md)); ccnb = info->content_ccnb; ccnb_size = info->pco->offset[CCN_PCO_E]; ib = info->interest_ccnb; ic = info->interest_comps; /* XXX - must verify sig, and make sure it is LEAF content */ res = ccn_content_get_value(ccnb, ccnb_size, info->pco, &data, &data_size); if (res < 0) abort(); if (data_size > CHUNK_SIZE) { /* For us this is spam. Give up now. */ fprintf(stderr, "*** Segment %d found with a data size of %d." " This program only works with segments of 1024 bytes." " Try ccncatchunks2 instead.\n", (int)selfp->intdata, (int)data_size); exit(1); } /* OK, we will accept this block. */ written = fwrite(data, data_size, 1, stdout); if (written != 1) exit(1); /* A short block signals EOF for us. */ if (data_size < CHUNK_SIZE) exit(0); /* Ask for the next one */ name = ccn_charbuf_create(); ccn_name_init(name); if (ic->n < 2) abort(); res = ccn_name_append_components(name, ib, ic->buf[0], ic->buf[ic->n - 2]); if (res < 0) abort(); temp = ccn_charbuf_create(); ccn_charbuf_putf(temp, "%d", ++(selfp->intdata)); ccn_name_append(name, temp->buf, temp->length); ccn_charbuf_destroy(&temp); templ = make_template(md, info); res = ccn_express_interest(info->h, name, selfp, templ); if (res < 0) abort(); ccn_charbuf_destroy(&templ); ccn_charbuf_destroy(&name); return(CCN_UPCALL_RESULT_OK); }
enum ccn_upcall_res incoming_content( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { struct ccn_charbuf *name = NULL; struct ccn_charbuf *templ = NULL; struct ccn_charbuf *temp = NULL; const unsigned char *ccnb = NULL; size_t ccnb_size = 0; const unsigned char *data = NULL; size_t data_size = 0; // TANG: no need to write data to stdout //size_t written; const unsigned char *ib = NULL; /* info->interest_ccnb */ struct ccn_indexbuf *ic = NULL; int res; struct mydata *md = selfp->data; if (kind == CCN_UPCALL_FINAL) { if (md != NULL) { selfp->data = NULL; free(md); md = NULL; } return(CCN_UPCALL_RESULT_OK); } if (kind == CCN_UPCALL_INTEREST_TIMED_OUT) return(CCN_UPCALL_RESULT_REEXPRESS); if (kind != CCN_UPCALL_CONTENT && kind != CCN_UPCALL_CONTENT_UNVERIFIED) return(CCN_UPCALL_RESULT_ERR); if (md == NULL) selfp->data = md = calloc(1, sizeof(*md)); ccnb = info->content_ccnb; ccnb_size = info->pco->offset[CCN_PCO_E]; ib = info->interest_ccnb; ic = info->interest_comps; /* XXX - must verify sig, and make sure it is LEAF content */ res = ccn_content_get_value(ccnb, ccnb_size, info->pco, &data, &data_size); if (res < 0) abort(); if (data_size > CHUNK_SIZE) { /* For us this is spam. Give up now. */ fprintf(stderr, "*** Segment %d found with a data size of %d." " This program only works with segments of 1024 bytes." " Try ccncatchunks2 instead.\n", (int)selfp->intdata, (int)data_size); exit(1); } /* OK, we will accept this block. */ //sleep(1); // TANG: No need to write data to stdout, skip 3 lines //written = fwrite(data, data_size, 1, stdout); //if (written != 1) // exit(1); /* A short block signals EOF for us. */ // TANG: to support data_size smaller than 1024, skip 2 lines //if (data_size < CHUNK_SIZE) // exit(0); /* Ask for the next one */ name = ccn_charbuf_create(); ccn_name_init(name); if (ic->n < 2) abort(); res = ccn_name_append_components(name, ib, ic->buf[0], ic->buf[ic->n - 2]); if (res < 0) abort(); temp = ccn_charbuf_create(); //printf("intdata = %d \n ", selfp->intdata); ccn_charbuf_putf(temp, "%d", ++(selfp->intdata)); ccn_name_append(name, temp->buf, temp->length); ccn_charbuf_destroy(&temp); if(DEBUG){ //Print out the interest's name printf("Interest name = "); int myres = 0; struct ccn_indexbuf* ndx = ccn_indexbuf_create(); unsigned char* mycomp = NULL; size_t mysize = 0; ndx->n = 0; myres = ccn_name_split(name, ndx); if(myres < 0){ fprintf(stderr, "ccn_name_split @ ccntraffic. failed"); } int it = 0; for(it = 0; it < ndx->n-1; it++){ mysize = 0; myres = ccn_name_comp_get(name->buf, ndx, it, &mycomp, &mysize); printf("%s/", mycomp); mycomp = NULL; } printf("\n"); } templ = make_template(md); res = ccn_express_interest(info->h, name, selfp, templ); if (res < 0) abort(); ccn_charbuf_destroy(&templ); ccn_charbuf_destroy(&name); return(CCN_UPCALL_RESULT_OK); }
int NdnMediaProcess::ndnDataSend(const void *buf, size_t len) { #define CHARBUF_DESTROY \ ccn_charbuf_destroy(&message);\ ccn_charbuf_destroy(&path); \ ccn_charbuf_destroy(&seq); UserDataBuf *userBuf = localUdb; if (userBuf == NULL) return -1; int res = 0; int seq_num = -1; struct ccn_charbuf *message = ccn_charbuf_create(); struct ccn_charbuf *path = ccn_charbuf_create(); struct ccn_charbuf *seq = ccn_charbuf_create(); unsigned char *ccn_msg = NULL; size_t ccn_msg_size = 0; ccn_name_init(path); seq_num = localSeq++; ccn_name_from_uri(path, localUdb->user_name.toLocal8Bit().constData()); ccn_name_append_str(path, "audio"); if (seq_num < 0) { res = -1; CHARBUF_DESTROY; return res; } ccn_charbuf_putf(seq, "%ld", seq_num); ccn_name_append(path, seq->buf, seq->length); struct ccn_charbuf *signed_info = ccn_charbuf_create(); if (cached_keystore == NULL) init_cached_keystore(); ccn_charbuf *keylocator = ccn_charbuf_create(); ccn_create_keylocator(keylocator, ccn_keystore_public_key(cached_keystore)); /* Create signed_info */ res = ccn_signed_info_create(signed_info, /* pubkeyid */ get_my_publisher_key_id(), /* publisher_key_id_size */ get_my_publisher_key_id_length(), /* datetime */ NULL, /* type */ CCN_CONTENT_DATA, /* freshness */ FRESHNESS, /* finalblockid */ NULL, /* keylocator */ keylocator); if (res != 0) { fprintf(stderr, "signed_info_create failed %d (line %d)\n", res, __LINE__); } if (isPrivate) { unsigned char *enc_buf = NULL; size_t enc_len = 0; res = symEncrypt(sessionKey, NULL, (const unsigned char *)buf, len, &enc_buf, &enc_len, AES_BLOCK_SIZE); if (res != 0) { fprintf(stderr, "can not decrypt audio\n"); std::exit(1); } res = ccn_encode_ContentObject( /* out */ message, path, signed_info, enc_buf, enc_len, /* keyLocator */ NULL, get_my_private_key()); if (enc_buf != NULL) { free(enc_buf); enc_buf = NULL; } } else { res = ccn_encode_ContentObject( /* out */ message, path, signed_info, buf, len, /* keyLocator */ NULL, get_my_private_key()); } if (res != 0) { fprintf(stderr, "encode_ContentObject failed %d (line %d)\n", res, __LINE__); CHARBUF_DESTROY; return res; } ccn_charbuf_destroy(&signed_info); ccn_charbuf_destroy(&keylocator); ccn_msg = (unsigned char *)calloc(1, message->length); ccn_msg_size = message->length; memcpy(ccn_msg, message->buf, message->length); /* { struct ccn_parsed_ContentObject o = {0}; res = ccn_parse_ContentObject(ccn_msg, ccn_msg_size, &o, NULL); if (res < 0) { fprintf(stderr, "created bad ContentObject, res = %d\n", res); abort(); } } */ struct buf_list *p = NULL, *b = userBuf->data_buf.buflist; while (b != NULL) { p = b; b = b->link; } b = (struct buf_list*)calloc(1, sizeof(struct buf_list)); if (b == NULL) { CHARBUF_DESTROY; return -1; } if (p != NULL) p->link = b; else userBuf->data_buf.buflist = b; b->buf = ccn_msg; b->len = ccn_msg_size; b->link = NULL; CHARBUF_DESTROY; return res; }
int main(int argc, char **argv) { int res; int opt; char *dir = NULL; struct ccn_charbuf *filename = NULL; int force = 0; const char *password = NULL; char *name = ".ccnx_keystore"; char *username; int fullname = 0; char *key = NULL; unsigned char keybuf[CCN_SECRET_KEY_LENGTH/8]; int copylen = CCN_SECRET_KEY_LENGTH/8; struct stat statbuf; char *digest = NULL; int dirset = 0; int read_mode = 0; struct ccn_keystore *keystore = ccn_aes_keystore_create(); EVP_PKEY *sk; while ((opt = getopt(argc, argv, "hfk:p:d:ro:")) != -1) { switch (opt) { case 'f': force = 1; break; case 'k': key = optarg; break; case 'p': password = optarg; break; case 'o': dir = optarg; dirset = 1; break; case 'd': digest = optarg; break; case 'r': read_mode = 1; break; case 'h': default: usage(argv[0]); exit(1); } } username = argv[optind]; if (username != NULL) { name = username; fullname = 1; } if (dir == NULL){ dir = getenv("HOME"); } res = stat(dir, &statbuf); if (res == -1) { perror(dir); exit(1); } else if ((statbuf.st_mode & S_IFMT) != S_IFDIR) { errno = ENOTDIR; perror(dir); exit(1); } filename = ccn_charbuf_create(); if (!dirset) { ccn_charbuf_putf(filename, "%s/.ccnx", dir); res = stat(ccn_charbuf_as_string(filename), &statbuf); if (res == -1) { res = mkdir(ccn_charbuf_as_string(filename), 0700); if (res != 0) { perror(ccn_charbuf_as_string(filename)); exit(1); } } } else ccn_charbuf_append_string(filename, dir); if (password == NULL) password = ccn_get_password(); ccn_charbuf_append_string(filename, "/"); ccn_charbuf_append_string(filename, name); if (key == NULL) { ccn_generate_symmetric_key(keybuf, CCN_SECRET_KEY_LENGTH); } if (!fullname) { if (read_mode) { ccn_charbuf_append_string(filename, "-"); ccn_charbuf_append_string(filename, digest); } else { if (key != NULL) { memset(keybuf, 0, sizeof(keybuf)); if (strlen(key) < sizeof(keybuf)) copylen = strlen(key); memcpy(keybuf, key, copylen); } ccn_create_aes_filename_from_key(filename, keybuf, CCN_SECRET_KEY_LENGTH); } } if (read_mode) { res = ccn_aes_keystore_init(keystore, ccn_charbuf_as_string(filename), password); } else { if (!force) { res = stat(ccn_charbuf_as_string(filename), &statbuf); if (res != -1) { errno=EEXIST; perror(ccn_charbuf_as_string(filename)); exit(1); } } res = ccn_aes_keystore_file_init(ccn_charbuf_as_string(filename), password, keybuf, CCN_SECRET_KEY_LENGTH); } if (res != 0) { if (errno != 0) perror(ccn_charbuf_as_string(filename)); else fprintf(stderr, "ccn_keystore_file_init: invalid argument\n"); exit(1); } if (read_mode) { unsigned char *key_data; int i; sk = (EVP_PKEY *) ccn_keystore_key(keystore); key_data = ASN1_STRING_data(EVP_PKEY_get0(sk)); printf("Retrieved key: 0x"); for (i = 0; i < ccn_keystore_key_digest_length(keystore); i++) printf("%x", key_data[i]); printf("\n"); } else { printf("Created keystore: %s\n", ccn_charbuf_as_string(filename)); } return(0); }
PUBLIC void r_store_init(struct ccnr_handle *h) { struct ccn_btree *btree = NULL; struct ccn_btree_node *node = NULL; struct hashtb_param param = {0}; int i; int j; int res; struct ccn_charbuf *path = NULL; struct ccn_charbuf *msgs = NULL; off_t offset; path = ccn_charbuf_create(); param.finalize_data = h; param.finalize = 0; h->cob_limit = r_init_confval(h, "CCNR_CONTENT_CACHE", 16, 2000000, 4201); h->cookie_limit = choose_limit(h->cob_limit, (ccnr_cookie)(~0U)); h->content_by_cookie = calloc(h->cookie_limit, sizeof(h->content_by_cookie[0])); CHKPTR(h->content_by_cookie); h->content_by_accession_tab = hashtb_create(sizeof(struct content_by_accession_entry), NULL); CHKPTR(h->content_by_accession_tab); h->btree = btree = ccn_btree_create(); CHKPTR(btree); FAILIF(btree->nextnodeid != 1); ccn_charbuf_putf(path, "%s/index", h->directory); res = mkdir(ccn_charbuf_as_string(path), 0700); if (res != 0 && errno != EEXIST) r_init_fail(h, __LINE__, ccn_charbuf_as_string(path), errno); else { msgs = ccn_charbuf_create(); btree->io = ccn_btree_io_from_directory(ccn_charbuf_as_string(path), msgs); if (btree->io == NULL) res = errno; if (msgs->length != 0 && CCNSHOULDLOG(h, sffdsdf, CCNL_WARNING)) { ccnr_msg(h, "while initializing %s - %s", ccn_charbuf_as_string(path), ccn_charbuf_as_string(msgs)); } ccn_charbuf_destroy(&msgs); if (btree->io == NULL) r_init_fail(h, __LINE__, ccn_charbuf_as_string(path), res); } node = ccn_btree_getnode(btree, 1, 0); if (btree->io != NULL) btree->nextnodeid = btree->io->maxnodeid + 1; CHKPTR(node); if (node->buf->length == 0) { res = ccn_btree_init_node(node, 0, 'R', 0); CHKSYS(res); } ccn_charbuf_destroy(&path); if (h->running == -1) return; r_store_read_stable_point(h); h->active_in_fd = -1; h->active_out_fd = r_io_open_repo_data_file(h, "repoFile1", 1); /* output */ offset = lseek(h->active_out_fd, 0, SEEK_END); h->startupbytes = offset; if (offset != h->stable || node->corrupt != 0) { ccnr_msg(h, "Index not current - resetting"); ccn_btree_init_node(node, 0, 'R', 0); node = NULL; ccn_btree_destroy(&h->btree); path = ccn_charbuf_create(); /* Remove old index files to avoid confusion */ for (i = 1, j = 0; i > 0 && j < 3; i++) { path->length = 0; res = ccn_charbuf_putf(path, "%s/index/%d", h->directory, i); if (res >= 0) res = unlink(ccn_charbuf_as_string(path)); if (res < 0) j++; } h->btree = btree = ccn_btree_create(); path->length = 0; ccn_charbuf_putf(path, "%s/index", h->directory); btree->io = ccn_btree_io_from_directory(ccn_charbuf_as_string(path), msgs); CHKPTR(btree->io); btree->io->maxnodeid = 0; btree->nextnodeid = 1; node = ccn_btree_getnode(btree, 1, 0); btree->nextnodeid = btree->io->maxnodeid + 1; ccn_btree_init_node(node, 0, 'R', 0); h->stable = 0; h->active_in_fd = r_io_open_repo_data_file(h, "repoFile1", 0); /* input */ ccn_charbuf_destroy(&path); if (CCNSHOULDLOG(h, dfds, CCNL_INFO)) ccn_schedule_event(h->sched, 50000, r_store_reindexing, NULL, 0); } if (CCNSHOULDLOG(h, weuyg, CCNL_FINEST)) { FILE *dumpfile = NULL; path = ccn_charbuf_create(); ccn_charbuf_putf(path, "%s/index/btree_check.out", h->directory); dumpfile = fopen(ccn_charbuf_as_string(path), "w"); res = ccn_btree_check(btree, dumpfile); if (dumpfile != NULL) { fclose(dumpfile); dumpfile = NULL; } else path->length = 0; ccnr_msg(h, "ccn_btree_check returned %d (%s)", res, ccn_charbuf_as_string(path)); ccn_charbuf_destroy(&path); if (res < 0) r_init_fail(h, __LINE__, "index is corrupt", res); } btree->full = r_init_confval(h, "CCNR_BTREE_MAX_FANOUT", 4, 9999, 1999); btree->full0 = r_init_confval(h, "CCNR_BTREE_MAX_LEAF_ENTRIES", 4, 9999, 1999); btree->nodebytes = r_init_confval(h, "CCNR_BTREE_MAX_NODE_BYTES", 1024, 8388608, 2097152); btree->nodepool = r_init_confval(h, "CCNR_BTREE_NODE_POOL", 16, 2000000, 512); if (h->running != -1) r_store_index_needs_cleaning(h); }
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_keystore *keystore = NULL; int res = 0; struct ccn_charbuf *signed_info = ccn_charbuf_create(); int i; int sec, usec; char msgbuf[PAYLOAD_SIZE]; struct timeval start, end; struct ccn_charbuf *message = ccn_charbuf_create(); struct ccn_charbuf *path = ccn_charbuf_create(); struct ccn_charbuf *seq = ccn_charbuf_create(); struct ccn_charbuf *temp = ccn_charbuf_create(); keystore = ccn_keystore_create(); ccn_charbuf_putf(temp, "%s/.ccnx/.ccnx_keystore", getenv("HOME")); res = ccn_keystore_init(keystore, ccn_charbuf_as_string(temp), "Th1s1sn0t8g00dp8ssw0rd."); if (res != 0) { printf("Failed to initialize keystore %s\n", ccn_charbuf_as_string(temp)); exit(1); } ccn_charbuf_destroy(&temp); res = ccn_signed_info_create(signed_info, /* pubkeyid */ ccn_keystore_public_key_digest(keystore), /* publisher_key_id_size */ ccn_keystore_public_key_digest_length(keystore), /* datetime */ NULL, /* type */ CCN_CONTENT_DATA, /* freshness */ FRESHNESS, /*finalblockid*/ NULL, /* keylocator */ NULL); srandom(time(NULL)); for (i=0; i<PAYLOAD_SIZE; i++) { msgbuf[i] = random(); } printf("Generating %d signed ContentObjects (one . per 100)\n", COUNT); gettimeofday(&start, NULL); for (i=0; i<COUNT; i++) { if (i>0 && (i%100) == 0) { printf("."); fflush(stdout); } ccn_name_init(path); ccn_name_append_str(path, "rtp"); ccn_name_append_str(path, "protocol"); ccn_name_append_str(path, "13.2.117.34"); ccn_name_append_str(path, "domain"); ccn_name_append_str(path, "smetters"); ccn_name_append_str(path, "principal"); ccn_name_append_str(path, "2021915340"); ccn_name_append_str(path, "id"); ccn_charbuf_putf(seq, "%u", i); ccn_name_append(path, seq->buf, seq->length); ccn_name_append_str(path, "seq"); res = ccn_encode_ContentObject(/* out */ message, path, signed_info, msgbuf, PAYLOAD_SIZE, /* digest_algorithm */ NULL, ccn_keystore_private_key(keystore)); ccn_charbuf_reset(message); ccn_charbuf_reset(path); ccn_charbuf_reset(seq); } gettimeofday(&end, NULL); sec = end.tv_sec - start.tv_sec; usec = (int)end.tv_usec - (int)start.tv_usec; while (usec < 0) { sec--; usec += 1000000; } printf("\nComplete in %d.%06d secs\n", sec, usec); return(0); }
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); }
/** * Load a link to the repo policy from the repoPolicy file and load the link * target to extract the actual policy. * If a policy file does not exist a new one is created, with a link to a policy * based either on the environment variable CCNR_GLOBAL_PREFIX or the system * default value of ccnx:/parc.com/csl/ccn/Repos, plus the system defaults for * other fields. * This routine must be called after the btree code is initialized and capable * of returning content objects. * Sets the parsed_policy field of the handle to be the new policy. */ static int load_policy(struct ccnr_handle *ccnr) { int fd; ssize_t res; struct content_entry *content = NULL; const unsigned char *content_msg = NULL; struct ccn_parsed_ContentObject pco = {0}; struct ccn_parsed_Link pl = {0}; struct ccn_indexbuf *nc = NULL; struct ccn_charbuf *basename = NULL; struct ccn_charbuf *policy = NULL; struct ccn_charbuf *policy_cob = NULL; struct ccn_charbuf *policyFileName; const char *global_prefix; const unsigned char *buf = NULL; size_t length = 0; int segment = 0; int final = 0; struct ccn_buf_decoder decoder; struct ccn_buf_decoder *d; policyFileName = ccn_charbuf_create(); ccn_charbuf_putf(policyFileName, "%s/repoPolicy", ccnr->directory); ccnr->parsed_policy = ccnr_parsed_policy_create(); fd = open(ccn_charbuf_as_string(policyFileName), O_RDONLY); if (fd >= 0) { ccnr->policy_link_cob = ccn_charbuf_create(); ccn_charbuf_reserve(ccnr->policy_link_cob, 4096); // limits the size of the policy link ccnr->policy_link_cob->length = 0; // clear the buffer res = read(fd, ccnr->policy_link_cob->buf, ccnr->policy_link_cob->limit - ccnr->policy_link_cob->length); close(fd); if (res == -1) { r_init_fail(ccnr, __LINE__, "Error reading repoPolicy file.", errno); ccn_charbuf_destroy(&ccnr->policy_link_cob); ccn_charbuf_destroy(&policyFileName); return(-1); } ccnr->policy_link_cob->length = res; nc = ccn_indexbuf_create(); res = ccn_parse_ContentObject(ccnr->policy_link_cob->buf, ccnr->policy_link_cob->length, &pco, nc); res = ccn_ref_tagged_BLOB(CCN_DTAG_Content, ccnr->policy_link_cob->buf, pco.offset[CCN_PCO_B_Content], pco.offset[CCN_PCO_E_Content], &buf, &length); d = ccn_buf_decoder_start(&decoder, buf, length); res = ccn_parse_Link(d, &pl, NULL); if (res <= 0) { ccnr_msg(ccnr, "Policy link is malformed."); goto CreateNewPolicy; } basename = ccn_charbuf_create(); ccn_charbuf_append(basename, buf + pl.offset[CCN_PL_B_Name], pl.offset[CCN_PL_E_Name] - pl.offset[CCN_PL_B_Name]); ccnr->policy_name = ccn_charbuf_create(); // to detect writes to this name ccn_charbuf_append_charbuf(ccnr->policy_name, basename); // has version ccn_name_chop(ccnr->policy_name, NULL, -1); // get rid of version policy = ccn_charbuf_create(); // if we fail to retrieve the link target, report and then create a new one do { ccn_name_append_numeric(basename, CCN_MARKER_SEQNUM, segment++); content = r_store_lookup_ccnb(ccnr, basename->buf, basename->length); if (content == NULL) { ccnr_debug_ccnb(ccnr, __LINE__, "policy lookup failed for", NULL, basename->buf, basename->length); break; } ccn_name_chop(basename, NULL, -1); content_msg = r_store_content_base(ccnr, content); if (content_msg == NULL) { ccnr_debug_ccnb(ccnr, __LINE__, "Unable to read policy object", NULL, basename->buf, basename->length); break; } res = ccn_parse_ContentObject(content_msg, r_store_content_size(ccnr, content), &pco, nc); res = ccn_ref_tagged_BLOB(CCN_DTAG_Content, content_msg, pco.offset[CCN_PCO_B_Content], pco.offset[CCN_PCO_E_Content], &buf, &length); ccn_charbuf_append(policy, buf, length); final = ccn_is_final_pco(content_msg, &pco, nc); } while (!final && segment < 100);