static void set_interface_roles(void)
{
kernel_pid_t ifs[GNRC_NETIF_NUMOF];
size_t numof = gnrc_netif_get(ifs);
for (size_t i = 0; i < numof && i < GNRC_NETIF_NUMOF; i++) {
kernel_pid_t dev = ifs[i];
int is_wired = gnrc_netapi_get(dev, NETOPT_IS_WIRED, 0, NULL, 0);
if ((!gnrc_border_interface) && (is_wired == 1)) {
ipv6_addr_t addr, defroute;
gnrc_border_interface = dev;
ipv6_addr_from_str(&addr, "fe80::2");
gnrc_ipv6_netif_add_addr(dev, &addr, 64,
GNRC_IPV6_NETIF_ADDR_FLAGS_UNICAST);
ipv6_addr_from_str(&defroute, "::");
ipv6_addr_from_str(&addr, "fe80::1");
fib_add_entry(&gnrc_ipv6_fib_table, dev, defroute.u8, 16,
0x00, addr.u8, 16, 0,
(uint32_t)FIB_LIFETIME_NO_EXPIRE);
}
else if ((!gnrc_wireless_interface) && (is_wired != 1)) {
gnrc_wireless_interface = dev;
}
if (gnrc_border_interface && gnrc_wireless_interface) {
break;
}
}
LOG_INFO("gnrc_uhcpc: Using %u as border interface and %u as wireless interface.\n", gnrc_border_interface, gnrc_wireless_interface);
}
static size_t _send(uint8_t *buf, size_t len, char *addr_str, char *port_str)
{
ipv6_addr_t addr;
size_t bytes_sent;
sock_udp_ep_t remote;
remote.family = AF_INET6;
remote.netif = SOCK_ADDR_ANY_NETIF;
/* parse destination address */
if (ipv6_addr_from_str(&addr, addr_str) == NULL) {
puts("gcoap_cli: unable to parse destination address");
return 0;
}
memcpy(&remote.addr.ipv6[0], &addr.u8[0], sizeof(addr.u8));
/* parse port */
remote.port = atoi(port_str);
if (remote.port == 0) {
puts("gcoap_cli: unable to parse destination port");
return 0;
}
bytes_sent = gcoap_req_send2(buf, len, &remote, _resp_handler);
if (bytes_sent > 0) {
req_count++;
}
return bytes_sent;
}
int ping_cmd(int argc, char **argv)
{
ipv6_addr_t dst;
int payload_len, _num;
if ((argc < 2) || (ipv6_addr_from_str(&dst, argv[1]) == NULL)) {
usage(argv[0]);
return 1;
}
if ((argc < 3) || ((_num = atoi(argv[2])) == 0)) {
_num = 3;
}
if ((argc < 4) || ((payload_len = atoi(argv[3])) == 0)) {
payload_len = 16;
}
atomic_store(&num, _num);
atomic_store(&received, 0);
seq = 0;
if (recv_ntfy.callback == NULL) {
uip_icmp6_echo_reply_callback_add(&recv_ntfy, handle_reply);
}
for (uint16_t i = 0; i < _num; i++) {
_waiting = true;
ping_send((uip_ipaddr_t *)&dst, payload_len);
xtimer_usleep(1000000);
if (_waiting) {
puts("Timeout");
}
}
return 0;
}
ipv6_addr_t* add_address_to_interface(char* link_addr, kernel_pid_t iface_pid, uint8_t add_flags)
{
// add a global IPv6 address for the root node
uint8_t prefix_len, flags = 0;
ipv6_addr_t* ifaddr;
ipv6_addr_t addr_dec;
if (ipv6_addr_from_str(&addr_dec, link_addr) == NULL) {
puts("error: unable to parse IPv6 address.");
return NULL;
};
prefix_len = ipv6_addr_split(link_addr, '/', 64);
flags = GNRC_IPV6_NETIF_ADDR_FLAGS_NDP_AUTO | add_flags;
if ((ifaddr = gnrc_ipv6_netif_add_addr(iface_pid, &addr_dec, prefix_len, flags)) == NULL) {
printf("error: unable to add IPv6 address\n");
return NULL;
}
// Address shall be valid infinitely
gnrc_ipv6_netif_addr_get(ifaddr)->valid = UINT32_MAX;
// Address shall be preferred infinitely
gnrc_ipv6_netif_addr_get(ifaddr)->preferred = UINT32_MAX;
return ifaddr;
}
int udp_send(int argc, char **argv)
{
if (argc != 4) {
puts("Usage: udp <ipv6-addr> <port> <payload>");
return -1;
}
int res;
ipv6_addr_t src = IPV6_ADDR_UNSPECIFIED, dst;
if (ipv6_addr_from_str(&dst, argv[1]) == NULL) {
puts("Error: unable to parse destination address");
return 1;
}
if((res = conn_udp_sendto(argv[3], strlen(argv[3]), &src, sizeof(src), &dst, sizeof(dst),
AF_INET6, 1234, (uint16_t) (atoi(argv[2])))) < 0) {
puts("could not send");
}
else {
//printf("Success: send %u byte to %s\n", (unsigned) res, argv[1]);
if (gnrc_rpl_instances[0].state && gnrc_rpl_instances[0].dodag.node_status != GNRC_RPL_ROOT_NODE) {
if (acked) {
time = xtimer_now64();
acked = false;
}
}
}
return 0;
}
static int _ipv6_nc_add(kernel_pid_t iface, char *ipv6_addr_str,
char *l2_addr_str)
{
ipv6_addr_t ipv6_addr;
uint8_t l2_addr[MAX_L2_ADDR_LEN];
size_t l2_addr_len;
if (ipv6_addr_from_str(&ipv6_addr, ipv6_addr_str) == NULL) {
puts("error: unable to parse IPv6 address.");
return 1;
}
if ((l2_addr_len = ng_netif_addr_from_str(l2_addr, sizeof(l2_addr),
l2_addr_str)) == 0) {
puts("error: unable to parse link-layer address.");
return 1;
}
if (ng_ipv6_nc_add(iface, &ipv6_addr, l2_addr, l2_addr_len, 0) == NULL) {
puts("error: unable to add address to neighbor cache.");
return 1;
}
printf("success: added IPv6 address %s to neighbor cache\n", ipv6_addr_str);
return 0;
}
static int udp_send(char *addr_str, char *port_str, char *data, unsigned int num,
unsigned int delay)
{
sock_udp_ep_t dst = SOCK_IPV6_EP_ANY;
uint8_t byte_data[SHELL_DEFAULT_BUFSIZE / 2];
size_t data_len;
/* parse destination address */
if (ipv6_addr_from_str((ipv6_addr_t *)&dst.addr.ipv6, addr_str) == NULL) {
puts("Error: unable to parse destination address");
return 1;
}
/* parse port */
dst.port = atoi(port_str);
data_len = hex2ints(byte_data, data);
for (unsigned int i = 0; i < num; i++) {
sock_udp_t *sock = NULL;
if (server_running) {
sock = &server_sock;
}
if (sock_udp_send(sock, byte_data, data_len, &dst) < 0) {
puts("could not send");
}
else {
printf("Success: send %u byte over UDP to [%s]:%" PRIu16 "\n",
(unsigned)data_len, addr_str, dst.port);
}
xtimer_usleep(delay);
}
return 0;
}
void *_udp_server(void *args)
{
uint16_t port = (uint16_t) atoi(args);
ipv6_addr_t server_addr = IPV6_ADDR_UNSPECIFIED;
msg_init_queue(server_msg_queue, SERVER_MSG_QUEUE_SIZE);
if(conn_udp_create(&conn, &server_addr, sizeof(server_addr), AF_INET6, port) < 0) {
return NULL;
}
server_running = true;
printf("Success: started UDP server on port %" PRIu16 "\n", port);
char *arg[4];
char *cmd = "udp_send";
char *port_str = "8888";
arg[0] = cmd;
arg[2] = port_str;
char src_str[IPV6_ADDR_MAX_STR_LEN];
while (1) {
int res;
ipv6_addr_t src;
size_t src_len = sizeof(ipv6_addr_t);
if ((res = conn_udp_recvfrom(&conn, server_buffer, sizeof(server_buffer),
&src, &src_len, &port)) < 0) {
puts("Error while receiving");
}
else if (res == 0) {
puts("No data received");
}
else {
server_buffer[res] = '\0';
if (gnrc_rpl_instances[0].state && gnrc_rpl_instances[0].dodag.node_status == GNRC_RPL_ROOT_NODE) {
printf("%s;%s\n", ipv6_addr_to_str(src_str, &src, sizeof(src_str)),
server_buffer);
ipv6_addr_to_str(addr_str, &ipv6_addr_all_nodes_link_local, sizeof(addr_str));
arg[1] = addr_str;
arg[3] = src_str;
udp_send(4, arg);
}
else {
ipv6_addr_t payload;
ipv6_addr_from_str(&payload, server_buffer);
if ((gnrc_ipv6_netif_find_by_addr(NULL, &payload) != KERNEL_PID_UNDEF) && (!acked)) {
acked = true;
printf("diff: %llu\n", xtimer_now64() - time);
}
}
}
}
return NULL;
}
static int _ipv6_nc_del(char *ipv6_addr_str)
{
ipv6_addr_t ipv6_addr;
if (ipv6_addr_from_str(&ipv6_addr, ipv6_addr_str) == NULL) {
puts("error: unable to parse IPv6 address.");
return 1;
}
ng_ipv6_nc_remove(KERNEL_PID_UNDEF, &ipv6_addr);
printf("success: removed %s from neighbor cache\n", ipv6_addr_str);
return 0;
}
int greet(int argc, char** argv)
{
if (argc < 3) {
printf("Usage: %s <server or multicast address> <name>\n", argv[0]);
return 1;
}
ipv6_addr_t target;
ipv6_addr_from_str(&target, argv[1]);
coap_client_send(&target, COAP_METHOD_POST, COAP_TYPE_CON, "greet", argv[2], COAP_CONTENTTYPE_TEXT_PLAIN);
coap_client_receive();
return 0;
}
SOL_API const struct sol_network_link_addr *
sol_network_addr_from_str(struct sol_network_link_addr *addr, const char *buf)
{
#if MODULE_GNRC_IPV6_NETIF
SOL_NULL_CHECK(addr, NULL);
SOL_NULL_CHECK(buf, NULL);
if (addr->family != SOL_NETWORK_FAMILY_INET6)
return NULL;
if (!ipv6_addr_from_str((ipv6_addr_t *)&addr->addr, buf))
return NULL;
return addr;
#else
return NULL;
#endif
}
int coap_client(int argc, char** argv)
{
if (argc < 2) {
printf("Usage: %s <server or multicast address>\n", argv[0]);
return 1;
}
ipv6_addr_t target;
ipv6_addr_from_str(&target, argv[1]);
coap_client_send(&target, COAP_METHOD_GET, COAP_TYPE_NONCON, ".well-known/core", NULL, 0);
coap_client_receive();
return 0;
}
int main(void)
{
#ifdef WITH_SHELL
/* initialize message queue */
msg_init_queue(_main_msg_q, Q_SZ);
#endif
eui64_t iid;
// uint16_t chan = 15;
netopt_enable_t acks = NETOPT_DISABLE;
kernel_pid_t ifs[GNRC_NETIF_NUMOF];
gnrc_netif_get(ifs);
gnrc_netapi_set(ifs[0], NETOPT_AUTOACK, 0, &acks, sizeof(acks));
// gnrc_netapi_set(ifs[0], NETOPT_CHANNEL, 0, &chan, sizeof(chan));
ipv6_addr_from_str(&dst_addr, "2001:affe:1234::1");
// ipv6_addr_from_str(&dst_addr, "fd38:3734:ad48:0:211d:50ce:a189:7cc4");
/* initialize senml payload */
gnrc_netapi_get(ifs[0], NETOPT_IPV6_IID, 0, &iid, sizeof(eui64_t));
initial_pos = sprintf(&p_buf[initial_pos], "[{\"bn\":\"urn:dev:mac:");
initial_pos += sprintf(&p_buf[initial_pos], "%02x%02x%02x%02x%02x%02x%02x%02x",
iid.uint8[0], iid.uint8[1], iid.uint8[2], iid.uint8[3],
iid.uint8[4], iid.uint8[5], iid.uint8[6], iid.uint8[7]);
initial_pos += sprintf(&p_buf[initial_pos], "\"},");
/* initialize sensors */
hdc1000_init(&th_dev, HDC1000_I2C, HDC1000_ADDR);
hdc1000_startmeasure(&th_dev);
mpl3115a2_init(&p_dev, MPL3115A2_I2C, MPL3115A2_ADDR, MPL3115A2_OS_RATIO_DEFAULT);
mpl3115a2_set_active(&p_dev);
tcs37727_init(&light_dev, TCS37727_I2C, TCS37727_ADDR, TCS37727_ATIME_DEFAULT);
tcs37727_set_rgbc_active(&light_dev);
#ifdef WITH_SHELL
thread_create(beac_stack, sizeof(beac_stack), PRIO, THREAD_CREATE_STACKTEST, beaconing,
NULL, "beaconing");
char line_buf[SHELL_DEFAULT_BUFSIZE];
shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);
#else
beaconing(NULL);
#endif
return 0;
}
int main(void)
{
#ifdef WITH_SHELL
/* initialize message queue */
msg_init_queue(_main_msg_q, Q_SZ);
#endif
eui64_t iid;
// uint16_t chan = 15;
netopt_enable_t acks = NETOPT_DISABLE;
kernel_pid_t ifs[GNRC_NETIF_NUMOF];
gnrc_netif_get(ifs);
gnrc_netapi_set(ifs[0], NETOPT_AUTOACK, 0, &acks, sizeof(acks));
ipv6_addr_from_str(&dst_addr, "2001:affe:1234::1");
// gnrc_netapi_set(ifs[0], NETOPT_CHANNEL, 0, &chan, sizeof(chan));
// ipv6_addr_from_str(&dst_addr, "fd38:3734:ad48:0:211d:50ce:a189:7cc4");
/* initialize senml payload */
gnrc_netapi_get(ifs[0], NETOPT_IPV6_IID, 0, &iid, sizeof(eui64_t));
initial_pos = sprintf(&p_buf[initial_pos], "[{\"bn\":\"urn:dev:mac:");
initial_pos += sprintf(&p_buf[initial_pos], "%02x%02x%02x%02x%02x%02x%02x%02x",
iid.uint8[0], iid.uint8[1], iid.uint8[2], iid.uint8[3],
iid.uint8[4], iid.uint8[5], iid.uint8[6], iid.uint8[7]);
initial_pos += sprintf(&p_buf[initial_pos], "\"},");
thread_create(coap_stack, sizeof(coap_stack), PRIO - 1, THREAD_CREATE_STACKTEST, microcoap_server,
NULL, "coap");
#ifdef WITH_SHELL
thread_create(beac_stack, sizeof(beac_stack), PRIO, THREAD_CREATE_STACKTEST, beaconing,
NULL, "beaconing");
char line_buf[SHELL_DEFAULT_BUFSIZE];
shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);
#else
beaconing(NULL);
#endif
return 0;
}
static int _netif_del(kernel_pid_t dev, char *addr_str)
{
#ifdef MODULE_GNRC_IPV6_NETIF
ipv6_addr_t addr;
if (ipv6_addr_from_str(&addr, addr_str) == NULL) {
puts("error: unable to parse IPv6 address.");
return 1;
}
gnrc_ipv6_netif_remove_addr(dev, &addr);
printf("success: removed %s to interface %" PRIkernel_pid "\n", addr_str,
dev);
return 0;
#else
(void)dev;
(void)addr_str;
puts("error: unable to delete IPv6 address.");
return 1;
#endif
}
int udp_send(int argc, char **argv)
{
if (argc != 4) {
puts("Usage: udp <ipv6-addr> <port> <payload>");
return -1;
}
int res;
ipv6_addr_t src = IPV6_ADDR_UNSPECIFIED, dst;
if (ipv6_addr_from_str(&dst, argv[1]) == NULL) {
puts("Error: unable to parse destination address");
return 1;
}
if((res = conn_udp_sendto(argv[3], strlen(argv[3]), &src, sizeof(src), &dst, sizeof(dst),
AF_INET6, 1234, (uint16_t) (atoi(argv[2])))) < 0) {
puts("could not send");
}
else {
printf("Success: send %u byte to %s\n", (unsigned) res, argv[1]);
}
return 0;
}
static int _netif_del(kernel_pid_t iface, char *addr_str)
{
#ifdef MODULE_GNRC_IPV6
ipv6_addr_t addr;
if (ipv6_addr_from_str(&addr, addr_str) == NULL) {
puts("error: unable to parse IPv6 address.");
return 1;
}
if (ipv6_addr_is_multicast(&addr)) {
if (gnrc_netapi_set(iface, NETOPT_IPV6_GROUP_LEAVE, 0, &addr,
sizeof(addr)) < 0) {
printf("error: unable to leave IPv6 multicast group\n");
return 1;
}
}
else {
if (gnrc_netapi_set(iface, NETOPT_IPV6_ADDR_REMOVE, 0, &addr,
sizeof(addr)) < 0) {
printf("error: unable to remove IPv6 address\n");
return 1;
}
}
printf("success: removed %s to interface %" PRIkernel_pid "\n", addr_str,
iface);
return 0;
#else
(void)iface;
(void)addr_str;
puts("error: unable to delete IPv6 address.");
return 1;
#endif
}
static int _netif_add(char *cmd_name, kernel_pid_t dev, int argc, char **argv)
{
#ifdef MODULE_GNRC_IPV6_NETIF
enum {
_UNICAST = 0,
_MULTICAST, /* multicast value just to check if given addr is mc */
_ANYCAST
} type = _UNICAST;
char *addr_str = argv[0];
ipv6_addr_t addr;
uint8_t prefix_len;
if (argc > 1) {
if (strcmp(argv[0], "anycast") == 0) {
type = _ANYCAST;
addr_str = argv[1];
}
else if (strcmp(argv[0], "multicast") == 0) {
type = _MULTICAST;
addr_str = argv[1];
}
else if (strcmp(argv[0], "unicast") == 0) {
/* type already set to unicast */
addr_str = argv[1];
}
else {
_add_usage(cmd_name);
return 1;
}
}
prefix_len = _get_prefix_len(addr_str);
if (ipv6_addr_from_str(&addr, addr_str) == NULL) {
puts("error: unable to parse IPv6 address.");
return 1;
}
if ((argc > 1) && (ipv6_addr_is_multicast(&addr)) && (type != _MULTICAST)) {
puts("error: address was not a multicast address.");
return 1;
}
if (gnrc_ipv6_netif_add_addr(dev, &addr, prefix_len,
(type == _ANYCAST) ?
GNRC_IPV6_NETIF_ADDR_FLAGS_NON_UNICAST :
GNRC_IPV6_NETIF_ADDR_FLAGS_UNICAST) == NULL) {
printf("error: unable to add IPv6 address\n");
return 1;
}
printf("success: added %s/%d to interface %" PRIkernel_pid "\n", addr_str,
prefix_len, dev);
return 0;
#else
(void)cmd_name;
(void)dev;
(void)argc;
(void)argv;
puts("error: unable to add IPv6 address.");
return 1;
#endif
}
static int _tftp_client_cmd(int argc, char * *argv)
{
ipv6_addr_t ip;
const char *file_name = argv[2];
tftp_mode_t mode = TTM_OCTET;
bool use_options = true;
ipv6_addr_from_str(&ip, _tftp_default_host);
if (argc >= 3 && argc <= 6) {
/* decode the action */
if (strcmp(argv[1], "get") == 0) {
_tftp_action = TFTP_READ;
}
else if (strcmp(argv[1], "put") == 0) {
_tftp_action = TFTP_WRITE;
}
else {
return -1;
}
/* get the transfer mode */
if (argc >= 4) {
if (strcmp(argv[3], "octet") == 0) {
mode = TTM_OCTET;
}
else if (strcmp(argv[3], "ascii") == 0) {
mode = TTM_ASCII;
}
else if (strcmp(argv[3], "mail") == 0) {
mode = TTM_MAIL;
}
else {
puts("tftp: couldn't parse the TFTP transfer mode");
return -1;
}
}
/* decode if we must use the TFTP option extension or not */
if (argc >= 5) {
if (strcmp(argv[4], "0") == 0) {
use_options = false;
}
else if (strcmp(argv[4], "1") == 0) {
use_options = true;
}
else {
puts("tftp: invalid options choose 0 or 1");
return -1;
}
}
/* decode the address */
if (argc >= 6) {
if (!ipv6_addr_from_str(&ip, argv[5])) {
puts("tftp: invalid IP address");
return -1;
}
}
}
else {
return -1;
}
if (_tftp_action == TFTP_READ) {
puts("tftp: starting read request");
gnrc_tftp_client_read(&ip, file_name, mode, _tftp_client_data_cb,
_tftp_client_start_cb, _tftp_client_stop_cb, use_options);
}
else if (_tftp_action == TFTP_WRITE) {
puts("tftp: starting write request");
gnrc_tftp_client_write(&ip, file_name, mode, _tftp_client_data_cb,
sizeof(_tftp_client_hello), _tftp_client_stop_cb, use_options);
}
return 0;
}
static int _netif_add(char *cmd_name, kernel_pid_t iface, int argc, char **argv)
{
#ifdef MODULE_GNRC_IPV6
enum {
_UNICAST = 0,
_ANYCAST
} type = _UNICAST;
char *addr_str = argv[0];
ipv6_addr_t addr;
uint16_t flags = GNRC_NETIF_IPV6_ADDRS_FLAGS_STATE_VALID;
uint8_t prefix_len;
if (argc > 1) {
if (strcmp(argv[0], "anycast") == 0) {
type = _ANYCAST;
addr_str = argv[1];
}
else if (strcmp(argv[0], "unicast") == 0) {
/* type already set to unicast */
addr_str = argv[1];
}
else {
_add_usage(cmd_name);
return 1;
}
}
prefix_len = _get_prefix_len(addr_str);
if (ipv6_addr_from_str(&addr, addr_str) == NULL) {
puts("error: unable to parse IPv6 address.");
return 1;
}
if (ipv6_addr_is_multicast(&addr)) {
if (gnrc_netapi_set(iface, NETOPT_IPV6_GROUP, 0, &addr,
sizeof(addr)) < 0) {
printf("error: unable to join IPv6 multicast group\n");
return 1;
}
}
else {
if (type == _ANYCAST) {
flags |= GNRC_NETIF_IPV6_ADDRS_FLAGS_ANYCAST;
}
flags |= (prefix_len << 8U);
if (gnrc_netapi_set(iface, NETOPT_IPV6_ADDR, flags, &addr,
sizeof(addr)) < 0) {
printf("error: unable to add IPv6 address\n");
return 1;
}
}
printf("success: added %s/%d to interface %" PRIkernel_pid "\n", addr_str,
prefix_len, iface);
return 0;
#else
(void)cmd_name;
(void)iface;
(void)argc;
(void)argv;
puts("error: unable to add IPv6 address.");
return 1;
#endif
}
