void riot_send_nack(uint16_t to)
{
msg_t m;
m.type = CCNL_RIOT_NACK;
DEBUGMSG(1, "sending NACK msg to pid=%" PRIkernel_pid"\n", to);
msg_try_send(&m, to);
}
int socket_base_net_msg_send(msg_t *m, kernel_pid_t pid, bool block, uint16_t message)
{
m->type = message;
if (block) {
return msg_send(m, pid);
} else {
return msg_try_send(m, pid);
}
}
static inline int _snd_rcv(kernel_pid_t pid, uint16_t type, gnrc_pktsnip_t *pkt)
{
msg_t msg;
/* set the outgoing message's fields */
msg.type = type;
msg.content.ptr = (void *)pkt;
/* send message */
int ret = msg_try_send(&msg, pid);
if (ret < 1) {
DEBUG("gnrc_netapi: dropped message to %" PRIkernel_pid " (%s)\n", pid,
(ret == 0) ? "receiver queue is full" : "invalid receiver");
}
return ret;
}
/**
* @brief local callback to handle incoming content chunks
*
* @note Gets called from CCNL thread context
*
* @returns 1 if chunk is handled and no further processing should happen
* @returns 0 otherwise
**/
int ccnlriot_consumer(struct ccnl_relay_s *relay, struct ccnl_face_s *from,
struct ccnl_pkt_s *pkt)
{
(void) from;
(void) relay;
if (dow_state == DOW_STATE_STOPPED) {
LOG_DEBUG("ccnl_helper: we're in stopped, do nothing\n");
free_packet(pkt);
return 1;
}
uint32_t cont_id = (uint32_t) strtol((char*)pkt->pfx->comp[2], NULL, 16);
if (cont_id > dow_highest_id) {
dow_highest_id = cont_id;
}
LOG_DEBUG("%" PRIu32 " ccnl_helper: local consumer for prefix: %s\n", xtimer_now().ticks32,
ccnl_prefix_to_path_detailed(_prefix_str, pkt->pfx, 1, 0, 0));
memset(_prefix_str, 0, CCNLRIOT_PFX_LEN);
#if DOW_DEPUTY
/* XXX: might be unnecessary du to mutex now */
/* if we're currently transferring our cache to the new deputy, we do not touch the content store */
if (dow_state == DOW_STATE_HANDOVER) {
LOG_DEBUG("ccnl_helper: we're in handover state, cannot touch content store right now\n");
free_packet(pkt);
return 1;
}
#endif
/* check if prefix is for ALL and contains an ACK */
if ((ccnl_prefix_cmp(ccnl_helper_all_pfx, NULL, pkt->pfx, CMP_MATCH) >= 1) &&
(strncmp((char*) pkt->content, CCNLRIOT_CONT_ACK, strlen(CCNLRIOT_CONT_ACK)) == 0)) {
dow_content_t *cc = (dow_content_t*) pkt->content;
LOG_DEBUG("ccnl_helper: content number is %i\n", cc->num);
if (cc->num >= 0) {
_remove_pit(relay, cc->num);
}
LOG_DEBUG("ccnl_helper: received ACK, flag the content\n");
msg_t m = { .type = DOW_MSG_RECEIVED_ACK };
msg_try_send(&m, dow_pid);
free_packet(pkt);
return 1;
}
int nhdp_register_if(kernel_pid_t if_pid, uint8_t *addr, size_t addr_size, uint8_t addr_type,
uint16_t max_pl_size, uint16_t hello_int_ms, uint16_t val_time_ms)
{
nhdp_if_entry_t *if_entry = NULL;
nhdp_addr_t *nhdp_addr;
msg_t signal_msg;
if (nhdp_rcv_pid != KERNEL_PID_UNDEF) {
return -2;
}
for (int i = 0; i < GNRC_NETIF_NUMOF; i++) {
if (nhdp_if_table[i].if_pid == KERNEL_PID_UNDEF) {
if_entry = &nhdp_if_table[i];
break;
}
}
if (!if_entry) {
/* Maximum number of registerable interfaces reached */
return -2;
}
uint16_t payload_size = max_pl_size > NHDP_MAX_RFC5444_PACKET_SZ
? NHDP_MAX_RFC5444_PACKET_SZ : max_pl_size;
if_entry->wr_target.packet_buffer = (uint8_t *) calloc(payload_size, sizeof(uint8_t));
if (!if_entry->wr_target.packet_buffer) {
/* Insufficient memory */
return -1;
}
if_entry->wr_target.packet_size = payload_size;
if_entry->wr_target.sendPacket = write_packet;
/* Get NHDP address entry for the given address */
nhdp_addr = nhdp_addr_db_get_address(addr, addr_size, addr_type);
if (!nhdp_addr) {
/* Insufficient memory */
free(if_entry->wr_target.packet_buffer);
return -1;
}
/* Add the interface to the LIB */
if (lib_add_if_addr(if_pid, nhdp_addr) != 0) {
free(if_entry->wr_target.packet_buffer);
nhdp_decrement_addr_usage(nhdp_addr);
return -1;
}
/* Create new IIB for the interface */
if (iib_register_if(if_pid) != 0) {
/* TODO: Cleanup lib entry */
free(if_entry->wr_target.packet_buffer);
nhdp_decrement_addr_usage(nhdp_addr);
return -1;
}
/* Set Interface's PID */
if_entry->if_pid = if_pid;
/* Set HELLO_INTERVAL and H_HOLD_TIME (validity time) */
if_entry->hello_interval.seconds = 0;
if_entry->hello_interval.microseconds = MS_IN_USEC * hello_int_ms;
if_entry->validity_time.seconds = 0;
if_entry->validity_time.microseconds = MS_IN_USEC * val_time_ms;
timex_normalize(&if_entry->hello_interval);
timex_normalize(&if_entry->validity_time);
/* Reset sequence number */
if_entry->seq_no = 0;
/* Everything went well */
nhdp_decrement_addr_usage(nhdp_addr);
nhdp_writer_register_if(&if_entry->wr_target);
helper_pid = if_pid;
/* Start the receiving thread */
nhdp_rcv_pid = thread_create(nhdp_rcv_stack, sizeof(nhdp_rcv_stack), THREAD_PRIORITY_MAIN - 1,
THREAD_CREATE_STACKTEST, _nhdp_receiver, NULL, "nhdp_rcv_thread");
/* Start sending periodic HELLO */
signal_msg.type = HELLO_TIMER;
signal_msg.content.ptr = if_entry;
/* TODO: msg_send or msg_try_send? */
msg_try_send(&signal_msg, nhdp_pid);
return 0;
}
/*
* @brief Processes a packet received by any transceiver device
*
* @param type The message type to determine which device has received the
* packet
* @param pos The current device driver's buffer position
*/
static void receive_packet(uint16_t type, uint8_t pos)
{
size_t i = 0;
transceiver_type_t t;
rx_buffer_pos = pos;
msg_t m;
DEBUG("Packet received\n");
switch (type) {
case RCV_PKT_CC1020:
t = TRANSCEIVER_CC1020;
break;
case RCV_PKT_CC1100:
t = TRANSCEIVER_CC1100;
break;
case RCV_PKT_CC2420:
t = TRANSCEIVER_CC2420;
break;
case RCV_PKT_MC1322X:
t = TRANSCEIVER_MC1322X;
break;
case RCV_PKT_NATIVE:
t = TRANSCEIVER_NATIVE;
break;
case RCV_PKT_AT86RF231:
t = TRANSCEIVER_AT86RF231;
break;
default:
t = TRANSCEIVER_NONE;
break;
}
/* search first free position in transceiver buffer */
for (i = 0; (i < TRANSCEIVER_BUFFER_SIZE) && (transceiver_buffer[transceiver_buffer_pos].processing); i++) {
if (++transceiver_buffer_pos == TRANSCEIVER_BUFFER_SIZE) {
transceiver_buffer_pos = 0;
}
}
/* no buffer left */
if (i >= TRANSCEIVER_BUFFER_SIZE) {
/* inform upper layers of lost packet */
m.type = ENOBUFFER;
m.content.value = t;
DEBUG("transceiver: buffer size exceeded, dropping packet\n");
}
/* copy packet and handle it */
else {
m.type = PKT_PENDING;
/* pass a null pointer if a packet from a undefined transceiver is
* received */
if (type == RCV_PKT_CC1100) {
#if (defined(MODULE_CC110X) || defined(MODULE_CC110X_LEGACY))
radio_packet_t *trans_p = &(transceiver_buffer[transceiver_buffer_pos]);
receive_cc110x_packet(trans_p);
#elif MODULE_CC110X_LEGACY_CSMA
radio_packet_t *trans_p = &(transceiver_buffer[transceiver_buffer_pos]);
receive_cc1100_packet(trans_p);
#endif
}
else if (type == RCV_PKT_MC1322X) {
#ifdef MODULE_MC1322X
ieee802154_packet_t *trans_p = &(transceiver_buffer[transceiver_buffer_pos]);
receive_mc1322x_packet(trans_p);
#endif
}
else if (type == RCV_PKT_CC2420) {
#ifdef MODULE_CC2420
ieee802154_packet_t *trans_p = &(transceiver_buffer[transceiver_buffer_pos]);
receive_cc2420_packet(trans_p);
#endif
}
else if (type == RCV_PKT_AT86RF231) {
#ifdef MODULE_AT86RF231
ieee802154_packet_t *trans_p = &(transceiver_buffer[transceiver_buffer_pos]);
receive_at86rf231_packet(trans_p);
#endif
}
else if (type == RCV_PKT_NATIVE) {
#ifdef MODULE_NATIVENET
radio_packet_t *trans_p = &(transceiver_buffer[transceiver_buffer_pos]);
receive_nativenet_packet(trans_p);
#endif
}
else {
puts("Invalid transceiver type");
return;
}
#ifdef DBG_IGNORE
#if MODULE_AT86RF231 || MODULE_CC2420 || MODULE_MC1322X
radio_address_t short_addr;
short_addr = (transceiver_buffer[transceiver_buffer_pos].frame.src_addr[1] << 8)
| transceiver_buffer[transceiver_buffer_pos].frame.src_addr[0];
for (size_t j = 0; (j < TRANSCEIVER_MAX_IGNORED_ADDR) && (transceiver_ignored_addr[j]); j++) {
DEBUG("check if source (%u) is ignored -> %u\n", short_addr, transceiver_ignored_addr[j]);
if (short_addr == transceiver_ignored_addr[j]) {
DEBUG("ignored packet from %" PRIu16 "\n", short_addr);
return;
}
}
#else
for (size_t j = 0; (j < TRANSCEIVER_MAX_IGNORED_ADDR) && (transceiver_ignored_addr[j]); j++) {
DEBUG("check if source (%u) is ignored -> %u\n", transceiver_buffer[transceiver_buffer_pos].src, transceiver_ignored_addr[j]);
if (transceiver_buffer[transceiver_buffer_pos].src == transceiver_ignored_addr[j]) {
DEBUG("ignored packet from %" PRIu16 "\n", transceiver_buffer[transceiver_buffer_pos].src);
return;
}
}
#endif
#endif
}
/* finally notify waiting upper layers
* this is done non-blocking, so packets can get lost */
i = 0;
while (reg[i].transceivers != TRANSCEIVER_NONE) {
if (reg[i].transceivers & t) {
m.content.ptr = (char *) &(transceiver_buffer[transceiver_buffer_pos]);
DEBUG("transceiver: Notify thread %" PRIkernel_pid "\n", reg[i].pid);
if (msg_try_send(&m, reg[i].pid) && (m.type != ENOBUFFER)) {
transceiver_buffer[transceiver_buffer_pos].processing++;
}
else {
DEBUG("transceiver: failed to notify upper layer.\n");
}
}
i++;
}
}
