void fill_nc(void)
{
ipv6_addr_t r_addr;
uint16_t l_addr;
printf("Adding %u as neighbor\n", id - 1);
ipv6_addr_init(&r_addr, 0xfe80, 0x0, 0x0, 0x0, 0x0, 0x00ff, 0xfe00, id - 1);
l_addr = HTONS(id - 1);
ndp_neighbor_cache_add(0, &r_addr, &l_addr, 2, 0, NDP_NCE_STATUS_REACHABLE,
NDP_NCE_TYPE_TENTATIVE, 0xffff);
printf("Adding %u as neighbor\n", id + 1);
ipv6_addr_init(&r_addr, 0xfe80, 0x0, 0x0, 0x0, 0x0, 0x00ff, 0xfe00, id + 1);
l_addr = HTONS(id + 1);
ndp_neighbor_cache_add(0, &r_addr, &l_addr, 2, 0, NDP_NCE_STATUS_REACHABLE,
NDP_NCE_TYPE_TENTATIVE, 0xffff);
}
int init_local_address(uint16_t r_addr)
{
ipv6_addr_t std_addr;
ipv6_addr_init(&std_addr, 0xabcd, 0xef12, 0, 0, 0x1034, 0x00ff, 0xfe00,
0);
net_if_set_src_address_mode(0, NET_IF_TRANS_ADDR_M_SHORT);
return net_if_set_hardware_address(0, r_addr) &&
sixlowpan_lowpan_init_adhoc_interface(0, &std_addr);
}
/* UDP send command */
void udp_send(int argc, char **argv)
{
int sock;
sockaddr6_t sa;
ipv6_addr_t ipaddr;
int bytes_sent;
int address;
char text[5];
if (argc != 3) {
printf("usage: send <addr> <text>\n");
return;
}
address = atoi(argv[1]);
strncpy(text, argv[2], sizeof(text));
text[sizeof(text) - 1] = 0;
sock = socket_base_socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (-1 == sock) {
printf("Error Creating Socket!");
return;
}
memset(&sa, 0, sizeof(sa));
if (address) {
ipv6_addr_init(&ipaddr, 0xabcd, 0x0, 0x0, 0x0, 0x0, 0x00ff, 0xfe00, (uint16_t)address);
}
else {
ipv6_addr_set_all_nodes_addr(&ipaddr);
}
sa.sin6_family = AF_INET;
memcpy(&sa.sin6_addr, &ipaddr, 16);
sa.sin6_port = HTONS(SERVER_PORT);
bytes_sent = socket_base_sendto(sock, (char *)text,
strlen(text) + 1, 0, &sa,
sizeof(sa));
if (bytes_sent < 0) {
printf("Error sending packet!\n");
}
else {
printf("Successful deliverd %i bytes over UDP to %s to 6LoWPAN\n",
bytes_sent, ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN,
&ipaddr));
}
socket_base_close(sock);
}
void fill_nc(void)
{
int numne = 5;
ipv6_addr_t r_addr;
uint16_t l_addr;
for (int16_t i = 0; i < numne; i++) {
printf("Adding %u as neighbor\n", i);
ipv6_addr_init(&r_addr, 0xfe80, 0x0, 0x0, 0x0, 0x0, 0x00ff, 0xfe00, i);
l_addr = HTONS(i);
ndp_neighbor_cache_add(0, &r_addr, &l_addr, 2, 0,
NDP_NCE_STATUS_REACHABLE,
NDP_NCE_TYPE_TENTATIVE,
0xffff);
}
}
/* TCP connection handler */
void tcp_ch(void)
{
msg_t recv_msg;
int read_bytes = 0;
char buff_msg[MAX_TCP_BUFFER];
sockaddr6_t stSockAddr;
msg_receive(&recv_msg);
int SocketFD = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
if(-1 == SocketFD) {
printf("cannot create socket");
return;
}
memset(&stSockAddr, 0, sizeof(stSockAddr));
stSockAddr.sin6_family = AF_INET6;
stSockAddr.sin6_port = HTONS(1100);
ipv6_addr_init(&stSockAddr.sin6_addr, 0xabcd, 0x0, 0x0, 0x0, 0x3612, 0x00ff, 0xfe00, current_message.node_number);
print_ipv6_addr(&stSockAddr.sin6_addr);
if(-1 == connect(SocketFD, &stSockAddr, sizeof(stSockAddr))) {
printf("Connect failed!\n");
close(SocketFD);
return;
}
tcp_socket_id = SocketFD;
while(read_bytes != -1) {
read_bytes = recv(SocketFD, buff_msg, MAX_TCP_BUFFER, 0);
if(read_bytes > 0) {
printf("--- Message: %s ---\n", buff_msg);
}
}
}
void rpl_udp_init(int argc, char **argv)
{
transceiver_command_t tcmd;
msg_t m;
int32_t chan = UNASSIGNED_CHANNEL;
if (argc != 2) {
printf("Usage: %s (r|n|h)\n", argv[0]);
printf("\tr\tinitialize as root\n");
printf("\tn\tinitialize as node router\n");
printf("\th\tinitialize as non-routing node (host-mode)\n");
return;
}
char command = argv[1][0];
if ((command == 'n') || (command == 'r') || (command == 'h')) {
printf("INFO: Initialize as %srouting %s on address %d\n",
((command == 'h') ? "non-" : ""),
(((command == 'n') || (command == 'h')) ? "node" : "root"), id);
#if (defined(MODULE_CC110X) || defined(MODULE_CC110X_LEGACY) || defined(MODULE_CC110X_LEGACY_CSMA))
if (!id || (id > 255)) {
printf("ERROR: address not a valid 8 bit integer\n");
return;
}
#endif
DEBUGF("Setting HW address to %u\n", id);
net_if_set_hardware_address(0, id);
tcmd.transceivers = TRANSCEIVER;
tcmd.data = &chan;
m.type = GET_CHANNEL;
m.content.ptr = (void *) &tcmd;
msg_send_receive(&m, &m, transceiver_pid);
if( chan == UNASSIGNED_CHANNEL ) {
DEBUGF("The channel has not been set yet.");
/* try to set the channel to 10 (RADIO_CHANNEL) */
chan = RADIO_CHANNEL;
}
m.type = SET_CHANNEL;
msg_send_receive(&m, &m, transceiver_pid);
if( chan == UNASSIGNED_CHANNEL ) {
puts("ERROR: channel NOT set! Aborting initialization.");
return;
}
printf("Channel set to %" PRIi32 "\n", chan);
/* global address */
ipv6_addr_t global_addr, global_prefix;
ipv6_addr_init(&global_prefix, 0xabcd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0);
ipv6_addr_set_by_eui64(&global_addr, 0, &global_prefix);
if (command != 'h') {
DEBUGF("Initializing RPL for interface 0\n");
uint8_t state = SIXLOWERROR_VALUE;
if (command == 'n') {
/*
* no global address specified, we'll use auto address config
* initiated by the root node
*/
state = rpl_init(0, NULL);
}
else if (command == 'r') {
rpl_options_t rpl_opts = {
.instance_id = 0,
.prefix = global_prefix,
.prefix_len = 64,
.prefix_flags = RPL_PREFIX_INFO_AUTO_ADDR_CONF,
/* autonomous address-configuration */
};
/* use specific global address */
state = rpl_init(0, &global_addr);
rpl_init_root(&rpl_opts);
is_root = 1;
}
if (state != SIXLOWERROR_SUCCESS) {
puts("Error initializing RPL");
}
else {
puts("6LoWPAN and RPL initialized.");
}
ipv6_iface_set_routing_provider(rpl_get_next_hop);
}
void init(char *str)
{
transceiver_command_t tcmd;
msg_t m;
uint8_t chan = RADIO_CHANNEL;
char command;
int res = sscanf(str, "init %c", &command);
if (res < 1) {
printf("Usage: init (r|n)\n");
printf("\tr\tinitialize as root\n");
printf("\tn\tinitialize as node router\n");
}
uint8_t state;
if ((command == 'n') || (command == 'r')) {
printf("INFO: Initialize as %s on address %d\n", ((command == 'n') ? "node" : "root"), id);
if (!id || (id > 255)) {
printf("ERROR: address not a valid 8 bit integer\n");
return;
}
state = rpl_init(TRANSCEIVER, id);
if (state != SIXLOWERROR_SUCCESS) {
printf("Error initializing RPL\n");
}
else {
puts("6LoWPAN and RPL initialized.");
}
if (command == 'r') {
rpl_init_root();
is_root = 1;
}
else {
ipv6_iface_set_routing_provider(rpl_get_next_hop);
}
int monitor_pid = thread_create(monitor_stack_buffer, MONITOR_STACK_SIZE, PRIORITY_MAIN-2, CREATE_STACKTEST, monitor, "monitor");
transceiver_register(TRANSCEIVER, monitor_pid);
ipv6_register_packet_handler(monitor_pid);
//sixlowpan_lowpan_register(monitor_pid);
}
else {
printf("ERROR: Unknown command '%c'\n", command);
return;
}
/* TODO: check if this works as intended */
ipv6_addr_t prefix, tmp;
ipv6_addr_init(&std_addr, 0xABCD, 0xEF12, 0, 0, 0x1034, 0x00FF, 0xFE00, id);
ipv6_addr_init_prefix(&prefix, &std_addr, 64);
plist_add(&prefix, 64, NDP_OPT_PI_VLIFETIME_INFINITE, 0, 1, ICMPV6_NDP_OPT_PI_FLAG_AUTONOM);
ipv6_init_iface_as_router();
/* add global address */
ipv6_addr_set_by_eui64(&tmp, &std_addr);
ipv6_iface_add_addr(&tmp, IPV6_ADDR_TYPE_GLOBAL, NDP_ADDR_STATE_PREFERRED, 0, 0);
/* set channel to 10 */
tcmd.transceivers = TRANSCEIVER;
tcmd.data = &chan;
m.type = SET_CHANNEL;
m.content.ptr = (void *) &tcmd;
msg_send_receive(&m, &m, transceiver_pid);
printf("Channel set to %u\n", RADIO_CHANNEL);
destiny_init_transport_layer();
puts("Destiny initialized");
/* start transceiver watchdog */
}
void rpl_udp_init(int argc, char **argv)
{
transceiver_command_t tcmd;
msg_t m;
uint8_t chan = RADIO_CHANNEL;
if (argc != 2) {
printf("Usage: %s (r|n)\n", argv[0]);
printf("\tr\tinitialize as root\n");
printf("\tn\tinitialize as node router\n");
return;
}
uint8_t state;
char command = argv[1][0];
if ((command == 'n') || (command == 'r')) {
printf("INFO: Initialize as %s on address %d\n", ((command == 'n') ? "node" : "root"), id);
if (!id || (id > 255)) {
printf("ERROR: address not a valid 8 bit integer\n");
return;
}
DEBUGF("Setting HW address to %u\n", id);
net_if_set_hardware_address(0, id);
DEBUGF("Initializing RPL for interface 0\n");
state = rpl_init(0);
if (state != SIXLOWERROR_SUCCESS) {
printf("Error initializing RPL\n");
}
else {
puts("6LoWPAN and RPL initialized.");
}
if (command == 'r') {
rpl_init_root();
is_root = 1;
}
else {
ipv6_iface_set_routing_provider(rpl_get_next_hop);
}
DEBUGF("Start monitor\n");
int monitor_pid = thread_create(
monitor_stack_buffer, sizeof(monitor_stack_buffer),
PRIORITY_MAIN - 2, CREATE_STACKTEST,
rpl_udp_monitor, NULL, "monitor");
DEBUGF("Register at transceiver %02X\n", TRANSCEIVER);
transceiver_register(TRANSCEIVER, monitor_pid);
ipv6_register_packet_handler(monitor_pid);
//sixlowpan_lowpan_register(monitor_pid);
}
else {
printf("ERROR: Unknown command '%c'\n", command);
return;
}
/* TODO: check if this works as intended */
ipv6_addr_t prefix, tmp;
ipv6_addr_init(&std_addr, 0xABCD, 0xEF12, 0, 0, 0x1034, 0x00FF, 0xFE00, id);
ipv6_addr_init_prefix(&prefix, &std_addr, 64);
ndp_add_prefix_info(0, &prefix, 64, NDP_OPT_PI_VLIFETIME_INFINITE,
NDP_OPT_PI_PLIFETIME_INFINITE, 1,
ICMPV6_NDP_OPT_PI_FLAG_AUTONOM);
ipv6_init_as_router();
/* add global address */
ipv6_addr_set_by_eui64(&tmp, 0, &std_addr);
ipv6_net_if_add_addr(0, &tmp, NDP_ADDR_STATE_PREFERRED, 0, 0, 0);
/* set channel to 10 */
tcmd.transceivers = TRANSCEIVER;
tcmd.data = &chan;
m.type = SET_CHANNEL;
m.content.ptr = (void *) &tcmd;
msg_send_receive(&m, &m, transceiver_pid);
printf("Channel set to %u\n", RADIO_CHANNEL);
puts("Destiny initialized");
/* start transceiver watchdog */
}
void udpif_get_ipv6_address(ipv6_addr_t *addr, uint16_t local_addr)
{
ipv6_addr_init(addr, 0xfe80, 0x0, 0x0, 0x0, 0x0, 0x00ff, 0xfe00, local_addr);
}
void init_tcp_server(void)
{
sockaddr6_t stSockAddr;
int read_bytes;
char buff_msg[MAX_TCP_BUFFER];
int16_t a;
transceiver_command_t tcmd;
msg_t mesg;
memset(buff_msg, 0, MAX_TCP_BUFFER);
int SocketFD = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
if(-1 == SocketFD) {
perror("can not create socket");
exit(EXIT_FAILURE);
}
memset(&stSockAddr, 0, sizeof(stSockAddr));
stSockAddr.sin6_family = AF_INET6;
stSockAddr.sin6_port = HTONS(1100);
tcmd.transceivers = TRANSCEIVER_CC1100;
mesg.type = GET_ADDRESS;
tcmd.data = &a;
mesg.content.ptr = (char *) &tcmd;
msg_send_receive(&mesg, &mesg, transceiver_pid);
ipv6_addr_init(&stSockAddr.sin6_addr, 0xabcd, 0x0, 0x0, 0x0, 0x3612, 0x00ff, 0xfe00, a);
print_ipv6_addr(&stSockAddr.sin6_addr);
if(-1 == bind(SocketFD, &stSockAddr, sizeof(stSockAddr))) {
printf("error bind failed\n");
close(SocketFD);
return;
}
print_internal_socket(getSocket(SocketFD));
if(-1 == listen(SocketFD, 10)) {
printf("error listen failed\n");
close(SocketFD);
return;
}
while(1) {
read_bytes = 0;
printf("INFO: WAITING FOR INC CONNECTIONS!\n");
int ConnectFD = accept(SocketFD, NULL, 0);
if(0 > ConnectFD) {
printf("error accept failed\n");
close(SocketFD);
return;
}
else {
printf("Connection established on socket %u.\n", ConnectFD);
if(running_recv_threads == 0) {
recv_socket_id1 = ConnectFD;
thread_create(recv_from_tcp_thread_stack1, RECV_FROM_TCP_THREAD_STACK_SIZE1, PRIORITY_MAIN,
CREATE_STACKTEST, recv_from_tcp_thread1, "recv_from_tcp_thread1");
}
else if(running_recv_threads == 1) {
recv_socket_id2 = ConnectFD;
thread_create(recv_from_tcp_thread_stack2, RECV_FROM_TCP_THREAD_STACK_SIZE2, PRIORITY_MAIN,
CREATE_STACKTEST, recv_from_tcp_thread2, "recv_from_tcp_thread2");
}
running_recv_threads++;
}
}
}
