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