static bool _try_l2addr_reconfiguration(gnrc_netif_t *netif) { uint8_t hwaddr[GNRC_NETIF_L2ADDR_MAXLEN]; uint16_t hwaddr_len; if (gnrc_netapi_get(netif->pid, NETOPT_SRC_LEN, 0, &hwaddr_len, sizeof(hwaddr_len)) < 0) { return false; } luid_get(hwaddr, hwaddr_len); #if GNRC_IPV6_NIB_CONF_6LN if (hwaddr_len == IEEE802154_LONG_ADDRESS_LEN) { if (gnrc_netapi_set(netif->pid, NETOPT_ADDRESS_LONG, 0, hwaddr, hwaddr_len) < 0) { return false; } } else #endif if (gnrc_netapi_set(netif->pid, NETOPT_ADDRESS, 0, hwaddr, hwaddr_len) < 0) { return false; } return true; }
int main(void) { gnrc_netreg_entry_t ne; uint8_t cpuid[CPUID_LEN]; cpuid_get(cpuid); conn_test_id = djb2_hash(cpuid, CPUID_LEN); random_init(conn_test_id); ne.pid = thread_create(_stack, sizeof(_stack), THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST, _listener, NULL, "listener"); ne.demux_ctx = GNRC_NETREG_DEMUX_CTX_ALL; gnrc_netreg_register(GNRC_NETTYPE_UNDEF, &ne); puts("Connectivity Test program!"); printf("MY ID: %08lX\n", (unsigned long) conn_test_id); unsigned res = CONN_TEST_CHAN; if (gnrc_netapi_set(CONN_TEST_NETIF, NETOPT_CHANNEL, 0, (uint16_t *)&res, sizeof(uint16_t)) < 0) { puts("main: error setting channel"); } unsigned int addr_len = 8; if (gnrc_netapi_set(CONN_TEST_NETIF, NETOPT_SRC_LEN, 0, (uint16_t *)&addr_len, sizeof(uint16_t)) < 0) { printf("main: error setting addressing mode\n"); } xtimer_set_msg(&ct_timer, (SEC_IN_USEC * 3) + (random_uint32() & 0x001FFFFF), &ct_m, ne.pid); char line_buf[SHELL_DEFAULT_BUFSIZE]; shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE); return 0; }
static int _netif_addrm_l2filter(kernel_pid_t dev, char *val, bool add) { uint8_t addr[MAX_ADDR_LEN]; size_t addr_len = gnrc_netif_addr_from_str(addr, sizeof(addr), val); if ((addr_len == 0) || (addr_len > L2FILTER_ADDR_MAXLEN)) { puts("error: given address is invalid"); return 1; } if (add) { if (gnrc_netapi_set(dev, NETOPT_L2FILTER, 0, addr, addr_len) < 0) { puts("unable to add link layer address to filter"); return 1; } puts("successfully added address to filter"); } else { if (gnrc_netapi_set(dev, NETOPT_L2FILTER_RM, 0, addr, addr_len) < 0) { puts("unable to remove link layer address from filter"); return 1; } puts("successfully removed address to filter"); } return 0; }
static int _netif_set_coding_rate(kernel_pid_t iface, char *value) { uint8_t cr; if (strcmp("4/5", value) == 0) { cr = LORA_CR_4_5; } else if (strcmp("4/6", value) == 0) { cr = LORA_CR_4_6; } else if (strcmp("4/7", value) == 0) { cr = LORA_CR_4_7; } else if (strcmp("4/8", value) == 0) { cr = LORA_CR_4_8; } else { puts("usage: ifconfig <if_id> set cr [4/5|4/6|4/7|4/8]"); return 1; } if (gnrc_netapi_set(iface, NETOPT_CODING_RATE, 0, &cr, sizeof(uint8_t)) < 0) { printf("error: unable to set coding rate to %s\n", value); return 1; } printf("success: set coding rate of interface %" PRIkernel_pid " to %s\n", iface, value); return 0; }
static int _netif_set_bandwidth(kernel_pid_t iface, char *value) { uint8_t bw; if (strcmp("125", value) == 0) { bw = LORA_BW_125_KHZ; } else if (strcmp("250", value) == 0) { bw = LORA_BW_250_KHZ; } else if (strcmp("500", value) == 0) { bw = LORA_BW_500_KHZ; } else { puts("usage: ifconfig <if_id> set bw [125|250|500]"); return 1; } if (gnrc_netapi_set(iface, NETOPT_BANDWIDTH, 0, &bw, sizeof(uint8_t)) < 0) { printf("error: unable to set bandwidth to %s\n", value); return 1; } printf("success: set bandwidth of interface %" PRIkernel_pid " to %s\n", iface, value); return 0; }
static int _netif_set_state(kernel_pid_t dev, char *state_str) { netopt_state_t state; if ((strcmp("off", state_str) == 0) || (strcmp("OFF", state_str) == 0)) { state = NETOPT_STATE_OFF; } else if ((strcmp("sleep", state_str) == 0) || (strcmp("SLEEP", state_str) == 0)) { state = NETOPT_STATE_SLEEP; } else if ((strcmp("idle", state_str) == 0) || (strcmp("IDLE", state_str) == 0)) { state = NETOPT_STATE_IDLE; } else if ((strcmp("reset", state_str) == 0) || (strcmp("RESET", state_str) == 0)) { state = NETOPT_STATE_RESET; } else { puts("usage: ifconfig <if_id> set state [off|sleep|idle|reset]"); return 1; } if (gnrc_netapi_set(dev, NETOPT_STATE, 0, &state, sizeof(netopt_state_t)) < 0) { printf("error: unable to set state to "); _print_netopt_state(state); puts(""); return 1; } printf("success: set state of interface %" PRIkernel_pid " to ", dev); _print_netopt_state(state); puts(""); return 0; }
static int _netif_set_encrypt(kernel_pid_t dev, netopt_t opt, char *encrypt_str) { netopt_enable_t set; size_t size = 1; if ((strcmp("on", encrypt_str) == 0) || (strcmp("ON", encrypt_str) == 0)) { set = NETOPT_ENABLE; } else if ((strcmp("off", encrypt_str) == 0) || (strcmp("OFF", encrypt_str) == 0)) { set = NETOPT_DISABLE; } else { puts("usage: ifconfig <if_id> set encryption [on|off]"); return 1; } if (gnrc_netapi_set(dev, opt, 0, &set, size) < 0) { printf("error: unable to set "); _print_netopt(opt); puts(""); return 1; } printf("success: set "); _print_netopt(opt); printf(" on interface %" PRIkernel_pid " to %s\n", dev, encrypt_str); return 0; }
static void _init_interface(void) { gnrc_netif_t *netif; netdev_test_setup(&_ieee802154_dev, NULL); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_DEVICE_TYPE, _get_netdev_device_type); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_PROTO, _get_netdev_proto); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_MAX_PDU_SIZE, _get_netdev_max_packet_size); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_SRC_LEN, _get_netdev_src_len); netdev_test_set_get_cb(&_ieee802154_dev, NETOPT_ADDRESS_LONG, _get_netdev_addr_long); netif = gnrc_netif_ieee802154_create( _netif_stack, THREAD_STACKSIZE_DEFAULT, GNRC_NETIF_PRIO, "dummy_netif", (netdev_t *)&_ieee802154_dev); ipv6_addr_t addr = IPV6_ADDR_UNSPECIFIED; /* fd01::01 */ addr.u8[0] = 0xfd; addr.u8[1] = 0x01; addr.u8[15] = 0x01; xtimer_usleep(500); /* wait for thread to start */ if (gnrc_netapi_set(netif->pid, NETOPT_IPV6_ADDR, 64U << 8U, &addr, sizeof(addr)) < 0) { printf("error: unable to add IPv6 address fd01::1/64 to interface %u\n", netif->pid); } }
static int _netif_set_addr(kernel_pid_t dev, netopt_t opt, char *addr_str) { uint8_t addr[MAX_ADDR_LEN]; size_t addr_len = gnrc_netif_addr_from_str(addr, sizeof(addr), addr_str); if (addr_len == 0) { puts("error: unable to parse address.\n" "Must be of format [0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*\n" "(hex pairs delimited by colons)"); return 1; } if (gnrc_netapi_set(dev, opt, 0, addr, addr_len) < 0) { printf("error: unable to set "); _print_netopt(opt); puts(""); return 1; } printf("success: set "); _print_netopt(opt); printf(" on interface %" PRIkernel_pid " to %s\n", dev, addr_str); return 0; }
static int comm_init(void) { kernel_pid_t ifs[GNRC_NETIF_NUMOF]; uint16_t pan = COMM_PAN; uint16_t chan = COMM_CHAN; /* get the PID of the first radio */ if (gnrc_netif_get(ifs) <= 0) { puts("ERROR: comm init, not radio found!\n"); return (-1); } /* initialize the radio */ gnrc_netapi_set(ifs[0], NETOPT_NID, 0, &pan, 2); gnrc_netapi_set(ifs[0], NETOPT_CHANNEL, 0, &chan, 2); return 0; }
static int _netif_set_encrypt_key(kernel_pid_t dev, netopt_t opt, char *key_str) { size_t str_len = strlen(key_str); size_t key_len = str_len / 2; uint8_t key[key_len]; if (str_len == 14U) { printf("\nNotice: setting 56 bit key."); } else if (str_len == 16U) { printf("\nNotice: setting 64 bit key."); } else if (str_len == 32U) { printf("\nNotice: setting 128 bit key."); } else if (str_len == 48U) { printf("\nNotice: setting 192 bit key."); } else if (str_len == 64U) { printf("\nNotice: setting 256 bit key."); } else if (str_len == 128U) { printf("\nNotice: setting 512 bit key."); } else { printf("error: invalid key size.\n"); return 1; } /* Convert any char from ASCII table in hex format */ for (size_t i = 0; i < str_len; i += 2) { int i1 = _hex_to_int(key_str[i]); int i2 = _hex_to_int(key_str[i + 1]); if (i1 == -1 || i2 == -1) { puts("error: unable to parse key"); return 1; } key[i / 2] = (uint8_t)((i1 << 4) + i2); } if (gnrc_netapi_set(dev, opt, 0, key, key_len) < 0) { printf("error: unable to set "); _print_netopt(opt); puts(""); return 1; } printf("success: set "); _print_netopt(opt); printf(" on interface %" PRIkernel_pid " to \n", dev); for (size_t i = 0; i < key_len; i++) { /* print the hex value of the key */ printf("%02x", key[i]); } puts(""); return 0; }
void gnrc_ipv6_netif_init_by_dev(void) { kernel_pid_t ifs[GNRC_NETIF_NUMOF]; size_t ifnum = gnrc_netif_get(ifs); for (size_t i = 0; i < ifnum; i++) { ipv6_addr_t addr; eui64_t iid; gnrc_ipv6_netif_t *ipv6_if = gnrc_ipv6_netif_get(ifs[i]); if (ipv6_if == NULL) { continue; } mutex_lock(&ipv6_if->mutex); #ifdef MODULE_GNRC_SIXLOWPAN gnrc_nettype_t if_type = GNRC_NETTYPE_UNDEF; if ((gnrc_netapi_get(ifs[i], NETOPT_PROTO, 0, &if_type, sizeof(if_type)) != -ENOTSUP) && (if_type == GNRC_NETTYPE_SIXLOWPAN)) { uint16_t src_len = 8; uint16_t max_frag_size = UINT16_MAX; DEBUG("ipv6 netif: Set 6LoWPAN flag\n"); ipv6_ifs[i].flags |= GNRC_IPV6_NETIF_FLAGS_SIXLOWPAN; /* use EUI-64 (8-byte address) for IID generation and for sending * packets */ gnrc_netapi_set(ifs[i], NETOPT_SRC_LEN, 0, &src_len, sizeof(src_len)); /* don't care for result */ if (gnrc_netapi_get(ifs[i], NETOPT_MAX_PACKET_SIZE, 0, &max_frag_size, sizeof(max_frag_size)) < 0) { /* if error we assume it works */ DEBUG("ipv6 netif: Can not get max packet size from interface %" PRIkernel_pid "\n", ifs[i]); } gnrc_sixlowpan_netif_add(ifs[i], max_frag_size); } #endif if ((gnrc_netapi_get(ifs[i], NETOPT_IPV6_IID, 0, &iid, sizeof(eui64_t)) < 0)) { mutex_unlock(&ipv6_if->mutex); continue; } ipv6_addr_set_aiid(&addr, iid.uint8); ipv6_addr_set_link_local_prefix(&addr); _add_addr_to_entry(ipv6_if, &addr, 64, 0); mutex_unlock(&ipv6_if->mutex); } }
static int _netif_set_flag(kernel_pid_t dev, netopt_t opt, netopt_enable_t set) { if (gnrc_netapi_set(dev, opt, 0, &set, sizeof(netopt_enable_t)) < 0) { puts("error: unable to set option"); return 1; } printf("success: %sset option\n", (set) ? "" : "un"); return 0; }
void comm_init(void) { uint8_t addr[2] = CONF_COMM_ADDR; uint16_t pan = CONF_COMM_PAN; uint16_t chan = CONF_COMM_CHAN; /* get the PID of the first radio */ gnrc_netif_t *netif = gnrc_netif_iter(NULL); if (netif == NULL) { puts("comm: ERROR during init, not radio found\n"); return; } /* initialize the radio */ puts("comm: setting address and PAN"); gnrc_netapi_set(netif->pid, NETOPT_ADDRESS, 0, &addr, 2); gnrc_netapi_set(netif->pid, NETOPT_NID, 0, &pan, 2); gnrc_netapi_set(netif->pid, NETOPT_CHANNEL, 0, &chan, 2); }
static int _netif_set_u16(kernel_pid_t iface, netopt_t opt, uint16_t context, char *u16_str) { unsigned long int res; bool hex = false; if (_is_number(u16_str)) { if ((res = strtoul(u16_str, NULL, 10)) == ULONG_MAX) { puts("error: unable to parse value.\n" "Must be a 16-bit unsigned integer (dec or hex)\n"); return 1; } } else { if ((res = strtoul(u16_str, NULL, 16)) == ULONG_MAX) { puts("error: unable to parse value.\n" "Must be a 16-bit unsigned integer (dec or hex)\n"); return 1; } hex = true; } if (res > 0xffff) { puts("error: unable to parse value.\n" "Must be a 16-bit unsigned integer (dec or hex)\n"); return 1; } if (gnrc_netapi_set(iface, opt, context, (uint16_t *)&res, sizeof(uint16_t)) < 0) { printf("error: unable to set "); _print_netopt(opt); puts(""); return 1; } printf("success: set "); _print_netopt(opt); printf(" on interface %" PRIkernel_pid " to ", iface); if (hex) { printf("0x%04lx\n", res); } else { printf("%lu\n", res); } return 0; }
static void _set_test_mode(int argc, char **argv, uint8_t mode) { (void) argc; if (_is_number(argv[1])) { kernel_pid_t dev = atoi(argv[1]); if (gnrc_netif_get_by_pid(dev)) { gnrc_netapi_set(dev, NETOPT_RF_TESTMODE, 0, (void *)&mode, sizeof(mode)); return; } } printf("usage: %s <if_id>\n", argv[0]); return; }
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_set_i16(kernel_pid_t dev, netopt_t opt, char *i16_str) { int16_t val = (int16_t)atoi(i16_str); if (gnrc_netapi_set(dev, opt, 0, (int16_t *)&val, sizeof(int16_t)) < 0) { printf("error: unable to set "); _print_netopt(opt); puts(""); return 1; } printf("success: set "); _print_netopt(opt); printf(" on interface %" PRIkernel_pid " to %i\n", dev, val); 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; }
static int _netif_set_state(kernel_pid_t iface, char *state_str) { netopt_state_t state; if ((strcmp("off", state_str) == 0) || (strcmp("OFF", state_str) == 0)) { state = NETOPT_STATE_OFF; } else if ((strcmp("sleep", state_str) == 0) || (strcmp("SLEEP", state_str) == 0)) { state = NETOPT_STATE_SLEEP; } else if ((strcmp("idle", state_str) == 0) || (strcmp("IDLE", state_str) == 0)) { state = NETOPT_STATE_IDLE; } else if ((strcmp("rx", state_str) == 0) || (strcmp("RX", state_str) == 0)) { state = NETOPT_STATE_RX; } else if ((strcmp("tx", state_str) == 0) || (strcmp("TX", state_str) == 0)) { state = NETOPT_STATE_TX; } else if ((strcmp("reset", state_str) == 0) || (strcmp("RESET", state_str) == 0)) { state = NETOPT_STATE_RESET; } else if ((strcmp("standby", state_str) == 0) || (strcmp("STANDBY", state_str) == 0)) { state = NETOPT_STATE_STANDBY; } else { puts("usage: ifconfig <if_id> set state [off|sleep|idle|rx|tx|reset|standby]"); return 1; } if (gnrc_netapi_set(iface, NETOPT_STATE, 0, &state, sizeof(netopt_state_t)) < 0) { printf("error: unable to set state to %s\n", _netopt_state_str[state]); return 1; } printf("success: set state of interface %" PRIkernel_pid " to %s\n", iface, _netopt_state_str[state]); return 0; }
static int _netif_set_u8(kernel_pid_t iface, netopt_t opt, uint16_t context, char *u8_str) { uint8_t val = atoi(u8_str); if (gnrc_netapi_set(iface, opt, context, (uint8_t *)&val, sizeof(uint8_t)) < 0) { printf("error: unable to set "); _print_netopt(opt); puts(""); return 1; } printf("success: set "); _print_netopt(opt); printf(" on interface %" PRIkernel_pid " to %i\n", iface, val); return 0; }
static int test_set_addr(void) { static const uint8_t new_addr[] = { 0x71, 0x29, 0x5b, 0xc8, 0x52, 0x65 }; uint8_t tmp[sizeof(new_addr)]; if (gnrc_netapi_set(_mac_pid, NETOPT_ADDRESS, 0, (void *)new_addr, sizeof(new_addr)) != sizeof(new_addr)) { puts("Error setting device address"); return 0; } if (gnrc_netapi_get(_mac_pid, NETOPT_ADDRESS, 0, tmp, sizeof(tmp)) != sizeof(tmp)) { puts("Error setting device address"); return 0; } else if (memcmp(tmp, new_addr, sizeof(new_addr)) != 0) { puts("Set to wrong device address"); return 0; } return 1; }
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; }
int watr_li_network_init (void) { DEBUG("%s()\n", __func__); kernel_pid_t ifs[GNRC_NETIF_NUMOF]; uint16_t channel = WATR_LI_CHANNEL; uint16_t pan_id = WATR_LI_PAN; if (0 >= gnrc_netif_get(ifs)) { puts ("[watr_li_network_init] ERROR: failed to get ifaces!"); return -1; } if (0 > gnrc_netapi_set(ifs[0], NETOPT_CHANNEL, 0, (uint16_t *)&channel, sizeof(uint16_t))) { puts ("[watr_li_network_init] ERROR: failed to set channel!"); return -1; } if (0 > gnrc_netapi_set(ifs[0], NETOPT_NID, 0, (uint16_t *)&pan_id, sizeof(uint16_t))) { puts ("[watr_li_network_init] ERROR: failed to set pan_id!"); return -1; } uint8_t iid[8]; if (0 > gnrc_netapi_get(ifs[0], NETOPT_IPV6_IID, 0, &iid, sizeof(iid))) { puts ("[watr_li_network_init] ERROR: failed to get IPv6 IID!"); return -1; } #ifdef WATR_LI_GLOBAL_IPV6 ipv6_addr_t myaddr; ipv6_addr_set_aiid(&myaddr, iid); myaddr.u64[0] = byteorder_htonll(0x2015110700000000); if (0 > gnrc_ipv6_netif_add_addr(ifs[0], &myaddr, 64, 0)) { puts ("[watr_li_network_init] ERROR: failed to set IPv6 addr!"); return -1; } #endif send_sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); if (send_sock < 0) { puts("[watr_li_network_init] ERROR: initializing send socket!"); return -1; } /* FIXME stringify my_id. we'll be needing this in a sec. */ memset(my_id, 0, sizeof(my_id)); sprintf(my_id, "%02X%02X%02X%02X%02X%02X%02X%02X", iid[0],iid[1],iid[2],iid[3],iid[4],iid[5],iid[6],iid[7]); /* Add my_id to humidity_path */ register_path = (coap_endpoint_path_t) {1, {"nodes"}}; //FIXME: should be nodes/my_id ? humidity_path = (coap_endpoint_path_t) {3, {"nodes", my_id, "humidity"}}; if (0 > watr_li_set_root_addr(watr_li_root_addr_str)) { puts("[watr_li_network_init] ERROR: failed to set root_addr!"); return -1; } if (0 > watr_li_register_at_root(my_id)) { puts("[watr_li_network_init] ERROR: failed to register at root!"); return -1; } 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 }
void gnrc_ipv6_netif_init_by_dev(void) { kernel_pid_t ifs[GNRC_NETIF_NUMOF]; size_t ifnum = gnrc_netif_get(ifs); #ifdef MODULE_GNRC_SIXLOWPAN_ND_BORDER_ROUTER bool abr_init = false; #endif for (size_t i = 0; i < ifnum; i++) { ipv6_addr_t addr; eui64_t iid; uint16_t tmp; gnrc_ipv6_netif_t *ipv6_if = gnrc_ipv6_netif_get(ifs[i]); if (ipv6_if == NULL) { continue; } mutex_lock(&ipv6_if->mutex); #ifdef MODULE_GNRC_SIXLOWPAN gnrc_nettype_t if_type = GNRC_NETTYPE_UNDEF; if ((gnrc_netapi_get(ifs[i], NETOPT_PROTO, 0, &if_type, sizeof(if_type)) != -ENOTSUP) && (if_type == GNRC_NETTYPE_SIXLOWPAN)) { uint16_t src_len = 8; uint16_t max_frag_size = UINT16_MAX; DEBUG("ipv6 netif: Set 6LoWPAN flag\n"); ipv6_ifs[i].flags |= GNRC_IPV6_NETIF_FLAGS_SIXLOWPAN; /* the router flag must be set early here, because otherwise * _add_addr_to_entry() wouldn't set the solicited node address. * However, addresses have to be configured before calling * gnrc_ipv6_netif_set_router(). */ #ifdef MODULE_GNRC_SIXLOWPAN_ND_ROUTER DEBUG("ipv6 netif: Set router flag\n"); ipv6_ifs[i].flags |= GNRC_IPV6_NETIF_FLAGS_ROUTER; #endif /* use EUI-64 (8-byte address) for IID generation and for sending * packets */ gnrc_netapi_set(ifs[i], NETOPT_SRC_LEN, 0, &src_len, sizeof(src_len)); /* don't care for result */ if (gnrc_netapi_get(ifs[i], NETOPT_MAX_PACKET_SIZE, 0, &max_frag_size, sizeof(max_frag_size)) < 0) { /* if error we assume it works */ DEBUG("ipv6 netif: Can not get max packet size from interface %" PRIkernel_pid "\n", ifs[i]); } gnrc_sixlowpan_netif_add(ifs[i], max_frag_size); } #endif /* set link-local address */ if ((gnrc_netapi_get(ifs[i], NETOPT_IPV6_IID, 0, &iid, sizeof(eui64_t)) < 0)) { mutex_unlock(&ipv6_if->mutex); continue; } ipv6_addr_set_aiid(&addr, iid.uint8); ipv6_addr_set_link_local_prefix(&addr); _add_addr_to_entry(ipv6_if, &addr, 64, 0); /* set link MTU */ if ((gnrc_netapi_get(ifs[i], NETOPT_MAX_PACKET_SIZE, 0, &tmp, sizeof(uint16_t)) >= 0)) { if (tmp >= IPV6_MIN_MTU) { ipv6_if->mtu = tmp; } /* otherwise leave at GNRC_IPV6_NETIF_DEFAULT_MTU as initialized in * gnrc_ipv6_netif_add() */ } if (gnrc_netapi_get(ifs[i], NETOPT_IS_WIRED, 0, &tmp, sizeof(int)) > 0) { ipv6_if->flags |= GNRC_IPV6_NETIF_FLAGS_IS_WIRED; } else { ipv6_if->flags &= ~GNRC_IPV6_NETIF_FLAGS_IS_WIRED; } mutex_unlock(&ipv6_if->mutex); #if (defined(MODULE_GNRC_NDP_ROUTER) || defined(MODULE_GNRC_SIXLOWPAN_ND_ROUTER)) gnrc_ipv6_netif_set_router(ipv6_if, true); #endif #ifdef MODULE_GNRC_SIXLOWPAN_ND if (ipv6_if->flags & GNRC_IPV6_NETIF_FLAGS_SIXLOWPAN) { #ifdef MODULE_GNRC_SIXLOWPAN_ND_BORDER_ROUTER /* first interface wins */ if (!abr_init) { gnrc_sixlowpan_nd_router_abr_create(&addr, 0); gnrc_ipv6_netif_set_rtr_adv(ipv6_if, true); abr_init = true; } #endif gnrc_sixlowpan_nd_init(ipv6_if); continue; /* skip gnrc_ndp_host_init() */ } #endif #ifdef MODULE_GNRC_NDP_HOST /* start periodic router solicitations */ gnrc_ndp_host_init(ipv6_if); #endif } }