static void riot_ccn_pit_test(int argc, char **argv)
{
(void) argc; /* the function takes no arguments */
(void) argv;
char name[] = "/riot/test";
char *prefix[CCNL_MAX_NAME_COMP];
char *cp = strtok(name, "/");
int i = 0;
while (i < (CCNL_MAX_NAME_COMP - 1) && cp) {
prefix[i++] = cp;
cp = strtok(NULL, "/");
}
//prefix[i] = 0; //segment to request
prefix[i + 1] = 0;
msg_t m;
riot_ccnl_msg_t rmsg;
char segment_string[16]; //max=999\0
timex_t now;
int segment;
for (segment = 0; segment < 200; segment++) {
memset(segment_string, 0, 16);
snprintf(segment_string, 16, "%d", segment);
prefix[i] = segment_string;
unsigned int interest_nonce = genrand_uint32();
int interest_len = mkInterest(prefix, &interest_nonce, (unsigned char *) small_buf);
rmsg.payload = &small_buf;
rmsg.size = interest_len;
m.content.ptr = (char *) &rmsg;
m.type = CCNL_RIOT_MSG;
msg_send(&m, relay_pid);
if ((segment % 50) == 0) {
vtimer_now(&now);
printf("done: %d - %ld.%ld\n", segment, now.tv_sec, now.tv_usec);
}
}
printf("done: tried to send %d interests\n", segment);
}
int
ccnl_fetchContentForChunkName(struct ccnl_prefix_s *prefix,
char* nfnexpr,
unsigned int *chunknum,
int suite,
unsigned char *out, int out_len,
int *len,
float wait, int sock, struct sockaddr sa) {
#ifdef USE_SUITE_CCNB
if (suite == CCNL_SUITE_CCNB) {
DEBUGMSG(ERROR, "CCNB not implemented\n");
exit(-1);
}
#endif
ccnl_mkInterestFunc mkInterest = ccnl_suite2mkInterestFunc(suite);
if (!mkInterest) {
DEBUGMSG(ERROR, "unknown suite %d/not implemented\n", suite);
exit(-1);
}
int nonce = random();
*len = mkInterest(prefix, &nonce, out, out_len);
/*
{
int fd = open("outgoing.bin", O_WRONLY|O_CREAT|O_TRUNC);
write(fd, out, *len);
close(fd);
}
*/
if (sendto(sock, out, *len, 0, &sa, sizeof(sa)) < 0) {
perror("sendto");
myexit(1);
}
if (block_on_read(sock, wait) <= 0) {
DEBUGMSG(WARNING, "timeout after block_on_read\n");
return -1;
}
*len = recv(sock, out, out_len, 0);
/*
{
int fd = open("incoming.bin", O_WRONLY|O_CREAT|O_TRUNC);
write(fd, out, *len);
close(fd);
}
*/
return 0;
}
int
main(int argc, char *argv[])
{
unsigned char out[64*1024];
int cnt, len, opt, sock = 0, socksize, suite = CCNL_SUITE_DEFAULT, port;
char *addr = NULL, *udp = NULL, *ux = NULL;
char *defaultNFNpath = "";//strdup("/ndn/ch/unibas/nfn");
struct sockaddr sa;
struct ccnl_prefix_s *prefix;
float wait = 3.0;
ccnl_mkInterestFunc mkInterest;
ccnl_isContentFunc isContent;
while ((opt = getopt(argc, argv, "hn:s:u:v:w:x:")) != -1) {
switch (opt) {
case 'n':
defaultNFNpath = optarg;
break;
case 's':
opt = ccnl_str2suite(optarg);
if (opt < 0 || opt >= CCNL_SUITE_LAST)
goto usage;
suite = opt;
break;
case 'u':
udp = optarg;
break;
case 'v':
#ifdef USE_LOGGING
if (isdigit(optarg[0]))
debug_level = atoi(optarg);
else
debug_level = ccnl_debug_str2level(optarg);
#endif
break;
case 'w':
wait = atof(optarg);
break;
case 'x':
ux = optarg;
break;
case 'h':
default:
usage:
fprintf(stderr, "usage: %s [options] NFNexpr\n"
" -n NFNPATH default prefix towards some NFN node(s)\n"
" -s SUITE (ccnb, ccnx2015, cisco2015, iot2014, ndn2013)\n"
" -u a.b.c.d/port UDP destination (default is 127.0.0.1/6363)\n"
#ifdef USE_LOGGING
" -v DEBUG_LEVEL (fatal, error, warning, info, debug, verbose, trace)\n"
#endif
" -w timeout in sec (float)\n"
" -x ux_path_name UNIX IPC: use this instead of UDP\n"
"Examples:\n"
"%% simplenfn /ndn/edu/wustl/ping\n"
"%% simplenfn \"echo hello world\"\n"
"%% simplenfn \"translate 'ccnx2014 /ccnx/parc/info.txt\"\n"
"%% simplenfn \"add 1 1\"\n",
argv[0]);
exit(1);
}
}
if (!argv[optind] || argv[optind+1])
goto usage;
srandom(time(NULL));
if (ccnl_parseUdp(udp, suite, &addr, &port) != 0) {
exit(-1);
}
DEBUGMSG(TRACE, "using udp address %s/%d\n", addr, port);
mkInterest = ccnl_suite2mkInterestFunc(suite);
isContent = ccnl_suite2isContentFunc(suite);
if (!mkInterest || !isContent) {
exit(-1);
}
if (ux) { // use UNIX socket
struct sockaddr_un *su = (struct sockaddr_un*) &sa;
su->sun_family = AF_UNIX;
strcpy(su->sun_path, ux);
sock = ux_open();
} else { // UDP
struct sockaddr_in *si = (struct sockaddr_in*) &sa;
si->sin_family = PF_INET;
si->sin_addr.s_addr = inet_addr(addr);
si->sin_port = htons(port);
sock = udp_open();
}
prefix = exprToNfnPrefix(defaultNFNpath, suite, argv[optind]);
if (!prefix)
goto done;
for (cnt = 0; cnt < 3; cnt++) {
int nonce = random();
len = mkInterest(prefix,
&nonce,
out, sizeof(out));
DEBUGMSG(TRACE,
"sending interest(prefix=%s, suite=%s)\n",
ccnl_prefix_to_path(prefix),
ccnl_suite2str(suite));
if(ux) {
socksize = sizeof(struct sockaddr_un);
} else {
socksize = sizeof(struct sockaddr_in);
}
if (sendto(sock, out, len, 0,(struct sockaddr *) &sa, socksize) < 0) {
perror("sendto");
myexit(1);
}
for (;;) { // wait for a content pkt (ignore interests)
int rc;
if (block_on_read(sock, wait) <= 0) // timeout
break;
len = recv(sock, out, sizeof(out), 0);
/*
fprintf(stderr, "received %d bytes\n", len);
if (len > 0)
fprintf(stderr, " suite=%d\n", ccnl_pkt2suite(out, len));
*/
rc = isContent(out, len);
if (rc < 0)
goto done;
if (rc == 0) { // it's an interest, ignore it
DEBUGMSG(WARNING, "skipping non-data packet\n");
continue;
}
write(1, out, len);
myexit(0);
}
if (cnt < 2)
DEBUGMSG(INFO, "re-sending interest\n");
}
DEBUGMSG(ERROR, "timeout\n");
done:
close(sock);
myexit(-1);
return 0; // avoid a compiler warning
}
int ccnl_riot_client_get(kernel_pid_t relay_pid, char *name, char *reply_buf)
{
char *prefix[CCNL_MAX_NAME_COMP];
char *cp = strtok(name, "/");
int i = 0;
while (i < (CCNL_MAX_NAME_COMP - 1) && cp) {
prefix[i++] = cp;
cp = strtok(NULL, "/");
}
//prefix[i] = 0; //segment to request
prefix[i + 1] = 0;
int content_len = 0;
for (int segment = 0; ; segment++) {
char segment_string[16]; //max=999\0
memset(segment_string, 0, 16);
snprintf(segment_string, 16, "%d", segment);
prefix[i] = segment_string;
unsigned char *interest_pkg = malloc(PAYLOAD_SIZE);
if (!interest_pkg) {
puts("ccnl_riot_client_get: malloc failed");
return 0;
}
unsigned int interest_nonce = genrand_uint32();
int interest_len = mkInterest(prefix, &interest_nonce, interest_pkg);
DEBUGMSG(1, "relay_pid=%" PRIkernel_pid " interest_len=%d\n", relay_pid, interest_len);
riot_ccnl_msg_t rmsg;
rmsg.payload = interest_pkg;
rmsg.size = interest_len;
msg_t m, rep;
m.content.ptr = (char *) &rmsg;
m.type = CCNL_RIOT_MSG;
msg_send(&m, relay_pid, 1);
/* ######################################################################### */
msg_receive(&rep);
free(interest_pkg);
if (rep.type == CCNL_RIOT_NACK) {
/* network stack was not able to fetch this chunk */
return 0;
}
/* we got a chunk of data from the network stack */
riot_ccnl_msg_t *rmsg_reply = (riot_ccnl_msg_t *) rep.content.ptr;
unsigned char *data = rmsg_reply->payload;
int datalen = (int) rmsg_reply->size;
DEBUGMSG(1, "%d bytes left; msg from=%" PRIkernel_pid "\n", datalen, rep.sender_pid);
int scope = 3, aok = 3, minsfx = 0, maxsfx = CCNL_MAX_NAME_COMP,
contlen = 0;
struct ccnl_buf_s *buf = 0, *nonce = 0, *ppkd = 0;
struct ccnl_prefix_s *p = 0;
unsigned char *content = 0;
buf = ccnl_extract_prefix_nonce_ppkd(&data, &datalen, &scope, &aok, &minsfx,
&maxsfx, &p, &nonce, &ppkd, &content, &contlen);
if (!buf) {
DEBUGMSG(6, " parsing error or no prefix\n");
return 0;
}
DEBUGMSG(1, "content_len=%d contlen=%d\n", content_len, contlen);
memcpy(reply_buf + content_len, content, contlen);
content_len += contlen;
free_prefix(p);
free_3ptr_list(buf, nonce, ppkd);
ccnl_free(rmsg_reply);
DEBUGMSG(1, "contentlen=%d CCNL_RIOT_CHUNK_SIZE=%d\n", contlen, CCNL_RIOT_CHUNK_SIZE);
if (contlen < CCNL_RIOT_CHUNK_SIZE || CCNL_RIOT_CHUNK_SIZE < contlen) {
/* last chunk */
break;
}
}
return content_len;
}