static enum ccn_upcall_res seqw_incoming_interest( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { int res; struct ccn_charbuf *cob = NULL; struct ccn_seqwriter *w = selfp->data; if (w == NULL || selfp != &(w->cl)) abort(); switch (kind) { case CCN_UPCALL_FINAL: ccn_charbuf_destroy(&w->nb); ccn_charbuf_destroy(&w->nv); ccn_charbuf_destroy(&w->buffer); ccn_charbuf_destroy(&w->cob0); free(w); break; case CCN_UPCALL_INTEREST: if (w->closed || w->buffer->length > 0) { cob = seqw_next_cob(w); if (cob == NULL) return(CCN_UPCALL_RESULT_OK); if (ccn_content_matches_interest(cob->buf, cob->length, 1, NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E], info->pi)) { w->interests_possibly_pending = 0; res = ccn_put(info->h, cob->buf, cob->length); if (res >= 0) { w->buffer->length = 0; w->seqnum++; return(CCN_UPCALL_RESULT_INTEREST_CONSUMED); } } ccn_charbuf_destroy(&cob); } if (w->cob0 != NULL) { cob = w->cob0; if (ccn_content_matches_interest(cob->buf, cob->length, 1, NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E], info->pi)) { w->interests_possibly_pending = 0; ccn_put(info->h, cob->buf, cob->length); return(CCN_UPCALL_RESULT_INTEREST_CONSUMED); } } w->interests_possibly_pending = 1; break; default: break; } return(CCN_UPCALL_RESULT_OK); }
/** * Write some data to a seqwriter. * * This is roughly analogous to a write(2) call in non-blocking mode. * * The current implementation returns an error and refuses the new data if * it does not fit in the current buffer. * That is, there are no partial writes. * In this case, the caller should ccn_run() for a little while and retry. * * It is also an error to attempt to write more than 4096 bytes. * * @returns the size written, or -1 for an error. In case of an error, * the caller may test ccn_geterror() for values of EAGAIN or * EINVAL from errno.h. */ int ccn_seqw_write(struct ccn_seqwriter *w, const void *buf, size_t size) { struct ccn_charbuf *cob = NULL; int res; int ans; if (w == NULL || w->cl.data != w) return(-1); if (w->buffer == NULL || size > MAX_DATA_SIZE) return(ccn_seterror(w->h, EINVAL)); ans = size; if (size + w->buffer->length > MAX_DATA_SIZE) ans = ccn_seterror(w->h, EAGAIN); else if (size != 0) ccn_charbuf_append(w->buffer, buf, size); if (w->interests_possibly_pending && (w->batching == 0 || ans == -1)) { cob = seqw_next_cob(w); if (cob != NULL) { res = ccn_put(w->h, cob->buf, cob->length); if (res >= 0) { if (w->seqnum == 0) { w->cob0 = cob; cob = NULL; } w->buffer->length = 0; w->seqnum++; w->interests_possibly_pending = 0; } ccn_charbuf_destroy(&cob); } } return(ans); }
enum ccn_upcall_res incoming_interest( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { struct ccn_charbuf *cob = selfp->data; int res; switch (kind) { case CCN_UPCALL_FINAL: break; case CCN_UPCALL_INTEREST: if (ccn_content_matches_interest(cob->buf, cob->length, 1, NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E], info->pi)) { res = ccn_put(info->h, cob->buf, cob->length); if (res >= 0) { selfp->intdata = 1; ccn_set_run_timeout(info->h, 0); return(CCN_UPCALL_RESULT_INTEREST_CONSUMED); } } break; default: break; } return(CCN_UPCALL_RESULT_OK); }
int NdnMediaProcess::doPendingSend() { int res = 0; struct buf_list *p; struct buf_list *b = localUdb->data_buf.buflist; if (b != NULL) { p = b->link; if (b != NULL && b->buf != NULL) { /* 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); res = ccn_put(ndnState.ccn, b->buf, b->len); pthread_mutex_unlock(&ccn_mutex); free(b->buf); b->len = 0; b->buf = NULL; } free(b); localUdb->data_buf.buflist = p; } return res; }
void CcnCC_sendContent(CcnCC self, struct ccn_charbuf* name, TimeSpan expires, void* data, size_t size) { struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; if (expires >= 0) { sp.template_ccnb = ccn_charbuf_create(); ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_SignedInfo, CCN_DTAG); ccnb_tagged_putf(sp.template_ccnb, CCN_DTAG_FreshnessSeconds, "%ld", expires / 1000); sp.sp_flags |= CCN_SP_TEMPL_FRESHNESS; ccn_charbuf_append_closer(sp.template_ccnb); } struct ccn_charbuf* content = ccn_charbuf_create(); if (0 == ccn_sign_content(self->ccnh, content, name, &sp, data, size)) { ccn_put(self->ccnh, content->buf, content->length); } ccn_charbuf_destroy(&sp.template_ccnb); ccn_charbuf_destroy(&content); }
enum ccn_upcall_res ccn_proxy_server_decap_interest( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { enum ccn_upcall_res upcall_res = CCN_UPCALL_RESULT_ERR; struct ccn_proxy_server* server = selfp->data; struct ccn_proxy* proxy = server->proxy; // struct ccn_proxy *proxy = (selfp->data)->proxy; int i, res; unsigned char* random = NULL; struct ccn_charbuf* request_name; struct ccn_indexbuf* request_comps; struct ccn_charbuf* signed_info; struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; random = (unsigned char*)malloc(RESP_SIZE * sizeof(unsigned char)); for (i = 0; i < RESP_SIZE; i++) random[i] = rand() % 256; handled++; printf("random buffer created - creating signed object: %d\n", handled); // Create a valid, signed ContentObject request_name = NULL; request_comps = NULL; res = ccn_util_extract_name(info->interest_ccnb, info->interest_comps, &request_name, &request_comps); signed_info = ccn_charbuf_create(); sp.type = CCN_CONTENT_DATA; res = ccn_sign_content(proxy->handle, signed_info, request_name, &sp, random, RESP_SIZE); // Drop the content object into the socket (handle) to be sent back downstream res = ccn_put(proxy->handle, signed_info->buf, signed_info->length); if (res < 0) { ccn_perror(proxy->handle, NULL); printf("WTF?!?!?!\n"); } else { printf("successfully put content object in the socket\n"); } // // TODO: need to fill up random buffer and then inject it using ccn_put return(CCN_UPCALL_RESULT_OK); }
static enum ccn_upcall_res write_interest_handler (struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { struct ccn_charbuf *cob = selfp->data; struct ccn *h = info->h; if (kind != CCN_UPCALL_INTEREST) return(CCN_UPCALL_RESULT_OK); if (ccn_content_matches_interest(cob->buf, cob->length, 1, NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E], info->pi)) { ccn_put(info->h, cob->buf, cob->length); selfp->intdata = 1; ccn_set_run_timeout(h, 0); return(CCN_UPCALL_RESULT_INTEREST_CONSUMED); } return(CCN_UPCALL_RESULT_OK); }
// handling incoming interest when it is incoming / received static enum ccn_upcall_res incoming_interest ( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { struct ccn_charbuf *cob = selfp -> data; int res; switch (kind) { case CCN_UPCALL_FINAL: // handler is about to be deregistered printf("deregistering handler...\n"); return CCN_UPCALL_RESULT_OK; case CCN_UPCALL_INTEREST: // incoming interest; cob is content, info is incoming interest if (ccn_content_matches_interest(cob -> buf, cob -> length, 1, NULL, info -> interest_ccnb, info -> pi -> offset[CCN_PI_E], info -> pi)) { res = ccn_put(info->h, cob->buf, cob->length); if (res >= 0) { selfp -> intdata = 1; ccn_set_run_timeout(info->h, 0); return (CCN_UPCALL_RESULT_INTEREST_CONSUMED); } } break; //case CCN_UPCALL_CONSUMED_INTEREST: // incoming interest, someone has answered //case CCN_UPCALL_CONTENT: // incoming verified content //case CCN_UPCALL_INTEREST_TIMED_OUT: // interest timed out //case CCN_UPCALL_CONTENT_UNVERIFIED: // content that has not been verified //case CCN_UPCALL_CONTENT_BAD: // verification failed default: printf("Unexpected response.\n"); return CCN_UPCALL_RESULT_ERR; } return (CCN_UPCALL_RESULT_OK); }
/** * Call-back from the CCN network that something has arrived * * We get notified that a client has interests in things we are producing. * This function will do some basic checking to see what exactly the client has * an interest in, and will produce what is appropriate. * Currently the things we produce are: * \li last block - we resend the last block we have published for a given name * \li last segment - we produce a data message that only contains the latest segment number we used * * \param selfp -> a context structure we created when registering this call-back * \param kind specifies the type of call-back being processed, see the \b switch statement * \param info context information about the call-back itself; interests, data, etc. * \return a response as to how successful we were in processing the call-back * \retval CCN_UPCALL_RESULT_OK things went well * \retval CCN_UPCALL_RESULT_VERIFY need to verify the contents of what we received * \retval CCN_UPCALL_RESULT_REEXPRESS an interest timedout waiting for data, so we try again * \retval CCN_UPCALL_RESULT_ERR some error was encountered */ static enum ccn_upcall_res new_interests (struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { Gstccnxsink *me = GST_CCNXSINK (selfp->data); struct ccn_charbuf *cb; struct ccn_charbuf *sname = NULL; const unsigned char *cp1, *cp2; size_t sz1; size_t sz2; long lastSeq; struct ccn_signing_params myparams; unsigned int i; int rc; GST_DEBUG ("something has arrived!"); GST_DEBUG ("matched is: %d", info->matched_comps); // number of filter components that were matched by the interest cb = interestAsUri (info); GST_DEBUG ("as URI: %s", ccn_charbuf_as_string (cb)); ccn_charbuf_destroy (&cb); myparams = me->sp; /* Some debugging stuff */ for (i = 0; i < 10; ++i) { const unsigned char *cp; size_t sz; GST_DEBUG ("%3d: ", i); if (0 > ccn_name_comp_get (info->interest_ccnb, info->interest_comps, i, &cp, &sz)) { // fprintf(stderr, "could not get comp\n"); break; } else { // hDump( DUMP_ADDR( cp ), DUMP_SIZE( sz ) ); } } switch (kind) { case CCN_UPCALL_FINAL: GST_LOG_OBJECT (me, "CCN upcall final %p", selfp); return (0); case CCN_UPCALL_INTEREST_TIMED_OUT: if (selfp != me->ccn_closure) { GST_LOG_OBJECT (me, "CCN Interest timed out on dead closure %p", selfp); return (0); } GST_LOG_OBJECT (me, "CCN upcall reexpress -- timed out"); if (me->timeouts > 5) { GST_LOG_OBJECT (me, "CCN upcall reexpress -- too many reexpressions"); return (0); } me->timeouts++; return (CCN_UPCALL_RESULT_REEXPRESS); case CCN_UPCALL_CONTENT_UNVERIFIED: if (selfp != me->ccn_closure) { GST_LOG_OBJECT (me, "CCN unverified content on dead closure %p", selfp); return (0); } return (CCN_UPCALL_RESULT_VERIFY); case CCN_UPCALL_CONTENT: if (selfp != me->ccn_closure) { GST_LOG_OBJECT (me, "CCN content on dead closure %p", selfp); return (0); } break; case CCN_UPCALL_CONTENT_BAD: GST_LOG_OBJECT (me, "Content signature verification failed! Discarding.\n"); return (CCN_UPCALL_RESULT_ERR); case CCN_UPCALL_CONSUMED_INTEREST: GST_LOG_OBJECT (me, "Upcall consumed interest\n"); return (CCN_UPCALL_RESULT_ERR); /* no data */ /* Here is the most interesting case...when an interest arrives */ case CCN_UPCALL_INTEREST: GST_INFO ("We got an interest\n"); myparams.freshness = 1; /* meta data is old very quickly */ /* See if any meta information is sought */ for (i = 0;; ++i) { if (0 > ccn_name_comp_get (info->interest_ccnb, info->interest_comps, i, &cp1, &sz1)) { cp1 = NULL; break; } else { if (!strncmp ((const char *) cp1, "_meta_", 6)) { // OK, found meta, now which one is needed? if (0 > ccn_name_comp_get (info->interest_ccnb, info->interest_comps, i + 1, &cp2, &sz2)) { GST_LOG_OBJECT (me, "CCN interest received with invalid meta request"); cp1 = NULL; } break; } // Component not meta, keep looking } } // At this point, i is left pointing at '_meta_' or at the end of component list if (cp1) { // hDump( DUMP_ADDR(cp1), DUMP_SIZE(sz1) ); // hDump( DUMP_ADDR(cp2), DUMP_SIZE(sz2) ); if (strncmp ((const char *) cp2, ".segment", 8)) goto Exit_Interest; /* not a match */ /* publish what segment we are up to in reply to the meta request */ lastSeq = me->segment - 1; GST_INFO ("sending meta data....segment: %d", lastSeq); sname = ccn_charbuf_create (); ccn_name_init (sname); rc = ccn_name_append_components (sname, info->interest_ccnb, info->interest_comps->buf[0], info->interest_comps->buf[i + 2]); if (rc < 0) goto Error_Interest; // rc = ccn_create_version(me->ccn, sname, CCN_V_REPLACE | CCN_V_NOW | CCN_V_HIGH, 0, 0); // if (rc < 0) goto Error_Interest; me->temp->length = 0; rc = ccn_sign_content (me->ccn, me->temp, sname, &myparams, &lastSeq, sizeof (lastSeq)); // hDump(DUMP_ADDR(sname->buf), DUMP_SIZE(sname->length)); if (rc != 0) { GST_LOG_OBJECT (me, "Failed to encode ContentObject (rc == %d)\n", rc); goto Error_Interest; } GST_INFO ("sending meta data..."); // hDump(DUMP_ADDR(me->temp->buf), DUMP_SIZE(me->temp->length)); rc = ccn_put (me->ccn, me->temp->buf, me->temp->length); me->temp->length = 0; if (rc < 0) { GST_LOG_OBJECT (me, "ccn_put failed (res == %d)\n", rc); goto Error_Interest; } GST_INFO ("meta data sent"); } else goto Exit_Interest; /* do not have _meta_ */ Exit_Interest: ccn_charbuf_destroy (&sname); break; Error_Interest: ccn_charbuf_destroy (&sname); return CCN_UPCALL_RESULT_ERR; default: GST_LOG_OBJECT (me, "CCN upcall result error"); return (CCN_UPCALL_RESULT_ERR); } me->timeouts = 0; return (CCN_UPCALL_RESULT_OK); }
/** * Send out a message onto the CCNx network * * Once a data buffer is ready to be sent onto the network, there are * a few more steps involved in preparing it for thta journey. * The CCN stack dictates that all data content messages must contain * a proper name, and be signed by the sender. * \todo some day we should also encrypt the data; I don't think it is now * Much of the information we need to accomplish the message preperation is * found in the element context or as one of the parameters. * * Most of the work is dealing with changing from the internal buffer size and * the message size of the CCN network. * We chop things up as needed and send each data message out, properly named and signed. * The naming will include the timestamp as well as a segment number. * If there are some partial bytes left over, that do not fill a CCN message packet, * we retain those to be sent out on the next call to this method. * The bytes are kept in the element context as is other pertinent information. * * \param me * \param data pointer to the data buffer to send * \param size number of bytes to send in the message * \param ts timestamp to use on the outbound message * \return a GST flow return value indicating the result of our attempt * \retval GST_FLOW_OK everything went well * \retval GST_FLOW_ERROR something went wrong */ static GstFlowReturn gst_ccnxsink_send (Gstccnxsink * me, guint8 * data, guint size, /*@unused@ */ GstClockTime ts) { struct ccn_charbuf *sname; /* where we construct the name of this data message */ struct ccn_charbuf *hold; /* holds the last block published so we can properly manage memory */ struct ccn_charbuf *temp; /* where we construct the message to send */ struct ccn_charbuf *signed_info; /* signing data within the message */ gint rc; /* return status on various calls */ guint8 *xferStart; /* points into the source buffer, data, as we packetize into CCN blocks */ size_t bytesLeft; /* keeps track of how much more we have to do */ /* Initialize our local storage and allocate buffers we will need */ xferStart = data; bytesLeft = size; sname = ccn_charbuf_create (); temp = ccn_charbuf_create (); signed_info = ccn_charbuf_create (); /* Hang onto this pointer so we can release the buffer as we exit this function */ hold = me->lastPublish; /* * I am hanging onto this code for now to handle the day when we want to encode the data. * I do not know why id did not work during development, but I am sure it is close to working 8-) * In the future, feel free to purge this if we never get around to using it. * Similarly for the code block that is down below a little bit. * if( me->keystore ) { signed_info->length = 0; GST_LOG_OBJECT( me, "send - signing info\n" ); rc = ccn_signed_info_create(signed_info , ccn_keystore_public_key_digest(me->keystore) //pubkeyid , ccn_keystore_public_key_digest_length(me->keystore) //publisher_key_id_size , NULL //datetime , CCN_CONTENT_DATA //type , me->expire //freshness , NULL //finalblockid , me->keylocator); // Put the keylocator in the first block only. ccn_charbuf_destroy(&(me->keylocator)); if (rc < 0) { GST_LOG_OBJECT(me, "Failed to create signed_info (rc == %d)\n", rc); goto Trouble; } } */ if (me->partial) { /* We had some left over from the last send */ size_t extra; uintmax_t seg; /* find out how much room we have left, and copy over the bytes we have, or need to fill the block */ extra = CCN_CHUNK_SIZE - me->partial->length; if (extra > bytesLeft) extra = bytesLeft; GST_LOG_OBJECT (me, "send - had a partial left: %d\n", extra); ccn_charbuf_append (me->partial, xferStart, extra); /* Adjust count and pointer to reflect the bytes we have taken */ bytesLeft -= extra; xferStart += extra; /* Filling to the size of the CCN packet means we need to send it out */ if (me->partial->length == CCN_CHUNK_SIZE) { sname->length = 0; seg = me->segment++; /* build up a name starting with the prefix, then the sequence number */ ccn_charbuf_append (sname, me->name->buf, me->name->length); ccn_name_append_numeric (sname, CCN_MARKER_SEQNUM, seg); temp->length = 0; /* Signing via this function does a lot of work. The result is a buffer, temp, that is ready to be sent */ ccn_sign_content (me->ccn, temp, sname, &me->sp, me->partial->buf, CCN_CHUNK_SIZE); // hDump( sname->buf, sname->length ); /* * See the comment above about holding this code. * if( me->keystore ) { rc = ccn_encode_ContentObject(temp, sname, signed_info, me->partial->buf, CCN_CHUNK_SIZE, NULL, ccn_keystore_private_key(me->keystore)); if (rc != 0) { GST_LOG_OBJECT( me, "Failed to encode ContentObject (rc == %d)\n", rc); goto Trouble; } */ /* send the data message on its way */ rc = ccn_put (me->ccn, temp->buf, temp->length); if (rc < 0) { GST_LOG_OBJECT (me, "ccn_put failed (rc == %d)\n", rc); goto Trouble; } /* free the buffer we used for the partial data */ ccn_charbuf_destroy (&me->partial); me->partial = NULL; /* } else { GST_LOG_OBJECT( me, "No keystore. What should we do?\n" ); goto Trouble; } */ } } /* No left over means we can send direct out of the data buffer */ /* Now that we are done with the partial block, go and process the new data in much the same fashion */ while (bytesLeft >= CCN_CHUNK_SIZE) { uintmax_t seg; GST_LOG_OBJECT (me, "send - bytesLeft: %d\n", bytesLeft); sname->length = 0; seg = me->segment++; ccn_charbuf_append (sname, me->name->buf, me->name->length); ccn_name_append_numeric (sname, CCN_MARKER_SEQNUM, seg); GST_LOG_OBJECT (me, "send - name is ready\n"); temp->length = 0; ccn_sign_content (me->ccn, temp, sname, &me->sp, xferStart, CCN_CHUNK_SIZE); // hDump( sname->buf, sname->length ); /* if( me->keystore ) { GST_LOG_OBJECT( me, "send - encoding\n" ); rc = ccn_encode_ContentObject(temp, sname, signed_info, xferStart, CCN_CHUNK_SIZE, NULL, ccn_keystore_private_key(me->keystore)); if (rc != 0) { GST_LOG_OBJECT( me, "Failed to encode ContentObject (rc == %d)\n", rc); goto Trouble; } */ GST_LOG_OBJECT (me, "send - putting\n"); rc = ccn_put (me->ccn, temp->buf, temp->length); if (rc < 0) { GST_LOG_OBJECT (me, "ccn_put failed (rc == %d)\n", rc); goto Trouble; } /* } else { GST_LOG_OBJECT( me, "No keystore. What should we do?\n" ); goto Trouble; } */ GST_LOG_OBJECT (me, "send - adjusting buffers\n"); /* msleep(5); */ bytesLeft -= CCN_CHUNK_SIZE; xferStart += CCN_CHUNK_SIZE; } /* end of while() */ if (bytesLeft) { /* We have some left over for next time */ GST_LOG_OBJECT (me, "send - for next time: %d\n", bytesLeft); me->partial = ccn_charbuf_create (); me->partial->length = 0; ccn_charbuf_append (me->partial, xferStart, bytesLeft); } /* Do proper memory management, then return */ ccn_charbuf_destroy (&sname); me->lastPublish = temp; ccn_charbuf_destroy (&hold); ccn_charbuf_destroy (&signed_info); GST_LOG_OBJECT (me, "send - leaving length: %d\n", me->lastPublish->length); return GST_FLOW_OK; Trouble: ccn_charbuf_destroy (&sname); ccn_charbuf_destroy (&temp); ccn_charbuf_destroy (&signed_info); return GST_FLOW_ERROR; }
/** * Common interest handler */ PUBLIC enum ccn_upcall_res ccnr_answer_req(struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { struct ccn_charbuf *msg = NULL; struct ccn_charbuf *name = NULL; struct ccn_charbuf *keylocator = NULL; struct ccn_charbuf *signed_info = NULL; struct ccn_charbuf *reply_body = NULL; struct ccnr_handle *ccnr = NULL; int res = 0; int morecomps = 0; const unsigned char *final_comp = NULL; size_t final_size = 0; switch (kind) { case CCN_UPCALL_FINAL: free(selfp); return(CCN_UPCALL_RESULT_OK); case CCN_UPCALL_INTEREST: break; case CCN_UPCALL_CONSUMED_INTEREST: return(CCN_UPCALL_RESULT_OK); default: return(CCN_UPCALL_RESULT_ERR); } ccnr = (struct ccnr_handle *)selfp->data; if (CCNSHOULDLOG(ccnr, LM_128, CCNL_FINE)) ccnr_debug_ccnb(ccnr, __LINE__, "ccnr_answer_req", NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E]); morecomps = selfp->intdata & MORECOMPS_MASK; if ((info->pi->answerfrom & CCN_AOK_NEW) == 0 && selfp->intdata != OP_SERVICE) return(CCN_UPCALL_RESULT_OK); if (info->matched_comps >= info->interest_comps->n) goto Bail; if ((selfp->intdata & OPER_MASK) != OP_SERVICE && info->pi->prefix_comps != info->matched_comps + morecomps) goto Bail; if (morecomps == 1) { res = ccn_name_comp_get(info->interest_ccnb, info->interest_comps, info->matched_comps, &final_comp, &final_size); if (res < 0) goto Bail; } if ((selfp->intdata & MUST_VERIFY) != 0) { struct ccn_parsed_ContentObject pco = {0}; // XXX - probably should check for message origin BEFORE verify res = ccn_parse_ContentObject(final_comp, final_size, &pco, NULL); if (res < 0) { ccnr_debug_ccnb(ccnr, __LINE__, "co_parse_failed", NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E]); goto Bail; } res = ccn_verify_content(info->h, final_comp, &pco); if (res != 0) { ccnr_debug_ccnb(ccnr, __LINE__, "co_verify_failed", NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E]); goto Bail; } } switch (selfp->intdata & OPER_MASK) { case OP_SERVICE: if (ccnr->service_ccnb == NULL) ccnr->service_ccnb = ccnr_init_service_ccnb(ccnr, info->h, CCNRID_LOCAL_URI, 600); if (ccn_content_matches_interest( ccnr->service_ccnb->buf, ccnr->service_ccnb->length, 1, NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E], info->pi )) { ccn_put(info->h, ccnr->service_ccnb->buf, ccnr->service_ccnb->length); res = CCN_UPCALL_RESULT_INTEREST_CONSUMED; goto Finish; } // XXX this needs refactoring. if (ccnr->neighbor_ccnb == NULL) ccnr->neighbor_ccnb = ccnr_init_service_ccnb(ccnr, info->h, CCNRID_NEIGHBOR_URI, 5); if (ccn_content_matches_interest( ccnr->neighbor_ccnb->buf, ccnr->neighbor_ccnb->length, 1, NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E], info->pi )) { ccn_put(info->h, ccnr->neighbor_ccnb->buf, ccnr->neighbor_ccnb->length); res = CCN_UPCALL_RESULT_INTEREST_CONSUMED; goto Finish; } if (ccn_content_matches_interest( ccnr->policy_link_cob->buf, ccnr->policy_link_cob->length, 1, NULL, info->interest_ccnb, info->pi->offset[CCN_PI_E], info->pi )) { ccn_put(info->h, ccnr->policy_link_cob->buf, ccnr->policy_link_cob->length); res = CCN_UPCALL_RESULT_INTEREST_CONSUMED; goto Finish; } goto Bail; break; default: // No other OP_xxx are supported here goto Bail; } Bail: res = CCN_UPCALL_RESULT_ERR; Finish: ccn_charbuf_destroy(&msg); ccn_charbuf_destroy(&name); ccn_charbuf_destroy(&keylocator); ccn_charbuf_destroy(&reply_body); ccn_charbuf_destroy(&signed_info); return(res); }
int andana_client_decap_content(struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { int res; struct andana_client *client = selfp->data; struct andana_path **path_ptr; struct hashtb_enumerator ee; struct hashtb_enumerator *e = ⅇ DEBUG_PRINT("Client Content handle called\n"); switch (kind) { case CCN_UPCALL_CONTENT: /**< incoming verified content */ DEBUG_PRINT("Incoming verified content\n"); break; case CCN_UPCALL_CONTENT_UNVERIFIED:/**< content that has not been verified */ DEBUG_PRINT("Incoming unverified content\n"); break; case CCN_UPCALL_CONTENT_BAD: /**< verification failed */ DEBUG_PRINT("Incoming bad content (verification failure)\n"); break; case CCN_UPCALL_INTEREST_TIMED_OUT:/**< interest timed out */ { const unsigned char *name = info->interest_ccnb + info->pi->offset[CCN_PI_B_Name]; const size_t length = info->pi->offset[CCN_PI_E_Name] - info->pi->offset[CCN_PI_B_Name]; DEBUG_PRINT("Interest timed out\n"); hashtb_start(client->name_to_path, e); hashtb_seek(e, name, length, 0); hashtb_delete(e); hashtb_end(e); return(CCN_UPCALL_RESULT_ERR); } case CCN_UPCALL_INTEREST: /**< incoming interest */ case CCN_UPCALL_CONSUMED_INTEREST: /**< incoming interest, someone has answered */ case CCN_UPCALL_FINAL: /**< handler is about to be deregistered */ default: DEBUG_PRINT("upcall other kind = %d\n", kind); return(CCN_UPCALL_RESULT_ERR); } const unsigned char *content_name = info->content_ccnb + info->pco->offset[CCN_PCO_B_Name]; const size_t name_length = info->pco->offset[CCN_PCO_E_Name] - info->pco->offset[CCN_PCO_B_Name]; hashtb_start(client->name_to_path, e); res = hashtb_seek(e, content_name, name_length, 0); if (res == HT_NEW_ENTRY) { DEBUG_PRINT("ABORT %d %s Received unsolicited content?\n", __LINE__, __func__); abort(); } else if (res == HT_OLD_ENTRY) { path_ptr = e->data; DEBUG_PRINT("Interest recording found old entry\n"); } else { DEBUG_PRINT("Error in Interest insertion\n"); } // hashtb_end(e); /* Inner content object (that we just extracted) should exactly * match the original requesting Interest. Decrypted and send it out */ unsigned char *decrypted_content = NULL; size_t decrypted_length; unsigned char *content_ccnb = calloc(info->pco->offset[CCN_PCO_E], sizeof(unsigned char)); memcpy(content_ccnb, info->content_ccnb, info->pco->offset[CCN_PCO_E]); res = andana_path_decrypt_decap(*path_ptr, content_ccnb, info->pco->offset[CCN_PCO_E], info->pco, &decrypted_content, &decrypted_length); if (res < 0) { hashtb_delete(e); hashtb_end(e); free(content_ccnb); free(decrypted_content); return(CCN_UPCALL_RESULT_ERR); } // ccn_util_validate_content_object(decrypted_content, decrypted_length); res = ccn_put(client->proxy->handle, decrypted_content, decrypted_length); if (res < 0) { DEBUG_PRINT("Error sending parsed content object\n"); abort(); } // andana_path_destroy(path_ptr); hashtb_delete(e); hashtb_end(e); free(content_ccnb); free(decrypted_content); // andana_path_destroy(path_ptr); return(CCN_UPCALL_RESULT_OK); }
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); }
enum ccn_upcall_res andana_server_session_listener( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { int res; struct andana_server *server = selfp->data; const unsigned char * const_encrypted = NULL; unsigned char *encrypted = NULL; size_t enc_size; /* * Extract the client's randomness (aka the symmetric key it sent us. * Should be the last component of the incoming Interest. */ struct ccn_charbuf *request_name = NULL; struct ccn_indexbuf *request_comps = NULL; DEBUG_PRINT("IN %d %s\n", __LINE__, __func__); switch (kind) { case CCN_UPCALL_INTEREST: DEBUG_PRINT("%d %s received session request\n", __LINE__, __func__); break; case CCN_UPCALL_INTEREST_TIMED_OUT: DEBUG_PRINT("%d %s received session request time out\n", __LINE__, __func__); /* Fall through */ default: DEBUG_PRINT("OUT %d %s\n", __LINE__, __func__); return(CCN_UPCALL_RESULT_OK); } printf("here now mk?\n"); res = ccn_util_extract_name(info->interest_ccnb, info->interest_comps, &request_name, &request_comps); if (res < 0) { DEBUG_PRINT("%d %s Failed to extract session request name\n", __LINE__, __func__); ccn_charbuf_destroy(&request_name); ccn_indexbuf_destroy(&request_comps); return(CCN_UPCALL_RESULT_ERR); } printf("passed util extract name\n"); res = ccn_name_comp_get(request_name->buf, request_comps, (unsigned int)request_comps->n - 2, &const_encrypted, &enc_size); if (res < 0) { DEBUG_PRINT("%d %s Failed to extract session creation data\n", __LINE__, __func__); ccn_charbuf_destroy(&request_name); ccn_indexbuf_destroy(&request_comps); return(CCN_UPCALL_RESULT_ERR); } encrypted = calloc(enc_size, sizeof(unsigned char)); printf("encryption size = %d\n", enc_size); if (encrypted == NULL) printf("invalid pointer return from calloc\n"); memcpy(encrypted, const_encrypted, enc_size); struct ccn_pkey *symkey = NULL; struct ccn_charbuf *decrypted = NULL; struct ccn_indexbuf *decrypted_comps = ccn_indexbuf_create(); printf("trying asymmetric decryption\n"); ccn_crypto_name_asym_decrypt(server->privkey, encrypted, &symkey, &decrypted, &decrypted_comps); // ccn_crypto_name_sym_decrypt(server->node_key, encrypted, encrypted_size, &decrypted, &decrypted_comps); /* cn_crypto_name_sym_decrypt(server->node_key, encrypted, encrypted_size, &symkey, &decrypted, &decrypted_comps); */ printf("good - now creating a session\n"); unsigned char *session_id = NULL; unsigned char *session_key = NULL; unsigned char *server_rand = NULL; /* * Create a new session id and session key using the client's randomness. * The server is also responsible for contributing randomness of its own for security. */ createSession(&session_id, &session_key, &server_rand, ccn_crypto_symkey_key(symkey), (unsigned int)ccn_crypto_symkey_bytes(symkey), ccn_crypto_symkey_key(server->node_key)); printf("Session made!\n"); /* Construct the response message using a ccn name (for convenience). */ struct ccn_charbuf *session_info = ccn_charbuf_create(); ccn_name_init(session_info); ccn_name_append(session_info, session_id, SESSIONID_LENGTH); ccn_name_append(session_info, session_key, SESSION_KEYLEN); ccn_name_append(session_info, server_rand, SESSIONRAND_LENGTH); /** * Encrypt the response message using the symmetric key * provided by the client and send it out. */ unsigned char *enc_info = NULL; ccn_crypto_content_encrypt(symkey, session_info->buf, session_info->length, &enc_info, &enc_size); struct ccn_charbuf *signed_enc_info = ccn_charbuf_create(); struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; sp.type = CCN_CONTENT_DATA; res = ccn_sign_content(server->proxy->handle, signed_enc_info, request_name, &sp, enc_info, enc_size); if (res < 0) { DEBUG_PRINT("%d %s Failed to signed session creation response\n", __LINE__, __func__); } else { res = ccn_put(server->proxy->handle, signed_enc_info->buf, signed_enc_info->length); } ccn_charbuf_destroy(&decrypted); ccn_indexbuf_destroy(&decrypted_comps); ccn_crypto_symkey_destroy(&symkey); free(session_id); free(session_key); free(server_rand); free(enc_info); ccn_charbuf_destroy(&signed_enc_info); if (res < 0) { DEBUG_PRINT("%d %s Error writing session creation response\n", __LINE__, __func__); return(CCN_UPCALL_RESULT_ERR); } DEBUG_PRINT("OUT %d %s Created new session. Response sent\n", __LINE__, __func__); return(CCN_UPCALL_RESULT_INTEREST_CONSUMED); }
enum ccn_upcall_res andana_server_decap_interest( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { enum ccn_upcall_res upcall_res = CCN_UPCALL_RESULT_ERR; struct andana_server *server = selfp->data; struct ccn_proxy *proxy = server->proxy; struct ccn_charbuf *new_interest = NULL; struct ccn_charbuf *new_name = NULL; struct ccn_charbuf *orig_name = NULL; struct ccn_indexbuf *orig_name_indexbuf = NULL; int orig_name_ncomps; char is_session = 0; struct hashtb_enumerator ee; struct hashtb_enumerator *e = ⅇ int res; DEBUG_PRINT("IN %d %s\n", __LINE__, __func__); switch (kind) { case CCN_UPCALL_INTEREST: DEBUG_PRINT("%d %s received interest\n", __LINE__, __func__); break; case CCN_UPCALL_INTEREST_TIMED_OUT: DEBUG_PRINT("%d %s received interest time out\n", __LINE__, __func__); /* Fall through */ default: DEBUG_PRINT("OUT %d %s\n", __LINE__, __func__); return(CCN_UPCALL_RESULT_OK); } /* Extract Name from Interest */ orig_name_ncomps = ccn_util_extract_name(info->interest_ccnb, info->interest_comps, &orig_name, &orig_name_indexbuf); #ifdef PROXYDEBUG ccn_util_print_pc_fmt(orig_name->buf, orig_name->length); DEBUG_PRINT("\n"); DEBUG_PRINT("Name has %lu comps\n", orig_name_indexbuf->n-1); #endif /*Decapsulate & decrypt Interest. */ const unsigned char *const_encrypted = NULL; unsigned char *encrypted = NULL; size_t encrypted_size; if (orig_name_ncomps >= 2) { const unsigned char *session_check = NULL; size_t session_check_size; res = ccn_name_comp_get(orig_name->buf, orig_name_indexbuf, (unsigned int)server->SESSION_FLAG, &session_check, &session_check_size); if (res < 0) { DEBUG_PRINT("%d %s Error extracting session check component %lu\n", __LINE__, __func__, server->SESSION_FLAG); goto SessionFail; } else { DEBUG_PRINT("%d %s Extracted component %lu\n", __LINE__, __func__,server->SESSION_FLAG); } if (session_check_size == strlen("SESSION") && memcmp(session_check, "SESSION", session_check_size) == 0) { DEBUG_PRINT("%d %s Session identified\n", __LINE__, __func__); is_session = 1; } else { DEBUG_PRINT("%d %s Not a session\n", __LINE__, __func__); } } /* Decrypt the name (contains a new name and an Interest template) */ struct ccn_pkey *symkey = NULL; struct ccn_charbuf *decrypted = NULL; struct ccn_indexbuf *decrypted_comps = ccn_indexbuf_create(); if (is_session) { res = ccn_name_comp_get(orig_name->buf, orig_name_indexbuf, (unsigned int)server->SESSION_ENC, &const_encrypted, &encrypted_size); if (res < 0) { DEBUG_PRINT("%d %s Error extracting encrypted session component %lu\n", __LINE__, __func__, server->SESSION_ENC); goto SessionParseFail; } else { DEBUG_PRINT("%d %s Extracted encrypted session component %lu\n", __LINE__, __func__, server->SESSION_ENC); } encrypted = calloc(encrypted_size, sizeof(unsigned char)); memcpy(encrypted, const_encrypted, encrypted_size); ccn_crypto_name_sym_decrypt(server->node_key, encrypted, encrypted_size, &symkey, &decrypted, &decrypted_comps); } else { ccn_name_comp_get(orig_name->buf, orig_name_indexbuf, (unsigned int)server->ENC, &const_encrypted, &encrypted_size); encrypted = calloc(encrypted_size, sizeof(unsigned char)); memcpy(encrypted, const_encrypted, encrypted_size); ccn_crypto_name_asym_decrypt(server->privkey, encrypted, &symkey, &decrypted, &decrypted_comps); } size_t ncomps = decrypted_comps->n-1; const unsigned char *tmpl = NULL; size_t tmpl_size; res = ccn_name_comp_get(decrypted->buf, decrypted_comps, (unsigned int)ncomps - 1, &tmpl, &tmpl_size); if (res < 0) { DEBUG_PRINT("ABORT %d %s unable to retrieve component %d\n", __LINE__, __func__, (int)ncomps); goto CompExtractFail; } /* Pull timestamp component (comp 0) */ const unsigned char *ts_data = NULL; size_t ts_size; res = ccn_name_comp_get(decrypted->buf, decrypted_comps, 0, &ts_data, &ts_size); if (res < 0) { goto CompExtractFail; } struct timeval timestamp; ccn_util_extract_timestamp(ts_data, ts_size, ×tamp); struct timeval window = {.tv_sec = 1, .tv_usec = 600000}; if (ccn_util_timestamp_window(×tamp, &window) == 0) { /* Timestamp too far away, this may be a replay attack */ DEBUG_PRINT("%d %s Timestamp too distant\n", __LINE__, __func__); goto TimestampFail; } new_name = ccn_charbuf_create(); ccn_name_init(new_name); res = ccn_name_append_components(new_name, decrypted->buf, decrypted_comps->buf[1], decrypted_comps->buf[ncomps-1]); if (res < 0) { DEBUG_PRINT("ABORT %d %s unable to append components\n", __LINE__, __func__); goto AppendCompFail; } /*Construct new Interest*/ if (tmpl_size == 0) { /* Detected default template */ DEBUG_PRINT("%d %s Using default Interest template\n", __LINE__, __func__); new_interest = NULL; } else { DEBUG_PRINT("%d %s Copying Interest template\n", __LINE__, __func__); new_interest = ccn_charbuf_create(); ccn_charbuf_append(new_interest, tmpl, tmpl_size); } /*Map new name to that of the original Interest and the requested symkey */ hashtb_start(server->cname_to_pair, e); res = hashtb_seek(e, new_name->buf, new_name->length, 0); if (res == HT_NEW_ENTRY) { struct andana_server_pair *p = andana_server_pair_init(orig_name, symkey); struct andana_server_pair **loc = e->data; *loc = p; } else if (res == HT_OLD_ENTRY) { DEBUG_PRINT("Interest recording found old entry\n"); goto LookupFail; } else { DEBUG_PRINT("Error in Interest insertion\n"); goto LookupFail; } DEBUG_PRINT("%d %s starting to write new interest\n", __LINE__, __func__); res = ccn_express_interest(proxy->handle, new_name, proxy->content_handler, new_interest); DEBUG_PRINT("%d %s done to writing new interest\n", __LINE__, __func__); if(res != 0) { DEBUG_PRINT("ABORT %d %s express interest res = %d\n", __LINE__, __func__, res); goto SendFail; } upcall_res = CCN_UPCALL_RESULT_OK; SendFail: LookupFail: if (upcall_res == CCN_UPCALL_RESULT_ERR) { hashtb_delete(e); } hashtb_end(e); if (new_interest != NULL) { ccn_charbuf_destroy(&new_interest); } TimestampFail: AppendCompFail: ccn_charbuf_destroy(&new_name); CompExtractFail: ccn_charbuf_destroy(&decrypted); free(encrypted); ccn_crypto_symkey_destroy(&symkey); SessionParseFail: ccn_indexbuf_destroy(&decrypted_comps); SessionFail: ccn_charbuf_destroy(&orig_name); ccn_indexbuf_destroy(&orig_name_indexbuf); DEBUG_PRINT("OUT %d %s\n", __LINE__, __func__); return(upcall_res); } /** * Encapsulate and encrypt returning content objects. Encryption * uses the ephemeral symmetric key provided by the user in the original * interest (stored in a pair). * * This node will naturally sign the outgoing content object, thus providing * verifiability. */ enum ccn_upcall_res andana_server_encap_content( struct ccn_closure *selfp, enum ccn_upcall_kind kind, struct ccn_upcall_info *info) { enum ccn_upcall_res upcall_res = CCN_UPCALL_RESULT_ERR; struct andana_server *server = selfp->data; struct ccn_proxy *proxy = server->proxy; struct ccn_charbuf *new_name = NULL; struct andana_server_pair **pair_ptr = NULL; struct ccn_charbuf *new_content = NULL; struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; struct hashtb_enumerator ee; struct hashtb_enumerator *e = ⅇ int res; DEBUG_PRINT("IN %d %s\n",__LINE__, __func__); switch (kind) { case CCN_UPCALL_CONTENT: /**< incoming verified content */ DEBUG_PRINT("%d %s Incoming verified content\n",__LINE__, __func__); break; case CCN_UPCALL_CONTENT_UNVERIFIED:/**< content that has not been verified */ DEBUG_PRINT("%d %s Incoming unverified content\n", __LINE__, __func__); break; case CCN_UPCALL_CONTENT_BAD: /**< verification failed */ DEBUG_PRINT("%d %s Incoming bad content (verification failure)\n", __LINE__, __func__); break; case CCN_UPCALL_INTEREST_TIMED_OUT:/**< interest timed out */ { DEBUG_PRINT("OUT %d %s Interest timed out\n", __LINE__, __func__); const unsigned char *name = info->interest_ccnb + info->pi->offset[CCN_PI_B_Name]; const size_t length = info->pi->offset[CCN_PI_E_Name] - info->pi->offset[CCN_PI_B_Name]; hashtb_start(server->cname_to_pair, e); hashtb_seek(e, name, length, 0); hashtb_delete(e); hashtb_end(e); return(CCN_UPCALL_RESULT_OK); } case CCN_UPCALL_FINAL:/**< handler is about to be deregistered */ DEBUG_PRINT("OUT %d %s final upcall\n", __LINE__, __func__); return(CCN_UPCALL_RESULT_OK); case CCN_UPCALL_INTEREST: /**< incoming interest */ case CCN_UPCALL_CONSUMED_INTEREST: /**< incoming interest, someone has answered */ default: DEBUG_PRINT("OUT %d %s upcall other kind = %d\n", __LINE__, __func__, kind); return(CCN_UPCALL_RESULT_ERR); } DEBUG_PRINT("%d %s Received content object\n", __LINE__, __func__); if (info->content_ccnb == NULL) { DEBUG_PRINT("OUT %d %s in content upcall, but no content, check kind: %d\n", __LINE__, __func__, kind); return(CCN_UPCALL_RESULT_OK); } /*Find name in Content Object*/ new_name = ccn_charbuf_create(); ccn_name_init(new_name); ccn_name_append_components(new_name, info->content_ccnb, info->content_comps->buf[0], info->content_comps->buf[info->matched_comps]); #ifdef PROXYDEBUG DEBUG_PRINT("name matches %d comps\n", info->matched_comps); ccn_util_print_pc_fmt(info->content_ccnb + info->pco->offset[CCN_PCO_B_Name], info->pco->offset[CCN_PCO_E_Name] - info->pco->offset[CCN_PCO_B_Name]); DEBUG_PRINT("\n"); #endif pair_ptr = hashtb_lookup(server->cname_to_pair, new_name->buf, new_name->length); if(pair_ptr == NULL) { /* No match for name*/ #ifdef PROXYDEBUG DEBUG_PRINT("Unsolicited content object with name: "); ccn_util_print_pc_fmt(new_name->buf, new_name->length); DEBUG_PRINT("\n"); #endif goto LookupFail; } struct ccn_charbuf *orig_name = (*pair_ptr)->name; struct ccn_pkey *symkey = (*pair_ptr)->symkey; /*Created signed info for new content object*/ unsigned char *encrypted_content = NULL; size_t encrypted_length; struct ccn_charbuf *content = ccn_charbuf_create(); ccn_charbuf_append(content, info->content_ccnb, info->pco->offset[CCN_PCO_E]); ccn_crypto_content_encrypt(symkey, content->buf, content->length, &encrypted_content, &encrypted_length); new_content = ccn_charbuf_create(); sp.type = CCN_CONTENT_DATA; res = ccn_sign_content(proxy->handle, new_content, orig_name, &sp, encrypted_content, encrypted_length); if (ccn_util_validate_content_object(new_content->buf, new_content->length) != 0) { DEBUG_PRINT("ABORT %d %s Failed to validated signed content\n", __LINE__, __func__); abort(); goto SignFail; } else { DEBUG_PRINT("OK %d %s signed content is valid\n", __LINE__, __func__); } if (res != 0) { DEBUG_PRINT("ABORT %d %s Failed to encode ContentObject (res == %d)\n", __LINE__, __func__, res); goto SignFail; } DEBUG_PRINT("%d %s starting content write\n", __LINE__, __func__); res = ccn_put(proxy->handle, new_content->buf, new_content->length); DEBUG_PRINT("%d %s done content write line\n", __LINE__, __func__); if (res < 0) { DEBUG_PRINT("ABORT %d %s ccn_put failed (res == %d)\n", __LINE__, __func__, res); goto SendFail; } DEBUG_PRINT("%d %s Reply sent\n", __LINE__, __func__); upcall_res = CCN_UPCALL_RESULT_OK; SendFail: hashtb_start(server->cname_to_pair, e); hashtb_seek(e, new_name->buf, new_name->length, 0); hashtb_delete(e); hashtb_end(e); SignFail: ccn_charbuf_destroy(&new_content); free(encrypted_content); ccn_charbuf_destroy(&content); LookupFail: ccn_charbuf_destroy(&new_name); DEBUG_PRINT("OUT %d %s\n", __LINE__, __func__); return(upcall_res); } /** * Clean up and destroy anonymous server object. Expect * to be called once at program close. * * @param pointer to anonymous server to be destroyed * @returns 0 (always) */ int andana_server_destroy(struct andana_server **server) { struct andana_server *s = *server; free(s->proxy->int_handler); free(s->proxy->content_handler); ccn_proxy_destroy(&(s->proxy)); ccn_crypto_pubkey_destroy(&(s->privkey)); hashtb_destroy(&(s->cname_to_pair)); free(s); return(0); }
/** * Send data to the fdholder. * * No direct error result is provided; the fdholder state is updated as needed. */ PUBLIC void r_io_send(struct ccnr_handle *h, struct fdholder *fdholder, const void *data, size_t size, off_t *offsetp) { ssize_t res; off_t offset = -1; if (offsetp != NULL) *offsetp = (off_t)-1; if ((fdholder->flags & CCNR_FACE_NOSEND) != 0) return; if (fdholder->outbuf != NULL) { ccn_charbuf_append(fdholder->outbuf, data, size); return; } if (fdholder == h->face0) { ccnr_meter_bump(h, fdholder->meter[FM_BYTO], size); ccn_dispatch_message(h->internal_client, (void *)data, size); r_dispatch_process_internal_client_buffer(h); return; } if ((fdholder->flags & CCNR_FACE_CCND) != 0) { /* Writes here need to go via the direct client's handle. */ ccnr_meter_bump(h, fdholder->meter[FM_BYTO], size); res = ccn_put(h->direct_client, data, size); if (res < 0 && CCNSHOULDLOG(h, r_io_send, CCNL_WARNING)) ccnr_msg(h, "ccn_put failed"); if (res == 1 && CCNSHOULDLOG(h, r_io_send, CCNL_FINEST)) ccnr_msg(h, "ccn_put deferred output for later send"); return; } if ((fdholder->flags & CCNR_FACE_REPODATA) != 0) { offset = lseek(fdholder->filedesc, 0, SEEK_END); if (offset == (off_t)-1) { ccnr_msg(h, "lseek(%d): %s", fdholder->filedesc, strerror(errno)); return; } if (offsetp != NULL) *offsetp = offset; if (fdholder->filedesc == h->active_out_fd) { if (offset != h->stable && h->stable != 0) ccnr_msg(h, "expected file size %ju, found %ju", (uintmax_t)h->stable, (uintmax_t)offset); h->stable = offset + size; } } if ((fdholder->flags & CCNR_FACE_DGRAM) == 0) res = write(fdholder->filedesc, data, size); else res = sendto(sending_fd(h, fdholder), data, size, 0, (struct sockaddr *)fdholder->name->buf, fdholder->name->length); if (res > 0) ccnr_meter_bump(h, fdholder->meter[FM_BYTO], res); if (res == size) return; if (res == -1) { res = handle_send_error(h, errno, fdholder, data, size); if (res == -1) return; } if ((fdholder->flags & CCNR_FACE_DGRAM) != 0) { ccnr_msg(h, "sendto short"); return; } if ((fdholder->flags & CCNR_FACE_REPODATA) != 0) { // need to truncate back to last known good object then exit. ccnr_msg(h, "Unrecoverable write error writing to repository. Content NOT stored."); ftruncate(fdholder->filedesc, offset); h->running = 0; return; } fdholder->outbufindex = 0; fdholder->outbuf = ccn_charbuf_create(); if (fdholder->outbuf == NULL) { ccnr_msg(h, "do_write: %s", strerror(errno)); return; } ccn_charbuf_append(fdholder->outbuf, ((const unsigned char *)data) + res, size - 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); }
int main(void) { int res; struct ccn *ccn= NULL; struct ccn_charbuf *name = NULL; struct ccn_charbuf *result = NULL; struct ccn_closure in_interest = {.p=&incoming_interest}; struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; // Parameters for creating signed content objects. char rawcontentbuf[1024] = ""; size_t content_size; // 1. Name name = ccn_charbuf_create(); res = ccn_name_from_uri(name, URI); if (res < 0) { fprintf(stderr, "bad ccn URI: %s\n", URI); exit(1); } // 2. ccn_create, and ccn_connect ccn = ccn_create(); res = ccn_connect(ccn, NULL); if (res < 0) { fprintf(stderr, "can't connect to ccnd: %d\n", res); ccn_perror(ccn, "ccn_connect"); exit(1); } // 3. Create the signed content object, set up &sp - signing params; // Extend a Name with a new version stamp if requested /*int versioned = 0; const char *postver = NULL; memcmp(postver, "%00", 3); if (versioned) { res = ccn_create_version(ccn, name, CCN_V_REPLACE | CCN_V_NOW | CCN_V_HIGH, 0, 0); if (res < 0) { fprintf(stderr, "%s: ccn_create_version() failed\n"); exit(1); } if (postver != NULL) { res = ccn_name_from_uri(name, postver); if (res < 0) { fprintf(stderr, "-V %s: invalid name suffix\n", postver); exit(0); } } } */ // Ask for a FinalBlockID if appropriate /*int setfinal = 0; if (setfinal) sp.sp_flags |= CCN_SP_FINAL_BLOCK; */ // Set content type //sp.type = content_type; // Set freshness /* The template_ccnb may contain a ccnb-encoded SignedInfo to supply selected fields from under * the direction of sp_flags. */ /*int expire = -1; if (expire >= 0) { if (sp.template_ccnb == NULL) { sp.template_ccnb = ccn_charbuf_create(); ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_SignedInfo, CCN_DTAG); } else if (sp.template_ccnb -> length > 0) { sp.template_ccnb -> length--; } ccnb_tagged_putf(sp.template_ccnb, CCN_DTAG_FreshnessSeconds, "%ld", expire); sp.sp_flags |= CCN_SP_TEMPL_FRESHNESS; ccn_charbuf_append_closer(sp.template_ccnb); } */ // Set key locator, if supplied /*const char *key_uri = NULL; //key_uri = optarg; if (key_uri != NULL) { struct ccn_charbuf *c = ccn_charbuf_create(); res = ccn_name_from_uri(c, key_uri); if (res < 0) { fprintf(stderr, "%s is not a valid ccnx URI\n", key_uri); exit(1); } if (sp.template_ccnb == NULL) { sp.template_ccnb = ccn_charbuf_create(); ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_SignedInfo, CCN_DTAG); } else if (sp.template_ccnb -> length > 0) { sp.template_ccnb -> length--; } ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_KeyLocator, CCN_DTAG); ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_KeyName, CCN_DTAG); ccn_charbuf_append(sp.template_ccnb, c->buf, c->length); ccn_charbuf_append_closer(sp.template_ccnb); ccn_charbuf_append_closer(sp.template_ccnb); sp.sp_flags |= CCN_SP_TEMPL_KEY_LOCATOR; ccn_charbuf_append_closer(sp.template_ccnb); ccn_charbuf_destroy(&c); } */ // Set up a handler for interest ccn_set_interest_filter(ccn, name, &in_interest); // 4. Use ccn_sign_content to create the signed content object with composed &sp, // if (force) { ccn_put; } # ccn_get means send ccn binary. For normal clients, this should be a ContentObject sent in response to an Interest. // else { ccn_set_interest_filter; ccn_run; } result = ccn_charbuf_create(); result -> length = 0; strcat(rawcontentbuf, CONTENTDATA); content_size = strlen(rawcontentbuf); //sp.sp_flags |= CCN_SP_FINAL_BLOCK; res = ccn_sign_content(ccn, result, name, &sp, rawcontentbuf, content_size); if (res < 0) { ccn_perror(ccn, "ccn_sign_content"); exit(1); } printf("Content signed, trying to send the data...\n"); res = ccn_put(ccn, result->buf, result->length); if (res < 0) { ccn_perror(ccn, "ccn_put"); printf("Failed to send content object: res = %d\n", res); exit(1); } else printf("ccn_put done, content object sent.\n"); // ccn_run serves as the event loop when timeout = -1 res = ccn_run(ccn, -1); // Loop here all the time until it is killed, then "Event loop..." printf("Event loop...\n"); if (res < 0) { ccn_perror(ccn, "ccn_run"); printf("Error: ccn_run\n"); exit(1); } ccn_destroy(&ccn); ccn_charbuf_destroy(&name); ccn_charbuf_destroy(&result); ccn_charbuf_destroy(&sp.template_ccnb); printf("ccn handle is destroyed... \n"); return 0; }
/* does that mean the last component is the implicit digest ? */ enum ccn_upcall_res packet_handler(struct ccn_closure *selfp, enum ccn_upcall_kind upcall_kind, struct ccn_upcall_info *info) { handler_data* h_data = (handler_data*) selfp->data; // Client data returned fprintf(stderr, "\nUpcall from %s handle\n", (info->h==(*h_data->ccn_rec))? "receiver":"publisher"); ccn_set_run_timeout(info->h, 0); // Return to client faster switch(upcall_kind) { case CCN_UPCALL_FINAL: fprintf(stderr, "CCN_UPCALL_FINAL\n"); return (CCN_UPCALL_RESULT_OK); case CCN_UPCALL_INTEREST_TIMED_OUT: fprintf(stderr, "CCN_UPCALL_INTEREST_TIMED_OUT\n"); (*h_data->complete) = 1; // End the main loop, some sort of problem return (CCN_UPCALL_RESULT_OK); case CCN_UPCALL_CONTENT: fprintf(stderr, "CCN_UPCALL_CONTENT\n"); const unsigned char* content = NULL; size_t content_bytes = 0; ccn_ref_tagged_BLOB(CCN_DTAG_Content, info->content_ccnb, info->pco->offset[CCN_PCO_B_Content], info->pco->offset[CCN_PCO_E_Content], &content, &content_bytes); fprintf(stderr, "\tContent: %s\n", content); (*h_data->outstanding_interests)--; return (CCN_UPCALL_RESULT_OK); case CCN_UPCALL_CONTENT_UNVERIFIED: fprintf(stderr, "CCN_UPCALL_CONTENT_UNVERIFIED\n"); return (CCN_UPCALL_RESULT_OK); case CCN_UPCALL_CONTENT_BAD: fprintf(stderr, "CCN_UPCALL_CONTENT_BAD\n"); return (CCN_UPCALL_RESULT_OK); case CCN_UPCALL_CONSUMED_INTEREST: fprintf(stderr, "CCN_UPCALL_CONSUMED_INTEREST\n"); return (CCN_UPCALL_RESULT_OK); case CCN_UPCALL_INTEREST: fprintf(stderr, "CCN_UPCALL_INTEREST, (matched comp == %d)\n", info->matched_comps); fprintf(stderr, " (interest comps == %zu)\n", info->interest_comps->n); int res = 0; // Corrected 20-May-2011 to support interests with additional components after prefix // if (info->interest_comps->n < 3) { // Name + signature + implicit digest, minimum fprintf(stderr, "\tnot enough components, %zu<3\n", info->interest_comps->n); } else { // Verify the interest res = verify_signed_interest(info->interest_ccnb, info->interest_comps, info->interest_comps->n-2, info->interest_comps->buf[0], info->interest_comps->buf[info->interest_comps->n-2], (*h_data->public_key)); fprintf(stderr, "\tverify_signed_interest == %d (%s)\n", res, (res==1)?"verified":"unverified"); } // Based on the results, // create and send a reply using default key & algorithm for the receiving handle // to sign the content object. // char* reply_data = (res==1) ? "OK" : "AUTH_FAIL"; // A modest content. struct ccn_charbuf* reply = ccn_charbuf_create(); struct ccn_charbuf* name = ccn_charbuf_create(); struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; ccn_name_init(name); // Don't need to create a new name, could just index into the buffer. res = ccn_name_append_components(name, info->interest_ccnb, info->interest_comps->buf[0], info->interest_comps->buf[info->interest_comps->n - 1]); ccn_sign_content(info->h, reply, name, &sp, (void*)reply_data, strlen(reply_data)+1); res = ccn_put(info->h, reply->buf, reply->length); ccn_charbuf_destroy(&reply); ccn_charbuf_destroy(&name); if (res >= 0) { fprintf (stderr, "\tReturned Content: %s\n", reply_data); return (CCN_UPCALL_RESULT_INTEREST_CONSUMED); } return (CCN_UPCALL_RESULT_OK); } return (CCN_UPCALL_RESULT_ERR); }
void GroupManager::incomingInterest(ccn_upcall_info *info) { int res; const char *data = NULL; const unsigned char *requester = NULL; const unsigned char *refresher = NULL; const unsigned char *filter = NULL; size_t filter_len = 0; ccn_charbuf *signed_info = NULL; ccn_charbuf *name = NULL; ccn_charbuf *content = NULL; RemoteUser *refreshUser = NULL; // requesterPrefix starts from index 4 to (info->interest_comps->n - 2) int nameEnd = 0; nameEnd = (info->interest_comps)->n - 2; /* construct reply data * name format: * /ndn/broadcast/conference/conference-name/speaker-list/username */ signed_info = ccn_charbuf_create(); struct ccn_charbuf *keylocator = ccn_charbuf_create(); ccn_create_keylocator(keylocator, ccn_keystore_public_key(cached_keystore)); 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*/ -1, /*freshness*/ FRESHNESS, /*finalblockid*/ NULL, /*keylocator*/ keylocator); if (res < 0) { DPRINT("FAILED TO CREATE signed_info (res == %d)", res); } name = ccn_charbuf_create(); content = ccn_charbuf_create(); ccn_name_init(name); ccn_name_append_components(name, info->interest_ccnb, info->interest_comps->buf[0], info->interest_comps->buf[nameEnd + 1]); // append own username ccn_name_append_str(name, userName.toLocal8Bit().constData()); // get user list, the caller need to free the data buffer allocated int dlen = userListtoXml(&data); ccn_encode_ContentObject(content, name, signed_info, data, dlen, NULL, get_my_private_key()); // already have the lock, no need to trylock ccn_put(info->h, content->buf, content->length); ccn_charbuf_destroy(&signed_info); ccn_charbuf_destroy(&name); ccn_charbuf_destroy(&content); if (data != NULL) { free((void *)data); data = NULL; } }
int main(int argc, char **argv) { const char *progname = argv[0]; struct ccn *ccn = NULL; struct ccn_charbuf *name = NULL; struct ccn_charbuf *pname = NULL; struct ccn_charbuf *temp = NULL; struct ccn_charbuf *extopt = NULL; long expire = -1; int versioned = 0; size_t blocksize = 8*1024; int status = 0; int res; ssize_t read_res; unsigned char *buf = NULL; enum ccn_content_type content_type = CCN_CONTENT_DATA; struct ccn_closure in_interest = {.p=&incoming_interest}; const char *postver = NULL; const char *key_uri = NULL; int force = 0; int verbose = 0; int timeout = -1; int setfinal = 0; int prefixcomps = -1; int fd; struct ccn_signing_params sp = CCN_SIGNING_PARAMS_INIT; while ((res = getopt(argc, argv, "e:fhk:lvV:p:t:w:x:")) != -1) { switch (res) { case 'e': if (extopt == NULL) extopt = ccn_charbuf_create(); fd = open(optarg, O_RDONLY); if (fd < 0) { perror(optarg); exit(1); } for (;;) { read_res = read(fd, ccn_charbuf_reserve(extopt, 64), 64); if (read_res <= 0) break; extopt->length += read_res; } if (read_res < 0) perror(optarg); close(fd); break; case 'f': force = 1; break; case 'l': setfinal = 1; // set FinalBlockID to last comp of name break; case 'k': key_uri = optarg; break; case 'p': prefixcomps = atoi(optarg); if (prefixcomps < 0) usage(progname); break; case 'x': expire = atol(optarg); if (expire <= 0) usage(progname); break; case 'v': verbose = 1; break; case 'V': versioned = 1; postver = optarg; if (0 == memcmp(postver, "%00", 3)) setfinal = 1; break; case 'w': timeout = atol(optarg); if (timeout <= 0) usage(progname); timeout *= 1000; break; case 't': if (0 == strcasecmp(optarg, "DATA")) { content_type = CCN_CONTENT_DATA; break; } if (0 == strcasecmp(optarg, "ENCR")) { content_type = CCN_CONTENT_ENCR; break; } if (0 == strcasecmp(optarg, "GONE")) { content_type = CCN_CONTENT_GONE; break; } if (0 == strcasecmp(optarg, "KEY")) { content_type = CCN_CONTENT_KEY; break; } if (0 == strcasecmp(optarg, "LINK")) { content_type = CCN_CONTENT_LINK; break; } if (0 == strcasecmp(optarg, "NACK")) { content_type = CCN_CONTENT_NACK; break; } content_type = atoi(optarg); if (content_type > 0 && content_type <= 0xffffff) break; fprintf(stderr, "Unknown content type %s\n", optarg); /* FALLTHRU */ 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); /* Preserve the original prefix, in case we add versioning, * but trim it down if requested for the interest filter registration */ pname = ccn_charbuf_create(); ccn_charbuf_append(pname, name->buf, name->length); if (prefixcomps >= 0) { res = ccn_name_chop(pname, NULL, prefixcomps); if (res < 0) { fprintf(stderr, "%s: unable to trim name to %d component%s.\n", progname, prefixcomps, prefixcomps == 1 ? "" : "s"); exit(1); } } /* Connect to ccnd */ ccn = ccn_create(); if (ccn_connect(ccn, NULL) == -1) { perror("Could not connect to ccnd"); exit(1); } /* Read the actual user data from standard input */ buf = calloc(1, blocksize); read_res = read_full(0, buf, blocksize); if (read_res < 0) { perror("read"); read_res = 0; status = 1; } /* Tack on the version component if requested */ if (versioned) { res = ccn_create_version(ccn, name, CCN_V_REPLACE | CCN_V_NOW | CCN_V_HIGH, 0, 0); if (res < 0) { fprintf(stderr, "%s: ccn_create_version() failed\n", progname); exit(1); } if (postver != NULL) { res = ccn_name_from_uri(name, postver); if (res < 0) { fprintf(stderr, "-V %s: invalid name suffix\n", postver); exit(0); } } } temp = ccn_charbuf_create(); /* Ask for a FinalBlockID if appropriate. */ if (setfinal) sp.sp_flags |= CCN_SP_FINAL_BLOCK; if (res < 0) { fprintf(stderr, "Failed to create signed_info (res == %d)\n", res); exit(1); } /* Set content type */ sp.type = content_type; /* Set freshness */ if (expire >= 0) { if (sp.template_ccnb == NULL) { sp.template_ccnb = ccn_charbuf_create(); ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_SignedInfo, CCN_DTAG); } else if (sp.template_ccnb->length > 0) { sp.template_ccnb->length--; } ccnb_tagged_putf(sp.template_ccnb, CCN_DTAG_FreshnessSeconds, "%ld", expire); sp.sp_flags |= CCN_SP_TEMPL_FRESHNESS; ccn_charbuf_append_closer(sp.template_ccnb); } /* Set key locator, if supplied */ if (key_uri != NULL) { struct ccn_charbuf *c = ccn_charbuf_create(); res = ccn_name_from_uri(c, key_uri); if (res < 0) { fprintf(stderr, "%s is not a valid ccnx URI\n", key_uri); exit(1); } if (sp.template_ccnb == NULL) { sp.template_ccnb = ccn_charbuf_create(); ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_SignedInfo, CCN_DTAG); } else if (sp.template_ccnb->length > 0) { sp.template_ccnb->length--; } ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_KeyLocator, CCN_DTAG); ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_KeyName, CCN_DTAG); ccn_charbuf_append(sp.template_ccnb, c->buf, c->length); ccn_charbuf_append_closer(sp.template_ccnb); ccn_charbuf_append_closer(sp.template_ccnb); sp.sp_flags |= CCN_SP_TEMPL_KEY_LOCATOR; ccn_charbuf_append_closer(sp.template_ccnb); ccn_charbuf_destroy(&c); } if (extopt != NULL && extopt->length > 0) { if (sp.template_ccnb == NULL) { sp.template_ccnb = ccn_charbuf_create(); ccn_charbuf_append_tt(sp.template_ccnb, CCN_DTAG_SignedInfo, CCN_DTAG); } else if (sp.template_ccnb->length > 0) { sp.template_ccnb->length--; } ccnb_append_tagged_blob(sp.template_ccnb, CCN_DTAG_ExtOpt, extopt->buf, extopt->length); sp.sp_flags |= CCN_SP_TEMPL_EXT_OPT; ccn_charbuf_append_closer(sp.template_ccnb); } /* Create the signed content object, ready to go */ temp->length = 0; res = ccn_sign_content(ccn, temp, name, &sp, buf, read_res); if (res != 0) { fprintf(stderr, "Failed to encode ContentObject (res == %d)\n", res); exit(1); } if (read_res == blocksize) { read_res = read_full(0, buf, 1); if (read_res == 1) { fprintf(stderr, "%s: warning - truncated data\n", argv[0]); status = 1; } } free(buf); buf = NULL; if (force) { /* At user request, send without waiting to see an interest */ res = ccn_put(ccn, temp->buf, temp->length); if (res < 0) { fprintf(stderr, "ccn_put failed (res == %d)\n", res); exit(1); } } else { in_interest.data = temp; /* Set up a handler for interests */ res = ccn_set_interest_filter(ccn, pname, &in_interest); if (res < 0) { fprintf(stderr, "Failed to register interest (res == %d)\n", res); exit(1); } res = ccn_run(ccn, timeout); if (in_interest.intdata == 0) { if (verbose) fprintf(stderr, "Nobody's interested\n"); exit(1); } } if (verbose) { struct ccn_charbuf *uri = ccn_charbuf_create(); uri->length = 0; ccn_uri_append(uri, name->buf, name->length, 1); printf("wrote %s\n", ccn_charbuf_as_string(uri)); ccn_charbuf_destroy(&uri); } ccn_destroy(&ccn); ccn_charbuf_destroy(&name); ccn_charbuf_destroy(&pname); ccn_charbuf_destroy(&temp); ccn_charbuf_destroy(&sp.template_ccnb); ccn_charbuf_destroy(&extopt); exit(status); }