void task_resNotifSendDone() {
OpenQueueEntry_t* msg;
// get recently-sent packet from openqueue
msg = openqueue_resGetSentPacket();
if (msg==NULL) {
// log the error
openserial_printError(COMPONENT_RES,ERR_NO_SENT_PACKET,
(errorparameter_t)0,
(errorparameter_t)0);
// abort
return;
}
// declare it as mine
msg->owner = COMPONENT_RES;
// indicate transmission (to update statistics)
if (msg->l2_sendDoneError==E_SUCCESS) {
neighbors_indicateTx(&(msg->l2_nextORpreviousHop),
msg->l2_numTxAttempts,
TRUE,
&msg->l2_asn);
/* piggy502: only apply Rx mask after a RES packet is sent */
switch(msg->creator){
case COMPONENT_RES:
applyRxMask();
break;
default:
break;
}
} else {
neighbors_indicateTx(&(msg->l2_nextORpreviousHop),
msg->l2_numTxAttempts,
FALSE,
&msg->l2_asn);
}
// send the packet to where it belongs
if (msg->creator == COMPONENT_RES) {
// discard (ADV or KA) packets this component has created
openqueue_freePacketBuffer(msg);
// I can send the next ADV or KA
res_vars.busySending = FALSE;
// restart a random timer
res_vars.periodMaintenance = 1700+(openrandom_get16b()&0xff);
opentimers_setPeriod(res_vars.timerId,
TIME_MS,
res_vars.periodMaintenance);
} else {
// send the rest up the stack
iphc_sendDone(msg,msg->l2_sendDoneError);
}
}
void openbridge_triggerData(OpenMote* self) {
uint8_t input_buffer[136];//worst case: 8B of next hop + 128B of data
OpenQueueEntry_t* pkt;
uint8_t numDataBytes;
numDataBytes = openserial_getNumDataBytes(self);
//poipoi xv
//this is a temporal workaround as we are never supposed to get chunks of data
//longer than input buffer size.. I assume that HDLC will solve that.
// MAC header is 13B + 8 next hop so we cannot accept packets that are longer than 118B
if (numDataBytes>(136 - 10/*21*/) || numDataBytes<8){
//to prevent too short or too long serial frames to kill the stack
openserial_printError(self, COMPONENT_OPENBRIDGE,ERR_INPUTBUFFER_LENGTH,
(errorparameter_t)numDataBytes,
(errorparameter_t)0);
return;
}
//copying the buffer once we know it is not too big
openserial_getInputBuffer(self, &(input_buffer[0]),numDataBytes);
if ( idmanager_getIsDAGroot(self)==TRUE && numDataBytes>0) {
pkt = openqueue_getFreePacketBuffer(self, COMPONENT_OPENBRIDGE);
if (pkt==NULL) {
openserial_printError(self, COMPONENT_OPENBRIDGE,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
return;
}
//admin
pkt->creator = COMPONENT_OPENBRIDGE;
pkt->owner = COMPONENT_OPENBRIDGE;
//l2
pkt->l2_nextORpreviousHop.type = ADDR_64B;
memcpy(&(pkt->l2_nextORpreviousHop.addr_64b[0]),&(input_buffer[0]),8);
//payload
packetfunctions_reserveHeaderSize(self, pkt,numDataBytes-8);
memcpy(pkt->payload,&(input_buffer[8]),numDataBytes-8);
//this is to catch the too short packet. remove it after fw-103 is solved.
if (numDataBytes<16){
openserial_printError(self, COMPONENT_OPENBRIDGE,ERR_INVALIDSERIALFRAME,
(errorparameter_t)0,
(errorparameter_t)0);
}
//send
if (( iphc_sendFromBridge(self, pkt))==E_FAIL) {
openqueue_freePacketBuffer(self, pkt);
}
}
}
/**
\brief Indicates a packet has been sent.
\param[in,out] msg The packet just sent.
\param[in] error The outcome of sending it.
*/
void forwarding_sendDone(OpenQueueEntry_t* msg, owerror_t error) {
// take ownership
msg->owner = COMPONENT_FORWARDING;
if (msg->creator==COMPONENT_RADIO || msg->creator==COMPONENT_FORWARDING) {
// this is a relayed packet
// free packet
openqueue_freePacketBuffer(msg);
} else {
// this is a packet created by this mote
// indicate sendDone to upper layer
switch(msg->l4_protocol) {
case IANA_TCP:
opentcp_sendDone(msg,error);
break;
case IANA_UDP:
openudp_sendDone(msg,error);
break;
case IANA_ICMPv6:
icmpv6_sendDone(msg,error);
break;
default:
// log error
openserial_printCritical(
COMPONENT_FORWARDING,
ERR_WRONG_TRAN_PROTOCOL,
(errorparameter_t)msg->l4_protocol,
(errorparameter_t)0
);
// free packet
openqueue_freePacketBuffer(msg);
}
}
}
void techo_receive(OpenMote* self, OpenQueueEntry_t* msg) {
uint16_t temp_l4_destination_port;
msg->owner = COMPONENT_TECHO;
//reply with the same OpenQueueEntry_t
msg->creator = COMPONENT_TECHO;
msg->l4_protocol = IANA_TCP;
temp_l4_destination_port = msg->l4_destination_port;
msg->l4_destination_port = msg->l4_sourcePortORicmpv6Type;
msg->l4_sourcePortORicmpv6Type = temp_l4_destination_port;
if ( opentcp_send(self, msg)==E_FAIL) {
openqueue_freePacketBuffer(self, msg);
}
}
void uecho_receive(OpenMote* self, OpenQueueEntry_t* request) {
uint16_t temp_l4_destination_port;
OpenQueueEntry_t* reply;
reply = openqueue_getFreePacketBuffer(self, COMPONENT_UECHO);
if (reply==NULL) {
openserial_printError(self,
COMPONENT_UECHO,
ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0
);
openqueue_freePacketBuffer(self, request); //clear the request packet as well
return;
}
reply->owner = COMPONENT_UECHO;
// reply with the same OpenQueueEntry_t
reply->creator = COMPONENT_UECHO;
reply->l4_protocol = IANA_UDP;
temp_l4_destination_port = request->l4_destination_port;
reply->l4_destination_port = request->l4_sourcePortORicmpv6Type;
reply->l4_sourcePortORicmpv6Type = temp_l4_destination_port;
reply->l3_destinationAdd.type = ADDR_128B;
// copy source to destination to echo.
memcpy(&reply->l3_destinationAdd.addr_128b[0],&request->l3_sourceAdd.addr_128b[0],16);
packetfunctions_reserveHeaderSize(self, reply,request->length);
memcpy(&reply->payload[0],&request->payload[0],request->length);
openqueue_freePacketBuffer(self, request);
if (( openudp_send(self, reply))==E_FAIL) {
openqueue_freePacketBuffer(self, reply);
}
}
void forwarding_sendDone(OpenQueueEntry_t* msg, error_t error) {
msg->owner = COMPONENT_FORWARDING;
if (msg->creator==COMPONENT_RADIO || msg->creator==COMPONENT_FORWARDING) {//that was a packet I had relayed
openqueue_freePacketBuffer(msg);
} else {//that was a packet coming from above
switch(msg->l4_protocol) {
case IANA_TCP:
opentcp_sendDone(msg,error);
break;
case IANA_UDP:
openudp_sendDone(msg,error);
break;
case IANA_ICMPv6:
icmpv6_sendDone(msg,error);
break;
default:
openserial_printError(COMPONENT_FORWARDING,ERR_WRONG_TRAN_PROTOCOL,
(errorparameter_t)msg->l4_protocol,
(errorparameter_t)0);
// free the corresponding packet buffer
openqueue_freePacketBuffer(msg);
}
}
}
void openudp_sendDone(OpenQueueEntry_t* msg, owerror_t error) {
msg->owner = COMPONENT_OPENUDP;
switch(msg->l4_sourcePortORicmpv6Type) {
case WKP_UDP_COAP:
opencoap_sendDone(msg,error);
break;
case WKP_UDP_ECHO:
uecho_sendDone(msg,error);
break;
default:
openserial_printError(COMPONENT_OPENUDP,ERR_UNSUPPORTED_PORT_NUMBER,
(errorparameter_t)msg->l4_sourcePortORicmpv6Type,
(errorparameter_t)5);
openqueue_freePacketBuffer(msg);
}
}
/**
\brief Receive a frame at the openbridge, which sends it out over serial.
*/
void openbridge_receive(OpenQueueEntry_t* msg) {
// prepend previous hop
packetfunctions_reserveHeaderSize(msg,LENGTH_ADDR64b);
memcpy(msg->payload,msg->l2_nextORpreviousHop.addr_64b,LENGTH_ADDR64b);
// prepend next hop (me)
packetfunctions_reserveHeaderSize(msg,LENGTH_ADDR64b);
memcpy(msg->payload,idmanager_getMyID(ADDR_64B)->addr_64b,LENGTH_ADDR64b);
// send packet over serial (will be memcopied into serial buffer)
openserial_printData((uint8_t*)(msg->payload),msg->length);
// free packet
openqueue_freePacketBuffer(msg);
}
/**
\brief Called when DIO/DAO was sent.
\param[in] msg Pointer to the message just sent.
\param[in] error Outcome of the sending.
*/
void icmpv6rpl_sendDone(OpenQueueEntry_t* msg, owerror_t error) {
// take ownership over that packet
msg->owner = COMPONENT_ICMPv6RPL;
// make sure I created it
if (msg->creator!=COMPONENT_ICMPv6RPL) {
openserial_printError(COMPONENT_ICMPv6RPL,ERR_UNEXPECTED_SENDDONE,
(errorparameter_t)0,
(errorparameter_t)0);
}
// free packet
openqueue_freePacketBuffer(msg);
// I'm not busy sending anymore
icmpv6rpl_vars.busySending = FALSE;
}
void ohlone_receive(OpenQueueEntry_t* msg) {
uint8_t payload_index;
for (payload_index=0;payload_index<msg->length-3;payload_index++) {
if (ohlone_check4chars(msg->payload+payload_index,(unsigned char *) "GET "))
memcpy(ohlone_vars.getRequest,
msg->payload + payload_index + 4,
msg->length - payload_index - 4);
if (ohlone_check4chars(msg->payload+payload_index, (unsigned char *)"\r\n\r\n")) {
ohlone_vars.httpChunk = 0;
ohlone_sendpkt();
return;
}
}
openserial_printData((uint8_t*)(msg->payload),msg->length);
openqueue_freePacketBuffer(msg);
}
void icmpv6_sendDone(OpenQueueEntry_t* msg, error_t error) {
msg->owner = COMPONENT_ICMPv6;
switch (msg->l4_sourcePortORicmpv6Type) {
case IANA_ICMPv6_ECHO_REQUEST:
case IANA_ICMPv6_ECHO_REPLY:
icmpv6echo_sendDone(msg, error);
break;
case IANA_ICMPv6_RPL:
icmpv6rpl_sendDone(msg, error);
break;
default:
openserial_printCritical(COMPONENT_ICMPv6,ERR_UNSUPPORTED_ICMPV6_TYPE,
(errorparameter_t)msg->l4_sourcePortORicmpv6Type,
(errorparameter_t)0);
// free the corresponding packet buffer
openqueue_freePacketBuffer(msg);
break;
}
}
void icmpv6_receive(OpenQueueEntry_t* msg) {
msg->owner = COMPONENT_ICMPv6;
msg->l4_sourcePortORicmpv6Type = ((ICMPv6_ht*)(msg->payload))->type;
switch (msg->l4_sourcePortORicmpv6Type) {
case IANA_ICMPv6_ECHO_REQUEST:
case IANA_ICMPv6_ECHO_REPLY:
icmpv6echo_receive(msg);
break;
case IANA_ICMPv6_RPL:
icmpv6rpl_receive(msg);
break;
default:
openserial_printError(COMPONENT_ICMPv6,ERR_UNSUPPORTED_ICMPV6_TYPE,
(errorparameter_t)msg->l4_sourcePortORicmpv6Type,
(errorparameter_t)1);
// free the corresponding packet buffer
openqueue_freePacketBuffer(msg);
break;
}
}
void uinject_task_cb() {
OpenQueueEntry_t* pkt;
// don't run if not synch
if (ieee154e_isSynch() == FALSE) return;
// don't run on dagroot
if (idmanager_getIsDAGroot()) {
opentimers_stop(uinject_vars.timerId);
return;
}
// if you get here, send a packet
// get a free packet buffer
pkt = openqueue_getFreePacketBuffer(COMPONENT_UINJECT);
if (pkt==NULL) {
openserial_printError(
COMPONENT_UINJECT,
ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0
);
return;
}
pkt->owner = COMPONENT_UINJECT;
pkt->creator = COMPONENT_UINJECT;
pkt->l4_protocol = IANA_UDP;
pkt->l4_destination_port = WKP_UDP_INJECT;
pkt->l4_sourcePortORicmpv6Type = WKP_UDP_INJECT;
pkt->l3_destinationAdd.type = ADDR_128B;
memcpy(&pkt->l3_destinationAdd.addr_128b[0],uinject_dst_addr,16);
packetfunctions_reserveHeaderSize(pkt,sizeof(uint16_t));
*((uint16_t*)&pkt->payload[0]) = uinject_vars.counter++;
if ((openudp_send(pkt))==E_FAIL) {
openqueue_freePacketBuffer(pkt);
}
}
void udpinject_trigger() {
OpenQueueEntry_t* pkt;
uint8_t number_bytes_from_input_buffer;
uint8_t input_buffer[18];
//get command from OpenSerial (16B IPv6 destination address, 2B destination port)
number_bytes_from_input_buffer = openserial_getInputBuffer(&(input_buffer[0]),sizeof(input_buffer));
if (number_bytes_from_input_buffer!=sizeof(input_buffer)) {
openserial_printError(COMPONENT_UDPINJECT,ERR_INPUTBUFFER_LENGTH,
(errorparameter_t)number_bytes_from_input_buffer,
(errorparameter_t)0);
return;
};
//prepare packet
pkt = openqueue_getFreePacketBuffer(COMPONENT_UDPINJECT);
if (pkt==NULL) {
openserial_printError(COMPONENT_UDPINJECT,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
return;
}
pkt->creator = COMPONENT_UDPINJECT;
pkt->owner = COMPONENT_UDPINJECT;
pkt->l4_protocol = IANA_UDP;
pkt->l4_sourcePortORicmpv6Type = WKP_UDP_INJECT;
pkt->l4_destination_port = packetfunctions_ntohs(&(input_buffer[16]));
pkt->l3_destinationAdd.type = ADDR_128B;
memcpy(&(pkt->l3_destinationAdd.addr_128b[0]),&(input_buffer[0]),16);
packetfunctions_reserveHeaderSize(pkt,6);
((uint8_t*)pkt->payload)[0] = 'p';
((uint8_t*)pkt->payload)[1] = 'o';
((uint8_t*)pkt->payload)[2] = 'i';
((uint8_t*)pkt->payload)[3] = 'p';
((uint8_t*)pkt->payload)[4] = 'o';
((uint8_t*)pkt->payload)[5] = 'i';
//send packet
if ((openudp_send(pkt))==E_FAIL) {
openqueue_freePacketBuffer(pkt);
}
}
void openudp_sendDone(OpenQueueEntry_t* msg, error_t error) {
msg->owner = COMPONENT_OPENUDP;
switch(msg->l4_sourcePortORicmpv6Type) {
case WKP_UDP_COAP:
opencoap_sendDone(msg,error);
break;
/*
case WKP_UDP_HELI:
appudpheli_sendDone(msg,error);
break;
case WKP_UDP_IMU:
appudpgina_sendDone(msg,error);
break;
*/
case WKP_UDP_ECHO:
udpecho_sendDone(msg,error);
break;
case WKP_UDP_INJECT:
udpinject_sendDone(msg,error);
break;
case WKP_UDP_DISCARD:
udpprint_sendDone(msg,error);
break;
case WKP_UDP_RAND:
udprand_sendDone(msg,error);
break;
case WKP_UDP_LATENCY:
udplatency_sendDone(msg,error);
break;
default:
openserial_printError(COMPONENT_OPENUDP,ERR_UNSUPPORTED_PORT_NUMBER,
(errorparameter_t)msg->l4_sourcePortORicmpv6Type,
(errorparameter_t)5);
openqueue_freePacketBuffer(msg);
}
}
/**
\brief Called when RPL message received.
\param[in] msg Pointer to the received message.
*/
void icmpv6rpl_receive(OpenQueueEntry_t* msg) {
uint8_t icmpv6code;
open_addr_t myPrefix;
// take ownership
msg->owner = COMPONENT_ICMPv6RPL;
// retrieve ICMPv6 code
icmpv6code = (((ICMPv6_ht*)(msg->payload))->code);
// toss ICMPv6 header
packetfunctions_tossHeader(msg,sizeof(ICMPv6_ht));
// handle message
switch (icmpv6code) {
case IANA_ICMPv6_RPL_DIO:
if (idmanager_getIsBridge()==TRUE) {
// stop here if I'm in bridge mode
break; // break, don't return
}
// update neighbor table
neighbors_indicateRxDIO(msg);
// update DODAGID in DIO/DAO
memcpy(
&(icmpv6rpl_vars.dio.DODAGID[0]),
&(((icmpv6rpl_dio_ht*)(msg->payload))->DODAGID[0]),
sizeof(icmpv6rpl_vars.dio.DODAGID)
);
memcpy(
&(icmpv6rpl_vars.dao.DODAGID[0]),
&(((icmpv6rpl_dio_ht*)(msg->payload))->DODAGID[0]),
sizeof(icmpv6rpl_vars.dao.DODAGID)
);
// remember I got a DODAGID
icmpv6rpl_vars.DODAGIDFlagSet=1;
// update my prefix
myPrefix.type = ADDR_PREFIX;
memcpy(
myPrefix.prefix,
&((icmpv6rpl_dio_ht*)(msg->payload))->DODAGID[0],
sizeof(myPrefix.prefix)
);
idmanager_setMyID(&myPrefix);
break;
case IANA_ICMPv6_RPL_DAO:
// this should never happen
openserial_printCritical(COMPONENT_ICMPv6RPL,ERR_UNEXPECTED_DAO,
(errorparameter_t)0,
(errorparameter_t)0);
break;
default:
// this should never happen
openserial_printCritical(COMPONENT_ICMPv6RPL,ERR_MSG_UNKNOWN_TYPE,
(errorparameter_t)icmpv6code,
(errorparameter_t)0);
break;
}
// free message
openqueue_freePacketBuffer(msg);
}
void udprand_receive(OpenQueueEntry_t* msg) {
openqueue_freePacketBuffer(msg);
}
/**
\brief The stack indicates that the packet was sent.
\param[in] msg The CoAP message just sent.
\param[in] error The outcome of sending it.
*/
void cinfo_sendDone(OpenMote* self, OpenQueueEntry_t* msg, owerror_t error) {
openqueue_freePacketBuffer(self, msg);
}
void iphc_sendDone(OpenQueueEntry_t* msg, owerror_t error) {
msg->owner = COMPONENT_IPHC;
openqueue_freePacketBuffer(msg);
}
void iphc_receive(OpenQueueEntry_t* msg) {
msg->owner = COMPONENT_IPHC;
macpong_send(++msg->payload[0]);
openqueue_freePacketBuffer(msg);
}
void radio_packet_received(OpenQueueEntry_t* packetReceived) {
P1OUT ^= 0x02; // toggle P1.1 for debug
leds_circular_shift(); // circular-shift LEDs for debug
openqueue_freePacketBuffer(packetReceived);
}
void cexample_sendDone(OpenQueueEntry_t* msg, owerror_t error) {
openqueue_freePacketBuffer(msg);
}
/**
\brief Called back from scheduler, when a task must be executed.
*/
void csensors_task_cb(void) {
OpenQueueEntry_t* pkt;
owerror_t outcome;
uint8_t id;
coap_option_iht options[3];
id = csensors_vars.cb_list[csensors_vars.cb_get];
// create a CoAP RD packet
pkt = openqueue_getFreePacketBuffer(COMPONENT_CSENSORS);
if (pkt==NULL) {
openserial_printError(
COMPONENT_CSENSORS,
ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0
);
return;
}
// take ownership over that packet
pkt->creator = COMPONENT_CSENSORS;
pkt->owner = COMPONENT_CSENSORS;
// CoAP payload
csensors_fillpayload(pkt,id);
// location-path0 option
options[0].type = COAP_OPTION_NUM_URIPATH;
options[0].length = sizeof(csensors_path0) - 1;
options[0].pValue = (uint8_t*)csensors_path0;
// location-path1 option
options[1].type = COAP_OPTION_NUM_URIPATH;
options[1].length = csensors_vars.csensors_resource[id].desc.path1len;
options[1].pValue = csensors_vars.csensors_resource[id].desc.path1val;
// content format option
csensors_vars.medType = COAP_MEDTYPE_APPOCTETSTREAM;
options[2].type = COAP_OPTION_NUM_CONTENTFORMAT;
options[2].length = 1;
options[2].pValue = &csensors_vars.medType;
// metadata
pkt->l4_destination_port = WKP_UDP_COAP;
pkt->l3_destinationAdd.type = ADDR_128B;
memcpy(&pkt->l3_destinationAdd.addr_128b[0],&ipAddr_ringmaster,16);
// send
outcome = opencoap_send(
pkt,
COAP_TYPE_NON,
COAP_CODE_REQ_PUT,
2, // token len
options,
3, // options len
&csensors_vars.csensors_resource[id].desc
);
// avoid overflowing the queue if fails
if (outcome==E_FAIL) {
openqueue_freePacketBuffer(pkt);
} else {
csensors_vars.cb_get = (csensors_vars.cb_get+1)%CSENSORSTASKLIST;
}
return;
}
void radio_packet_received(OpenQueueEntry_t* packetReceived) {
openqueue_freePacketBuffer(packetReceived);
P1OUT ^= 0x02; // toggle P1.1 for debug
leds_increment(); // increment LEDs for debug
}
void stupidmac_sendDone(OpenQueueEntry_t* pkt, error_t error) {
openqueue_freePacketBuffer(pkt);
}
/**
\brief Indicate a CoAP messages was received.
A "CoAP message" is simply a UDP datagram received on the CoAP UDP port.
This function will call the appropriate resource, and send back its answer. The
received packetbuffer is reused to contain the response (or error code).
\param[in] msg The received CoAP message.
*/
void opencoap_receive(OpenQueueEntry_t* msg) {
uint16_t temp_l4_destination_port;
uint8_t i;
uint8_t index;
coap_option_t last_option;
coap_resource_desc_t* temp_desc;
bool found;
owerror_t outcome;
// local variables passed to the handlers (with msg)
coap_header_iht coap_header;
coap_option_iht coap_options[MAX_COAP_OPTIONS];
// take ownership over the received packet
msg->owner = COMPONENT_OPENCOAP;
//=== step 1. parse the packet
// parse the CoAP header and remove from packet
index = 0;
coap_header.Ver = (msg->payload[index] & 0xc0) >> 6;
coap_header.T = (coap_type_t)((msg->payload[index] & 0x30) >> 4);
coap_header.TKL = (msg->payload[index] & 0x0f);
index++;
coap_header.Code = (coap_code_t)(msg->payload[index]);
index++;
coap_header.messageID = msg->payload[index]*256+msg->payload[index+1];
index+=2;
// reject unsupported header
if (coap_header.Ver!=COAP_VERSION || coap_header.TKL>COAP_MAX_TKL) {
openserial_printError(
COMPONENT_OPENCOAP,ERR_WRONG_TRAN_PROTOCOL,
(errorparameter_t)0,
(errorparameter_t)coap_header.Ver
);
openqueue_freePacketBuffer(msg);
return;
}
// record the token
memcpy(&coap_header.token[0], &msg->payload[index], coap_header.TKL);
index += coap_header.TKL;
// initialize the coap_options
for (i=0;i<MAX_COAP_OPTIONS;i++) {
coap_options[i].type = COAP_OPTION_NONE;
}
// fill in the coap_options
last_option = COAP_OPTION_NONE;
for (i=0;i<MAX_COAP_OPTIONS;i++) {
// detect when done parsing options
if (msg->payload[index]==COAP_PAYLOAD_MARKER){
// found the payload marker, done parsing options.
index++; // skip marker and stop parsing options
break;
}
// parse this option
coap_options[i].type = (coap_option_t)((uint8_t)last_option+(uint8_t)((msg->payload[index] & 0xf0) >> 4));
last_option = coap_options[i].type;
coap_options[i].length = (msg->payload[index] & 0x0f);
index++;
coap_options[i].pValue = &(msg->payload[index]);
index += coap_options[i].length; //includes length as well
}
// remove the CoAP header+options
packetfunctions_tossHeader(msg,index);
//=== step 2. find the resource to handle the packet
// find the resource this applies to
found = FALSE;
if (
coap_header.Code>=COAP_CODE_REQ_GET &&
coap_header.Code<=COAP_CODE_REQ_DELETE
) {
// this is a request: target resource is indicated as COAP_OPTION_LOCATIONPATH option(s)
// find the resource which matches
// start with the first resource in the linked list
temp_desc = opencoap_vars.resources;
// iterate until matching resource found, or no match
while (found==FALSE) {
if (
coap_options[0].type==COAP_OPTION_NUM_URIPATH &&
coap_options[1].type==COAP_OPTION_NUM_URIPATH &&
temp_desc->path0len>0 &&
temp_desc->path0val!=NULL &&
temp_desc->path1len>0 &&
temp_desc->path1val!=NULL
) {
// resource has a path of form path0/path1
if (
coap_options[0].length==temp_desc->path0len &&
memcmp(coap_options[0].pValue,temp_desc->path0val,temp_desc->path0len)==0 &&
coap_options[1].length==temp_desc->path1len &&
memcmp(coap_options[1].pValue,temp_desc->path1val,temp_desc->path1len)==0
) {
found = TRUE;
};
} else if (
coap_options[0].type==COAP_OPTION_NUM_URIPATH &&
temp_desc->path0len>0 &&
temp_desc->path0val!=NULL
) {
// resource has a path of form path0
if (
coap_options[0].length==temp_desc->path0len &&
memcmp(coap_options[0].pValue,temp_desc->path0val,temp_desc->path0len)==0
) {
found = TRUE;
};
};
// iterate to next resource, if not found
if (found==FALSE) {
if (temp_desc->next!=NULL) {
temp_desc = temp_desc->next;
} else {
break;
}
}
}
} else {
// this is a response: target resource is indicated by message ID
// find the resource which matches
// start with the first resource in the linked list
temp_desc = opencoap_vars.resources;
// iterate until matching resource found, or no match
while (found==FALSE) {
if (coap_header.messageID==temp_desc->messageID) {
found=TRUE;
// call the resource's callback
if (temp_desc->callbackRx!=NULL) {
temp_desc->callbackRx(msg,&coap_header,&coap_options[0]);
}
}
// iterate to next resource, if not found
if (found==FALSE) {
if (temp_desc->next!=NULL) {
temp_desc = temp_desc->next;
} else {
break;
}
}
};
// free the received packet
openqueue_freePacketBuffer(msg);
// stop here: will will not respond to a response
return;
}
//=== step 3. ask the resource to prepare response
if (found==TRUE) {
// call the resource's callback
outcome = temp_desc->callbackRx(msg,&coap_header,&coap_options[0]);
} else {
// reset packet payload (DO NOT DELETE, we will reuse same buffer for response)
msg->payload = &(msg->packet[127]);
msg->length = 0;
// set the CoAP header
coap_header.TKL = 0;
coap_header.Code = COAP_CODE_RESP_NOTFOUND;
}
if (outcome==E_FAIL) {
// reset packet payload (DO NOT DELETE, we will reuse same buffer for response)
msg->payload = &(msg->packet[127]);
msg->length = 0;
// set the CoAP header
coap_header.TKL = 0;
coap_header.Code = COAP_CODE_RESP_METHODNOTALLOWED;
}
//=== step 4. send that packet back
// fill in packet metadata
if (found==TRUE) {
msg->creator = temp_desc->componentID;
} else {
msg->creator = COMPONENT_OPENCOAP;
}
msg->l4_protocol = IANA_UDP;
temp_l4_destination_port = msg->l4_destination_port;
msg->l4_destination_port = msg->l4_sourcePortORicmpv6Type;
msg->l4_sourcePortORicmpv6Type = temp_l4_destination_port;
// set destination address as the current source
msg->l3_destinationAdd.type = ADDR_128B;
memcpy(&msg->l3_destinationAdd.addr_128b[0],&msg->l3_sourceAdd.addr_128b[0],LENGTH_ADDR128b);
// fill in CoAP header
packetfunctions_reserveHeaderSize(msg,4+coap_header.TKL);
msg->payload[0] = (COAP_VERSION << 6) |
(COAP_TYPE_ACK << 4) |
(coap_header.TKL << 0);
msg->payload[1] = coap_header.Code;
msg->payload[2] = coap_header.messageID/256;
msg->payload[3] = coap_header.messageID%256;
memcpy(&msg->payload[4], &coap_header.token[0], coap_header.TKL);
if ((openudp_send(msg))==E_FAIL) {
openqueue_freePacketBuffer(msg);
}
}
/**
\brief Prepare and a send a RPL DIO.
*/
void sendDIO() {
OpenQueueEntry_t* msg;
// stop if I'm not sync'ed
if (ieee154e_isSynch()==FALSE) {
// remove packets genereted by this module (DIO and DAO) from openqueue
openqueue_removeAllCreatedBy(COMPONENT_ICMPv6RPL);
// I'm not busy sending a DIO/DAO
icmpv6rpl_vars.busySending = FALSE;
// stop here
return;
}
// do not send DIO if I'm in in bridge mode
if (idmanager_getIsBridge()==TRUE) {
return;
}
// do not send DIO if I have the default DAG rank
if (neighbors_getMyDAGrank()==DEFAULTDAGRANK) {
return;
}
// do not send DIO if I'm already busy sending
if (icmpv6rpl_vars.busySending==TRUE) {
return;
}
// if you get here, all good to send a DIO
// I'm now busy sending
icmpv6rpl_vars.busySending = TRUE;
// reserve a free packet buffer for DIO
msg = openqueue_getFreePacketBuffer(COMPONENT_ICMPv6RPL);
if (msg==NULL) {
openserial_printError(COMPONENT_ICMPv6RPL,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
icmpv6rpl_vars.busySending = FALSE;
return;
}
// take ownership
msg->creator = COMPONENT_ICMPv6RPL;
msg->owner = COMPONENT_ICMPv6RPL;
// set transport information
msg->l4_protocol = IANA_ICMPv6;
msg->l4_sourcePortORicmpv6Type = IANA_ICMPv6_RPL;
// set DIO destination
memcpy(&(msg->l3_destinationAdd),&icmpv6rpl_vars.dioDestination,sizeof(open_addr_t));
//===== DIO payload
// note: DIO is already mostly populated
icmpv6rpl_vars.dio.rank = neighbors_getMyDAGrank();
packetfunctions_reserveHeaderSize(msg,sizeof(icmpv6rpl_dio_ht));
memcpy(
((icmpv6rpl_dio_ht*)(msg->payload)),
&(icmpv6rpl_vars.dio),
sizeof(icmpv6rpl_dio_ht)
);
//===== ICMPv6 header
packetfunctions_reserveHeaderSize(msg,sizeof(ICMPv6_ht));
((ICMPv6_ht*)(msg->payload))->type = msg->l4_sourcePortORicmpv6Type;
((ICMPv6_ht*)(msg->payload))->code = IANA_ICMPv6_RPL_DIO;
packetfunctions_calculateChecksum(msg,(uint8_t*)&(((ICMPv6_ht*)(msg->payload))->checksum));//call last
//send
if (icmpv6_send(msg)!=E_SUCCESS) {
icmpv6rpl_vars.busySending = FALSE;
openqueue_freePacketBuffer(msg);
} else {
icmpv6rpl_vars.busySending = FALSE;
}
}
void cexample_task_cb() {
OpenQueueEntry_t* pkt;
owerror_t outcome;
uint8_t numOptions;
uint8_t i;
uint16_t x_int = 0;
uint16_t sum = 0;
uint16_t avg = 0;
uint8_t N_avg = 10;
// don't run if not synch
if (ieee154e_isSynch() == FALSE) return;
// don't run on dagroot
if (idmanager_getIsDAGroot()) {
opentimers_stop(cexample_vars.timerId);
return;
}
for (i = 0; i < N_avg; i++) {
sum += x_int;
}
avg = sum/N_avg;
// create a CoAP RD packet
pkt = openqueue_getFreePacketBuffer(COMPONENT_CEXAMPLE);
if (pkt==NULL) {
openserial_printError(
COMPONENT_CEXAMPLE,
ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0
);
openqueue_freePacketBuffer(pkt);
return;
}
// take ownership over that packet
pkt->creator = COMPONENT_CEXAMPLE;
pkt->owner = COMPONENT_CEXAMPLE;
// CoAP payload
packetfunctions_reserveHeaderSize(pkt,PAYLOADLEN);
for (i=0;i<PAYLOADLEN;i++) {
pkt->payload[i] = i;
}
avg = openrandom_get16b();
pkt->payload[0] = (avg>>8)&0xff;
pkt->payload[1] = (avg>>0)&0xff;
numOptions = 0;
// location-path option
packetfunctions_reserveHeaderSize(pkt,sizeof(cexample_path0)-1);
memcpy(&pkt->payload[0],&cexample_path0,sizeof(cexample_path0)-1);
packetfunctions_reserveHeaderSize(pkt,1);
pkt->payload[0] = ((COAP_OPTION_NUM_URIPATH) << 4) | (sizeof(cexample_path0)-1);
numOptions++;
// content-type option
packetfunctions_reserveHeaderSize(pkt,2);
pkt->payload[0] = (COAP_OPTION_NUM_CONTENTFORMAT << 4) | 1;
pkt->payload[1] = COAP_MEDTYPE_APPOCTETSTREAM;
numOptions++;
// metadata
pkt->l4_destination_port = WKP_UDP_COAP;
pkt->l3_destinationAdd.type = ADDR_128B;
memcpy(&pkt->l3_destinationAdd.addr_128b[0],&ipAddr_motesEecs,16);
// send
outcome = opencoap_send(
pkt,
COAP_TYPE_NON,
COAP_CODE_REQ_PUT,
numOptions,
&cexample_vars.desc
);
// avoid overflowing the queue if fails
if (outcome==E_FAIL) {
openqueue_freePacketBuffer(pkt);
}
return;
}
/**
\brief Prepare and a send a RPL DAO.
*/
void sendDAO() {
OpenQueueEntry_t* msg; // pointer to DAO messages
uint8_t nbrIdx; // running neighbor index
uint8_t numTransitParents,numTargetParents; // the number of parents indicated in transit option
open_addr_t address;
open_addr_t* prefix;
if (ieee154e_isSynch()==FALSE) {
// I'm not sync'ed
// delete packets genereted by this module (DIO and DAO) from openqueue
openqueue_removeAllCreatedBy(COMPONENT_ICMPv6RPL);
// I'm not busy sending a DIO/DAO
icmpv6rpl_vars.busySending = FALSE;
// stop here
return;
}
// dont' send a DAO if you're in bridge mode
if (idmanager_getIsBridge()==TRUE) {
return;
}
// dont' send a DAO if you did not acquire a DAGrank
if (neighbors_getMyDAGrank()==DEFAULTDAGRANK) {
return;
}
// dont' send a DAO if you're still busy sending the previous one
if (icmpv6rpl_vars.busySending==TRUE) {
return;
}
// if you get here, you start construct DAO
// reserve a free packet buffer for DAO
msg = openqueue_getFreePacketBuffer(COMPONENT_ICMPv6RPL);
if (msg==NULL) {
openserial_printError(COMPONENT_ICMPv6RPL,ERR_NO_FREE_PACKET_BUFFER,
(errorparameter_t)0,
(errorparameter_t)0);
return;
}
// take ownership
msg->creator = COMPONENT_ICMPv6RPL;
msg->owner = COMPONENT_ICMPv6RPL;
// set transport information
msg->l4_protocol = IANA_ICMPv6;
msg->l4_sourcePortORicmpv6Type = IANA_ICMPv6_RPL;
// set DAO destination
msg->l3_destinationAdd.type=ADDR_128B;
memcpy(msg->l3_destinationAdd.addr_128b,icmpv6rpl_vars.dio.DODAGID,sizeof(icmpv6rpl_vars.dio.DODAGID));
//===== fill in packet
//NOTE: limit to preferrred parent only the number of DAO transit addresses to send
//=== transit option -- from RFC 6550, page 55 - 1 transit information header per parent is required.
//getting only preferred parent as transit
numTransitParents=0;
neighbors_getPreferredParentEui64(&address);
packetfunctions_writeAddress(msg,&address,OW_BIG_ENDIAN);
prefix=idmanager_getMyID(ADDR_PREFIX);
packetfunctions_writeAddress(msg,prefix,OW_BIG_ENDIAN);
// update transit info fields
// from rfc6550 p.55 -- Variable, depending on whether or not the DODAG ParentAddress subfield is present.
// poipoi xv: it is not very clear if this includes all fields in the header. or as target info 2 bytes are removed.
// using the same pattern as in target information.
icmpv6rpl_vars.dao_transit.optionLength = LENGTH_ADDR128b + sizeof(icmpv6rpl_dao_transit_ht)-2;
icmpv6rpl_vars.dao_transit.PathControl=0; //todo. this is to set the preference of this parent.
icmpv6rpl_vars.dao_transit.type=OPTION_TRANSIT_INFORMATION_TYPE;
// write transit info in packet
packetfunctions_reserveHeaderSize(msg,sizeof(icmpv6rpl_dao_transit_ht));
memcpy(
((icmpv6rpl_dao_transit_ht*)(msg->payload)),
&(icmpv6rpl_vars.dao_transit),
sizeof(icmpv6rpl_dao_transit_ht)
);
numTransitParents++;
//target information is required. RFC 6550 page 55.
/*
One or more Transit Information options MUST be preceded by one or
more RPL Target options.
*/
numTargetParents = 0;
for (nbrIdx=0;nbrIdx<MAXNUMNEIGHBORS;nbrIdx++) {
if ((neighbors_isNeighborWithHigherDAGrank(nbrIdx))==TRUE) {
// this neighbor is of higher DAGrank as I am. so it is my child
// write it's address in DAO RFC6550 page 80 check point 1.
neighbors_getNeighbor(&address,ADDR_64B,nbrIdx);
packetfunctions_writeAddress(msg,&address,OW_BIG_ENDIAN);
prefix=idmanager_getMyID(ADDR_PREFIX);
packetfunctions_writeAddress(msg,prefix,OW_BIG_ENDIAN);
// update target info fields
// from rfc6550 p.55 -- Variable, length of the option in octets excluding the Type and Length fields.
// poipoi xv: assuming that type and length fields refer to the 2 first bytes of the header
icmpv6rpl_vars.dao_target.optionLength = LENGTH_ADDR128b +sizeof(icmpv6rpl_dao_target_ht) - 2; //no header type and length
icmpv6rpl_vars.dao_target.type = OPTION_TARGET_INFORMATION_TYPE;
icmpv6rpl_vars.dao_target.flags = 0; //must be 0
icmpv6rpl_vars.dao_target.prefixLength = 128; //128 leading bits -- full address.
// write transit info in packet
packetfunctions_reserveHeaderSize(msg,sizeof(icmpv6rpl_dao_target_ht));
memcpy(
((icmpv6rpl_dao_target_ht*)(msg->payload)),
&(icmpv6rpl_vars.dao_target),
sizeof(icmpv6rpl_dao_target_ht)
);
// remember I found it
numTargetParents++;
}
//limit to MAX_TARGET_PARENTS the number of DAO target addresses to send
//section 8.2.1 pag 67 RFC6550 -- using a subset
// poipoi TODO base selection on ETX rather than first X.
if (numTargetParents>=MAX_TARGET_PARENTS) break;
}
// stop here if no parents found
if (numTransitParents==0) {
openqueue_freePacketBuffer(msg);
return;
}
icmpv6rpl_vars.dao_transit.PathSequence++; //increment path sequence.
// if you get here, you will send a DAO
//=== DAO header
packetfunctions_reserveHeaderSize(msg,sizeof(icmpv6rpl_dao_ht));
memcpy(
((icmpv6rpl_dao_ht*)(msg->payload)),
&(icmpv6rpl_vars.dao),
sizeof(icmpv6rpl_dao_ht)
);
//=== ICMPv6 header
packetfunctions_reserveHeaderSize(msg,sizeof(ICMPv6_ht));
((ICMPv6_ht*)(msg->payload))->type = msg->l4_sourcePortORicmpv6Type;
((ICMPv6_ht*)(msg->payload))->code = IANA_ICMPv6_RPL_DAO;
packetfunctions_calculateChecksum(msg,(uint8_t*)&(((ICMPv6_ht*)(msg->payload))->checksum)); //call last
//===== send
if (icmpv6_send(msg)==E_SUCCESS) {
icmpv6rpl_vars.busySending = TRUE;
} else {
openqueue_freePacketBuffer(msg);
}
}
void stupidmac_sendDone(OpenQueueEntry_t* pkt, error_t error) {
openqueue_freePacketBuffer(pkt);
//scheduler_push_task(ID_TASK_APPLICATION); // ask the scheduler to do run task_application again
}
