void
ccnl_simu_add_fwd(char node, const char *name, char dstnode)
{
struct ccnl_relay_s *relay = char2relay(node), *dst = char2relay(dstnode);
struct ccnl_forward_s *fwd;
sockunion sun;
char *cp;
DEBUGMSG(TRACE, "ccnl_simu_add_fwd\n");
sun.eth.sll_family = AF_PACKET;
memcpy(sun.eth.sll_addr, dst->ifs[0].addr.eth.sll_addr, ETH_ALEN);
fwd = (struct ccnl_forward_s *) ccnl_calloc(1, sizeof(*fwd));
// fwd->prefix = ccnl_path_to_prefix(name);
cp = ccnl_strdup(name);
fwd->prefix = ccnl_URItoPrefix(cp, theSuite, NULL, NULL);
ccnl_free(cp);
fwd->suite = theSuite;
fwd->face = ccnl_get_face_or_create(relay, 0, &sun.sa, sizeof(sun.eth));
#ifdef USE_FRAG
// fwd->face->frag = ccnl_frag_new(CCNL_FRAG_SEQUENCED2012, 1500);
fwd->face->frag = ccnl_frag_new(CCNL_FRAG_CCNx2013, 1200);
#endif
fwd->face->flags |= CCNL_FACE_FLAGS_STATIC;
fwd->next = relay->fib;
relay->fib = fwd;
}
static struct ccnl_face_s *_intern_face_get(char *addr_str)
{
/* initialize address with 0xFF for broadcast */
size_t addr_len = (strlen(addr_str) + 1) / 3;
uint8_t relay_addr[addr_len];
memset(relay_addr, UINT8_MAX, addr_len);
addr_len = gnrc_netif_addr_from_str(relay_addr, sizeof(relay_addr), addr_str);
if (addr_len == 0) {
printf("Error: %s is not a valid link layer address\n", addr_str);
return NULL;
}
sockunion sun;
sun.sa.sa_family = AF_PACKET;
memcpy(&(sun.linklayer.sll_addr), relay_addr, addr_len);
sun.linklayer.sll_halen = addr_len;
sun.linklayer.sll_protocol = htons(ETHERTYPE_NDN);
int i;
uint16_t devType;
for(i = 0; i < ccnl_relay.ifcount; i++) {
gnrc_netapi_get(ccnl_relay.ifs[i].if_pid, NETOPT_DEVICE_TYPE, 0, &devType, sizeof(devType));
if( (addr_len == 8 && devType == NETDEV2_TYPE_IEEE802154) || (addr_len == 6 && devType == NETDEV2_TYPE_ETHERNET) )
break;
}
return ccnl_get_face_or_create(&ccnl_relay, ccnl_relay.ifs[i].if_pid, &sun.sa, sizeof(sun.linklayer));
}
void
ccnl_core_RX(struct ccnl_relay_s *relay, int ifndx, unsigned char *data,
int datalen, struct sockaddr *sa, int addrlen)
{
unsigned char *base = data;
struct ccnl_face_s *from;
int enc, suite = -1, skip;
dispatchFct dispatch;
(void) base; // silence compiler warning (if USE_DEBUG is not set)
DEBUGMSG_CORE(DEBUG, "ccnl_core_RX ifndx=%d, %d bytes\n", ifndx, datalen);
// DEBUGMSG_ON(DEBUG, "ccnl_core_RX ifndx=%d, %d bytes\n", ifndx, datalen);
#ifdef USE_STATS
if (ifndx >= 0)
relay->ifs[ifndx].rx_cnt++;
#endif
from = ccnl_get_face_or_create(relay, ifndx, sa, addrlen);
if (!from) {
DEBUGMSG_CORE(DEBUG, " no face\n");
return;
} else {
DEBUGMSG_CORE(DEBUG, " face %d, peer=%s\n", from->faceid,
ccnl_addr2ascii(&from->peer));
}
// loop through all packets in the received frame (UDP, Ethernet etc)
while (datalen > 0) {
// work through explicit code switching
while (!ccnl_switch_dehead(&data, &datalen, &enc))
suite = ccnl_enc2suite(enc);
if (suite == -1)
suite = ccnl_pkt2suite(data, datalen, &skip);
if (!ccnl_isSuite(suite)) {
DEBUGMSG_CORE(WARNING, "?unknown packet format? ccnl_core_RX ifndx=%d, %d bytes starting with 0x%02x at offset %zd\n",
ifndx, datalen, *data, data - base);
return;
}
// dispatch = ccnl_core_RX_dispatch[suite];
dispatch = ccnl_core_suites[suite].RX;
if (!dispatch) {
DEBUGMSG_CORE(ERROR, "Forwarder not initialized or dispatcher "
"for suite %s does not exist.\n", ccnl_suite2str(suite));
return;
}
if (dispatch(relay, from, &data, &datalen) < 0)
break;
if (datalen > 0) {
DEBUGMSG_CORE(WARNING, "ccnl_core_RX: %d bytes left\n", datalen);
}
}
}
static int
ccnl_crypto_create_ccnl_crypto_face(struct ccnl_relay_s *relay, char *ux_path)
{
sockunion su;
DEBUGMSG(DEBUG, " adding UNIX face unixsrc=%s\n", ux_path);
su.sa.sa_family = AF_UNIX;
strcpy(su.ux.sun_path, (char*) ux_path);
relay->crypto_face = ccnl_get_face_or_create(relay, -1, &su.sa, sizeof(struct sockaddr_un));
if(!relay->crypto_face) return 0;
relay->crypto_face->flags = CCNL_FACE_FLAGS_STATIC;
return 1;
}
void
ccnl_core_RX(struct ccnl_relay_s *relay, int ifndx, unsigned char *data,
int datalen, uint16_t sender_id)
{
struct ccnl_face_s *from;
DEBUGMSG(14, "ccnl_core_RX ifndx=%d, %d bytes\n", ifndx, datalen);
from = ccnl_get_face_or_create(relay, ifndx, sender_id);
if (!from) {
return;
}
DEBUGMSG(1, "ccnl_core_RX: faceid=%d frag=%p\n", from->faceid, (void *) from->frag);
ccnl_core_RX_datagram(relay, from, &data, &datalen);
}
int
main(int argc, char **argv)
{
int opt;
int udpport = 0;
char *prefix, *defaultgw;
struct ccnl_if_s *i;
struct ccnl_forward_s *fwd;
sockunion sun;
srandom(time(NULL));
int suite = CCNL_SUITE_NDNTLV;
while ((opt = getopt(argc, argv, "hs:u:v:")) != -1) {
switch (opt) {
case 's':
opt = ccnl_str2suite(optarg);
if (opt >= 0 && opt < CCNL_SUITE_LAST)
suite = opt;
else
fprintf(stderr, "Suite parameter <%s> ignored.\n", optarg);
break;
case 'u':
udpport = atoi(optarg);
break;
case 'v':
debug_level = atoi(optarg);
break;
case 'h':
default:
usage:
fprintf(stderr,
"usage: %s [options] PREFIX DGWIP/DGWUDPPORT\n"
"options: [-h] [-s SUITE] [-u udpport] [-v debuglevel]\n"
"example: %s /ndn 128.252.153.194/6363\n",
argv[0], argv[0]);
exit(EXIT_FAILURE);
}
}
if ((optind+1) >= argc)
goto usage;
prefix = argv[optind];
defaultgw = argv[optind+1];
ccnl_core_init();
// if (theRelay.suite == CCNL_SUITE_NDNTLV && !udpport)
udpport = NDN_UDP_PORT;
i = &theRelay.ifs[0];
i->mtu = NDN_DEFAULT_MTU;
i->fwdalli = 1;
i->sock = ccnl_open_udpdev(udpport);
if (i->sock < 0)
exit(-1);
theRelay.ifcount++;
fprintf(stderr, "NDN minimalrelay started, listening on UDP port %d\n",
udpport);
inet_aton(strtok(defaultgw,"/"), &sun.ip4.sin_addr);
sun.ip4.sin_port = atoi(strtok(NULL, ""));
fwd = (struct ccnl_forward_s *) ccnl_calloc(1, sizeof(*fwd));
fwd->prefix = ccnl_URItoPrefix(prefix, suite, NULL, NULL);
fwd->suite = suite;
fwd->face = ccnl_get_face_or_create(&theRelay, 0, &sun.sa, sizeof(sun.ip4));
fwd->face->flags |= CCNL_FACE_FLAGS_STATIC;
theRelay.fib = fwd;
ccnl_set_timer(1000000, ccnl_minimalrelay_ageing, &theRelay, 0);
ccnl_io_loop(&theRelay);
return 0;
}
void ccnl_relay_config(struct ccnl_relay_s *relay, int max_cache_entries, int fib_threshold_prefix, int fib_threshold_aggregate)
{
struct ccnl_if_s *i;
DEBUGMSG(99, "ccnl_relay_config\n");
relay->max_cache_entries = max_cache_entries;
relay->fib_threshold_prefix = fib_threshold_prefix;
relay->fib_threshold_aggregate = fib_threshold_aggregate;
if (RIOT_MSG_IDX != relay->ifcount) {
DEBUGMSG(1, "sorry, idx did not match: riot msg device\n");
}
i = &relay->ifs[relay->ifcount];
i->sock = ccnl_open_riotmsgdev();
i->sendfunc = &riot_send_msg;
i->mtu = 4000;
i->reflect = 0;
i->fwdalli = 0;
if (i->sock >= 0) {
relay->ifcount++;
if (relay->defaultInterfaceScheduler) {
i->sched = relay->defaultInterfaceScheduler(relay,
ccnl_interface_CTS);
}
}
else {
DEBUGMSG(1, "sorry, could not open riot msg device\n");
}
if (RIOT_TRANS_IDX != relay->ifcount) {
DEBUGMSG(1, "sorry, idx did not match: riot trans device\n");
}
i = &relay->ifs[relay->ifcount];
i->sock = ccnl_open_riottransdev();
i->sendfunc = &riot_send_transceiver;
#ifdef USE_FRAG
i->mtu = 120;
#else
i->mtu = 1500;
#endif
i->reflect = 0;
i->fwdalli = 0;
if (i->sock >= 0) {
relay->ifcount++;
if (relay->defaultInterfaceScheduler) {
i->sched = relay->defaultInterfaceScheduler(relay,
ccnl_interface_CTS);
}
}
else {
DEBUGMSG(1, "sorry, could not open riot trans device\n");
}
/* create default boardcast face on transceiver interface */
struct ccnl_face_s * f = ccnl_get_face_or_create(relay, RIOT_TRANS_IDX, RIOT_BROADCAST);
f->flags |= CCNL_FACE_FLAGS_STATIC;
i->broadcast_face = f;
ccnl_set_timer(TIMEOUT_TO_US(CCNL_CHECK_TIMEOUT_SEC, CCNL_CHECK_TIMEOUT_USEC), ccnl_ageing, relay, 0);
ccnl_set_timer(TIMEOUT_TO_US(CCNL_CHECK_RETRANSMIT_SEC, CCNL_CHECK_RETRANSMIT_USEC), ccnl_retransmit, relay, 0);
ccnl_set_timer(TIMEOUT_TO_US(CCNL_NONCE_TIMEOUT_SEC, CCNL_NONCE_TIMEOUT_USEC), ccnl_nonce_timeout, relay, 0);
}
