Hugging Face's logo

Datasets:
Beifengdo
/
Arduino-Development

Languages:
Chinese
Tags:
education
arduino
embedded
cplusplus
archive
Dataset card Files
xet
 Community
Arduino-Development / libraries /Temboo /src /utility /CoapMessageLayer.cpp
Beifengdo's picture
Beifengdo
Archive original Arduino development files (part 9)
69c3cbe verified
Raw History Blame Contribute Delete
16.3 kB
/*
###############################################################################
#
# Temboo CoAP Edge Device library
#
# Copyright (C) 2017, Temboo Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
# either express or implied. See the License for the specific
# language governing permissions and limitations under the License.
#
###############################################################################
*/
#include "utility/CoapMessageLayer.h"
CoapMessageLayer::CoapMessageLayer(uint8_t* rxBuffer, uint16_t rxLen, TembooCoAPIPStack& ipStack) :
m_rxBuffer(rxBuffer),
m_rxLen(rxLen),
m_ipStack(ipStack),
m_state(STATE_CLOSED),
m_prevState(STATE_CLOSED),
m_retransmitCount(0),
m_lastResult(NO_ERROR),
m_msgID(0) {
}
CoapMessageLayer::Result CoapMessageLayer::rejectMsg(CoapMsg& msg) {
return rejectMsg(msg, m_ipStack.getRemoteAddress(), m_ipStack.getRemotePort());
}
CoapMessageLayer::Result CoapMessageLayer::rejectMsg(CoapMsg& msg, IPAddress addr, uint16_t port) {
msg.convertToReset();
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("Sending RST");
if (m_ipStack.sendDatagram(addr, port, msg.getMsgBytes(), msg.getMsgLen())) {
m_lastResult = ERROR_SENDING_PACKET;
} else {
m_lastResult = NO_ERROR;
if (STATE_ACK_PENDING == m_state) {
// go back to previous state since the
// message recv'd wasn't what we're expecting
m_state = m_prevState;
}
}
return m_lastResult;
}
CoapMessageLayer::Result CoapMessageLayer::acceptMsg(CoapMsg& msg) {
return acceptMsg(msg, m_ipStack.getRemoteAddress(), m_ipStack.getRemotePort());
}
CoapMessageLayer::Result CoapMessageLayer::acceptMsg(CoapMsg& msg, IPAddress addr, uint16_t port) {
if (m_state != STATE_ACK_PENDING) {
m_lastResult = ERROR_IMPROPER_STATE;
} else {
msg.convertToEmptyAck();
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("Sending ACK");
if (m_ipStack.sendDatagram(addr, port, msg.getMsgBytes(), msg.getMsgLen())) {
m_lastResult = ERROR_SENDING_PACKET;
} else {
m_state = STATE_CLOSED;
m_lastResult = NO_ERROR;
}
}
return m_lastResult;
}
CoapMessageLayer::Result CoapMessageLayer::reliableSend(CoapMsg& msg, IPAddress destAddr, uint16_t destPort) {
if (m_state != STATE_CLOSED) {
m_lastResult = ERROR_IMPROPER_STATE;
return m_lastResult;
}
m_rxByteCount = 0;
m_msgID = msg.getId();
m_msgBytes = msg.getMsgBytes();
m_msgLen = msg.getMsgLen();
m_destAddr = destAddr;
m_destPort = destPort;
msg.setType(CoapMsg::COAP_CONFIRMABLE);
m_retransmitCount = 0;
m_retransmitTimeoutMillis = random(ACK_TIMEOUT, MAX_ACK_TIMEOUT);
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("Sending message");
if (m_ipStack.sendDatagram(m_destAddr, m_destPort, msg.getMsgBytes(), msg.getMsgLen())) {
m_state = STATE_CLOSED;
m_lastResult = ERROR_SENDING_PACKET;
} else {
m_txSpanTimer.start(MAX_TRANSMIT_WAIT);
m_retransmitTimer.start(m_retransmitTimeoutMillis);
m_state = STATE_RELIABLE_TX;
m_lastResult = NO_ERROR;
}
return m_lastResult;
}
CoapMessageLayer::Result CoapMessageLayer::cancelReliableSend() {
if (m_state != STATE_RELIABLE_TX) {
m_lastResult = ERROR_IMPROPER_STATE;
return m_lastResult;
}
m_state = STATE_CLOSED;
m_lastResult = NO_ERROR;
return m_lastResult;
}
CoapMessageLayer::Result CoapMessageLayer::loop() {
m_lastResult = NO_ERROR;
switch(m_state) {
case STATE_RELIABLE_TX:
// We have sent a CON request.
// We're expecting an ACK or a response.
// See if it's time to give up all hope of getting an ACK.
if (m_txSpanTimer.expired()) {
m_lastResult = ERROR_TX_SPAN_TIME_EXCEEDED;
m_state = STATE_CLOSED;
TEMBOO_TRACE("ERROR: ");
TEMBOO_TRACELN("ACK not received within timeout");
break;
}
// See if any messages have come in.
if (m_ipStack.recvDatagram(m_rxBuffer, m_rxLen, m_rxByteCount)) {
m_lastResult = ERROR_RECEIVING_PACKET;
m_state = STATE_CLOSED;
break;
}
// We've received something. See if it's relevant.
if (m_rxByteCount > 0) {
CoapMsg msg(m_rxBuffer, m_rxLen, m_rxByteCount);
// Make sure the message is valid
if (!msg.isValid()) {
rejectMsg(msg);
// We're only interested in messages coming from the host
// we sent the original request to.
} else if (m_ipStack.getRemoteAddress() == m_destAddr) {
switch (msg.getType()) {
case CoapMsg::COAP_ACK:
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("ACK Received");
// Is it ACK'ing the last request we sent?
if (msg.getId() == m_msgID) {
m_state = STATE_CLOSED;
m_lastResult = ACK_RECEIVED;
} else {
// if not, just ignore it.
TEMBOO_TRACE("ERROR: ");
TEMBOO_TRACELN("MID did not match");
}
break;
case CoapMsg::COAP_RESET:
// Is it rejecting the last request we sent?
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("RST Received");
if (msg.getId() == m_msgID) {
m_state = STATE_CLOSED;
m_lastResult = RESET_RECEIVED;
} else {
// if not, just ignore it.
TEMBOO_TRACE("ERROR: ");
TEMBOO_TRACELN("MID did not match");
}
break;
case CoapMsg::COAP_CONFIRMABLE:
// It COULD be the response to our request, or
// just some unexpected message.
// We'll let the upper layers decide.
m_prevState = m_state;
m_state = STATE_ACK_PENDING;
m_lastResult = CON_RECEIVED;
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("CON Received");
break;
case CoapMsg::COAP_NON_CONFIRMABLE:
// It COULD be the response to our request, or
// just some unexpected message.
// We'll let the upper layers decide.
// That's what Kovatsch et al. show in their FSM.
m_state = STATE_CLOSED;
m_lastResult = NON_RECEIVED;
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("NON Received");
break;
}
if (msg.getPayloadLen() > 0) {
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("Payload data:");
uint8_t *payload = msg.getPayload();
uint16_t len = msg.getPayloadLen();
for (uint16_t i = 0; i < len; i++) {
TEMBOO_TRACE((char)payload[i]);
}
TEMBOO_TRACELN();
}
} else if (msg.getType() == CoapMsg::COAP_CONFIRMABLE) {
// It's not from the host we sent the request to, but
// the sending host expects a reply, so explicitly reject it.
rejectMsg(msg);
}
break;
}
// Nothing was received. See if it's time to retransmit.
if (m_retransmitTimer.expired()) {
if (m_retransmitCount >= MAX_RETRANSMIT) {
// We've retried enough. Give up.
TEMBOO_TRACE("ERROR: ");
TEMBOO_TRACELN("Maximum retransmit reached");
m_lastResult = ERROR_RETRANSMIT_COUNT_EXCEEDED;
m_state = STATE_CLOSED;
} else {
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("Retransmit message");
m_retransmitCount++;
m_retransmitTimeoutMillis *= 2;
if (m_ipStack.sendDatagram(m_destAddr, m_destPort, m_msgBytes, m_msgLen)) {
m_state = STATE_CLOSED;
m_lastResult = ERROR_SENDING_PACKET;
} else {
m_retransmitTimer.start(m_retransmitTimeoutMillis);
m_state = STATE_RELIABLE_TX;
m_lastResult = NO_ERROR;
}
}
}
break;
case STATE_ACK_PENDING:
// Nothing to do here but wait for
// the higher layer to accept or reject.
break;
case STATE_WAITING_FOR_CON:
// See if any messages have come in.
if (m_ipStack.recvDatagram(m_rxBuffer, m_rxLen, m_rxByteCount)) {
m_lastResult = ERROR_RECEIVING_PACKET;
m_state = STATE_CLOSED;
break;
}
// We've received something. See if it's relevant.
if (m_rxByteCount > 0) {
CoapMsg msg(m_rxBuffer, m_rxLen, m_rxByteCount);
// Make sure the message is valid
if (!msg.isValid()) {
rejectMsg(msg);
// We're only interested in messages coming from the host
// we sent the original request to.
} else if (m_ipStack.getRemoteAddress() == m_destAddr) {
switch (msg.getType()) {
case CoapMsg::COAP_ACK:
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("ACK Received");
// Is it ACK'ing the last request we sent?
if (msg.getId() == m_msgID) {
m_state = STATE_CLOSED;
m_lastResult = ACK_RECEIVED;
} else {
// if not, just ignore it.
TEMBOO_TRACE("ERROR: ");
TEMBOO_TRACELN("MID did not match");
}
break;
case CoapMsg::COAP_RESET:
// Is it rejecting the last request we sent?
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("RST Received");
if (msg.getId() == m_msgID) {
m_state = STATE_CLOSED;
m_lastResult = RESET_RECEIVED;
} else {
// if not, just ignore it.
TEMBOO_TRACE("ERROR: ");
TEMBOO_TRACELN("MID did not match");
}
break;
case CoapMsg::COAP_CONFIRMABLE:
// It COULD be the response to our request, or
// just some unexpected message.
// We'll let the upper layers decide.
m_prevState = m_state;
m_state = STATE_ACK_PENDING;
m_lastResult = CON_RECEIVED;
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("CON Received");
break;
case CoapMsg::COAP_NON_CONFIRMABLE:
// It COULD be the response to our request, or
// just some unexpected message.
// We'll let the upper layers decide.
// That's what Kovatsch et al. show in their FSM.
m_state = STATE_CLOSED;
m_lastResult = NON_RECEIVED;
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("NON Received");
break;
}
if (msg.getPayloadLen() > 0) {
TEMBOO_TRACE("DBG: ");
TEMBOO_TRACELN("Payload data:");
uint8_t *payload = msg.getPayload();
uint16_t len = msg.getPayloadLen();
for (uint16_t i = 0; i < len; i++) {
TEMBOO_TRACE((char)payload[i]);
}
TEMBOO_TRACELN();
}
} else if (msg.getType() == CoapMsg::COAP_CONFIRMABLE) {
// It's not from the host we sent the request to, but
// the sending host expects a reply, so explicitly reject it.
rejectMsg(msg);
}
break;
}
break;
case STATE_CLOSED:
// We haven't sent anything that we're expecting an answer to.
// We haven't received anything that requires an answer.
// Just pump the receiver.
if (m_ipStack.recvDatagram(m_rxBuffer, m_rxLen, m_rxByteCount)) {
m_lastResult = ERROR_RECEIVING_PACKET;
break;
}
// If we received something, handle it.
if (m_rxByteCount > 0) {
CoapMsg msg(m_rxBuffer, m_rxLen, m_rxByteCount);
switch (msg.getType()) {
case CoapMsg::COAP_ACK:
// Not expecting any ACKS, ignore it.
break;
case CoapMsg::COAP_RESET:
// Haven't sent any CONs and we don't send NONs, ignore it.
break;
case CoapMsg::COAP_CONFIRMABLE:
// Let the higher layers deal with this.
m_prevState = m_state;
m_state = STATE_ACK_PENDING;
m_lastResult = CON_RECEIVED;
break;
case CoapMsg::COAP_NON_CONFIRMABLE:
// Let the higher layers deal with this.
m_lastResult = NON_RECEIVED;
break;
}
}
break;
}
return m_lastResult;
}