otError AnnounceBeginClient::SendRequest(uint32_t aChannelMask, uint8_t aCount, uint16_t aPeriod,
const Ip6::Address &aAddress)
{
otError error = OT_ERROR_NONE;
Coap::Header header;
MeshCoP::CommissionerSessionIdTlv sessionId;
MeshCoP::ChannelMask0Tlv channelMask;
MeshCoP::CountTlv count;
MeshCoP::PeriodTlv period;
Ip6::MessageInfo messageInfo;
Message *message = NULL;
VerifyOrExit(GetNetif().GetCommissioner().IsActive(), error = OT_ERROR_INVALID_STATE);
header.Init(aAddress.IsMulticast() ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE,
OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_ANNOUNCE_BEGIN);
header.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(GetNetif().GetCoap(), header)) != NULL,
error = OT_ERROR_NO_BUFS);
sessionId.Init();
sessionId.SetCommissionerSessionId(GetNetif().GetCommissioner().GetSessionId());
SuccessOrExit(error = message->Append(&sessionId, sizeof(sessionId)));
channelMask.Init();
channelMask.SetMask(aChannelMask);
SuccessOrExit(error = message->Append(&channelMask, sizeof(channelMask)));
count.Init();
count.SetCount(aCount);
SuccessOrExit(error = message->Append(&count, sizeof(count)));
period.Init();
period.SetPeriod(aPeriod);
SuccessOrExit(error = message->Append(&period, sizeof(period)));
messageInfo.SetSockAddr(GetNetif().GetMle().GetMeshLocal16());
messageInfo.SetPeerAddr(aAddress);
messageInfo.SetPeerPort(kCoapUdpPort);
messageInfo.SetInterfaceId(GetNetif().GetInterfaceId());
SuccessOrExit(error = GetNetif().GetCoap().SendMessage(*message, messageInfo));
otLogInfoMeshCoP(GetInstance(), "sent announce begin query");
exit:
if (error != OT_ERROR_NONE && message != NULL)
{
message->Free();
}
return error;
}
otError PanIdQueryClient::SendQuery(uint16_t aPanId, uint32_t aChannelMask, const Ip6::Address &aAddress,
otCommissionerPanIdConflictCallback aCallback, void *aContext)
{
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header header;
MeshCoP::CommissionerSessionIdTlv sessionId;
MeshCoP::ChannelMask0Tlv channelMask;
MeshCoP::PanIdTlv panId;
Ip6::MessageInfo messageInfo;
Message *message = NULL;
VerifyOrExit(netif.GetCommissioner().IsActive(), error = OT_ERROR_INVALID_STATE);
header.Init(aAddress.IsMulticast() ? OT_COAP_TYPE_NON_CONFIRMABLE : OT_COAP_TYPE_CONFIRMABLE,
OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_PANID_QUERY);
header.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(netif.GetCoap(), header)) != NULL,
error = OT_ERROR_NO_BUFS);
sessionId.Init();
sessionId.SetCommissionerSessionId(netif.GetCommissioner().GetSessionId());
SuccessOrExit(error = message->Append(&sessionId, sizeof(sessionId)));
channelMask.Init();
channelMask.SetMask(aChannelMask);
SuccessOrExit(error = message->Append(&channelMask, sizeof(channelMask)));
panId.Init();
panId.SetPanId(aPanId);
SuccessOrExit(error = message->Append(&panId, sizeof(panId)));
messageInfo.SetSockAddr(netif.GetMle().GetMeshLocal16());
messageInfo.SetPeerAddr(aAddress);
messageInfo.SetPeerPort(kCoapUdpPort);
messageInfo.SetInterfaceId(netif.GetInterfaceId());
SuccessOrExit(error = netif.GetCoap().SendMessage(*message, messageInfo));
otLogInfoMeshCoP(GetInstance(), "sent panid query");
mCallback = aCallback;
mContext = aContext;
exit:
if (error != OT_ERROR_NONE && message != NULL)
{
message->Free();
}
return error;
}
otError Dataset::AppendMleDatasetTlv(Message &aMessage) const
{
otError error = OT_ERROR_NONE;
Mle::Tlv tlv;
Mle::Tlv::Type type;
const Tlv * cur = reinterpret_cast<const Tlv *>(mTlvs);
const Tlv * end = reinterpret_cast<const Tlv *>(mTlvs + mLength);
VerifyOrExit(mLength > 0);
type = (mType == Tlv::kActiveTimestamp ? Mle::Tlv::kActiveDataset : Mle::Tlv::kPendingDataset);
tlv.SetType(type);
tlv.SetLength(static_cast<uint8_t>(mLength) - sizeof(Tlv) - sizeof(Timestamp));
SuccessOrExit(error = aMessage.Append(&tlv, sizeof(Tlv)));
while (cur < end)
{
if (cur->GetType() == mType)
{
; // skip Active or Pending Timestamp TLV
}
else if (cur->GetType() == Tlv::kDelayTimer)
{
uint32_t elapsed = TimerMilli::GetNow() - mUpdateTime;
DelayTimerTlv delayTimer(static_cast<const DelayTimerTlv &>(*cur));
if (delayTimer.GetDelayTimer() > elapsed)
{
delayTimer.SetDelayTimer(delayTimer.GetDelayTimer() - elapsed);
}
else
{
delayTimer.SetDelayTimer(0);
}
SuccessOrExit(error = aMessage.Append(&delayTimer, sizeof(delayTimer)));
}
else
{
SuccessOrExit(error = aMessage.Append(cur, sizeof(Tlv) + cur->GetLength()));
}
cur = cur->GetNext();
}
exit:
return error;
}
void ChildSupervisor::SendMessage(Child &aChild)
{
ThreadNetif &netif = GetNetif();
Message *message = NULL;
otError error = OT_ERROR_NONE;
uint8_t childIndex;
VerifyOrExit(aChild.GetIndirectMessageCount() == 0);
message = netif.GetInstance().mMessagePool.New(Message::kTypeSupervision, sizeof(uint8_t));
VerifyOrExit(message != NULL);
// Supervision message is an empty payload 15.4 data frame.
// The child index is stored here in the message content to allow
// the destination of the message to be later retrieved using
// `ChildSupervisor::GetDestination(message)`.
childIndex = netif.GetMle().GetChildIndex(aChild);
SuccessOrExit(error = message->Append(&childIndex, sizeof(childIndex)));
SuccessOrExit(error = netif.SendMessage(*message));
message = NULL;
otLogInfoMle(GetInstance(), "Sending supervision message to child 0x%04x", aChild.GetRloc16());
exit:
if (message != NULL)
{
message->Free();
}
}
otError Dhcp6Server::AppendRapidCommit(Message &aMessage)
{
RapidCommit option;
option.Init();
return aMessage.Append(&option, sizeof(option));
}
otError Dhcp6Server::AppendIaNa(Message &aMessage, IaNa &aIaNa)
{
otError error = OT_ERROR_NONE;
uint16_t length = 0;
if (mPrefixAgentsMask)
{
for (uint8_t i = 0; i < OPENTHREAD_CONFIG_NUM_DHCP_PREFIXES; i++)
{
if ((mPrefixAgentsMask & (1 << i)))
{
length += sizeof(IaAddress);
}
}
}
else
{
length += sizeof(IaAddress) * mPrefixAgentsCount;
}
length += sizeof(IaNa) + sizeof(StatusCode) - sizeof(Dhcp6Option);
aIaNa.SetLength(length);
aIaNa.SetT1(OT_DHCP6_DEFAULT_IA_NA_T1);
aIaNa.SetT2(OT_DHCP6_DEFAULT_IA_NA_T2);
SuccessOrExit(error = aMessage.Append(&aIaNa, sizeof(IaNa)));
exit:
return error;
}
void ChildSupervisor::SendMessage(Child &aChild)
{
Message *message = NULL;
uint8_t childIndex;
VerifyOrExit(aChild.GetIndirectMessageCount() == 0);
message = Get<MessagePool>().New(Message::kTypeSupervision, sizeof(uint8_t));
VerifyOrExit(message != NULL);
// Supervision message is an empty payload 15.4 data frame.
// The child index is stored here in the message content to allow
// the destination of the message to be later retrieved using
// `ChildSupervisor::GetDestination(message)`.
childIndex = Get<ChildTable>().GetChildIndex(aChild);
SuccessOrExit(message->Append(&childIndex, sizeof(childIndex)));
SuccessOrExit(Get<ThreadNetif>().SendMessage(*message));
message = NULL;
otLogInfoUtil("Sending supervision message to child 0x%04x", aChild.GetRloc16());
exit:
if (message != NULL)
{
message->Free();
}
}
otError Leader::SendKeepAliveResponse(const Coap::Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState)
{
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
StateTlv state;
Message *message;
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
state.Init();
state.SetState(aState);
SuccessOrExit(error = message->Append(&state, sizeof(state)));
SuccessOrExit(error = netif.GetCoap().SendMessage(*message, aMessageInfo));
otLogInfoMeshCoP(GetInstance(), "sent keep alive response");
exit:
if (error != OT_ERROR_NONE && message != NULL)
{
message->Free();
}
return error;
}
otError Dhcp6Server::AppendStatusCode(Message &aMessage, Status aStatus)
{
StatusCode option;
option.Init();
option.SetStatusCode(aStatus);
return aMessage.Append(&option, sizeof(option));
}
otError Leader::SendPetitionResponse(const Coap::Header &aRequestHeader, const Ip6::MessageInfo &aMessageInfo,
StateTlv::State aState)
{
ThreadNetif &netif = GetNetif();
otError error = OT_ERROR_NONE;
Coap::Header responseHeader;
StateTlv state;
CommissionerSessionIdTlv sessionId;
Message *message;
responseHeader.SetDefaultResponseHeader(aRequestHeader);
responseHeader.SetPayloadMarker();
VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap(), responseHeader)) != NULL, error = OT_ERROR_NO_BUFS);
state.Init();
state.SetState(aState);
SuccessOrExit(error = message->Append(&state, sizeof(state)));
if (mTimer.IsRunning())
{
uint16_t len = sizeof(Tlv) + mCommissionerId.GetLength();
SuccessOrExit(error = message->Append(&mCommissionerId, len));
}
if (aState == StateTlv::kAccept)
{
sessionId.Init();
sessionId.SetCommissionerSessionId(mSessionId);
SuccessOrExit(error = message->Append(&sessionId, sizeof(sessionId)));
}
SuccessOrExit(error = netif.GetCoap().SendMessage(*message, aMessageInfo));
otLogInfoMeshCoP(GetInstance(), "sent petition response");
exit:
if (error != OT_ERROR_NONE && message != NULL)
{
message->Free();
}
return error;
}
ThreadError Local::Register(const Ip6::Address &aDestination)
{
ThreadError error = kThreadError_None;
Coap::Header header;
Message *message;
Ip6::MessageInfo messageInfo;
UpdateRloc();
mSocket.Open(&HandleUdpReceive, this);
for (size_t i = 0; i < sizeof(mCoapToken); i++)
{
mCoapToken[i] = otPlatRandomGet();
}
header.Init();
header.SetVersion(1);
header.SetType(Coap::Header::kTypeConfirmable);
header.SetCode(Coap::Header::kCodePost);
header.SetMessageId(++mCoapMessageId);
header.SetToken(mCoapToken, sizeof(mCoapToken));
header.AppendUriPathOptions(OPENTHREAD_URI_SERVER_DATA);
header.AppendContentFormatOption(Coap::Header::kApplicationOctetStream);
header.Finalize();
VerifyOrExit((message = Ip6::Udp::NewMessage(0)) != NULL, error = kThreadError_NoBufs);
SuccessOrExit(error = message->Append(header.GetBytes(), header.GetLength()));
SuccessOrExit(error = message->Append(mTlvs, mLength));
memset(&messageInfo, 0, sizeof(messageInfo));
memcpy(&messageInfo.mPeerAddr, &aDestination, sizeof(messageInfo.mPeerAddr));
messageInfo.mPeerPort = kCoapUdpPort;
SuccessOrExit(error = mSocket.SendTo(*message, messageInfo));
otLogInfoNetData("Sent network data registration\n");
exit:
if (error != kThreadError_None && message != NULL)
{
Message::Free(*message);
}
return error;
}
otError Dhcp6Server::AppendHeader(Message &aMessage, uint8_t *aTransactionId)
{
Dhcp6Header header;
header.Init();
header.SetType(kTypeReply);
header.SetTransactionId(aTransactionId);
return aMessage.Append(&header, sizeof(header));
}
otError EnergyScanServer::SendReport(void)
{
otError error = OT_ERROR_NONE;
Coap::Header header;
MeshCoP::ChannelMask0Tlv channelMask;
MeshCoP::EnergyListTlv energyList;
Ip6::MessageInfo messageInfo;
Message * message;
header.Init(OT_COAP_TYPE_CONFIRMABLE, OT_COAP_CODE_POST);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(OT_URI_PATH_ENERGY_REPORT);
header.SetPayloadMarker();
VerifyOrExit((message = MeshCoP::NewMeshCoPMessage(GetNetif().GetCoap(), header)) != NULL,
error = OT_ERROR_NO_BUFS);
channelMask.Init();
channelMask.SetMask(mChannelMask);
SuccessOrExit(error = message->Append(&channelMask, sizeof(channelMask)));
energyList.Init();
energyList.SetLength(mScanResultsLength);
SuccessOrExit(error = message->Append(&energyList, sizeof(energyList)));
SuccessOrExit(error = message->Append(mScanResults, mScanResultsLength));
messageInfo.SetSockAddr(GetNetif().GetMle().GetMeshLocal16());
messageInfo.SetPeerAddr(mCommissioner);
messageInfo.SetPeerPort(kCoapUdpPort);
SuccessOrExit(error = GetNetif().GetCoap().SendMessage(*message, messageInfo));
otLogInfoMeshCoP(GetInstance(), "sent scan results");
exit:
if (error != OT_ERROR_NONE && message != NULL)
{
message->Free();
}
mActive = false;
return error;
}
otError Dhcp6Server::AppendServerIdentifier(Message &aMessage)
{
otError error = OT_ERROR_NONE;
ServerIdentifier option;
option.Init();
option.SetDuidType(kDuidLL);
option.SetDuidHardwareType(kHardwareTypeEui64);
option.SetDuidLinkLayerAddress(GetNetif().GetMac().GetExtAddress());
SuccessOrExit(error = aMessage.Append(&option, sizeof(option)));
exit:
return error;
}
otError Dhcp6Server::AddIaAddress(Message &aMessage, otIp6Prefix &aIp6Prefix, ClientIdentifier &aClient)
{
otError error = OT_ERROR_NONE;
IaAddress option;
option.Init();
memcpy((option.GetAddress()->mFields.m8), &(aIp6Prefix.mPrefix), 8);
memcpy(&(option.GetAddress()->mFields.m8[8]), aClient.GetDuidLinkLayerAddress(), sizeof(Mac::ExtAddress));
option.SetPreferredLifetime(OT_DHCP6_DEFAULT_PREFERRED_LIFETIME);
option.SetValidLifetime(OT_DHCP6_DEFAULT_VALID_LIFETIME);
SuccessOrExit(error = aMessage.Append(&option, sizeof(option)));
exit:
return error;
}
void CoapSecure::HandleDtlsReceive(uint8_t *aBuf, uint16_t aLength)
{
Message *message = NULL;
VerifyOrExit((message = GetInstance().GetMessagePool().New(Message::kTypeIp6, 0)) != NULL);
SuccessOrExit(message->Append(aBuf, aLength));
CoapBase::Receive(*message, mPeerAddress);
exit:
if (message != NULL)
{
message->Free();
}
}
ThreadError DatasetManager::Register(void)
{
ThreadError error = kThreadError_None;
Coap::Header header;
Message *message;
Ip6::Address leader;
Ip6::MessageInfo messageInfo;
header.Init(kCoapTypeConfirmable, kCoapRequestPost);
header.SetToken(Coap::Header::kDefaultTokenLength);
header.AppendUriPathOptions(mUriSet);
header.SetPayloadMarker();
if (strcmp(mUriSet, OPENTHREAD_URI_PENDING_SET) == 0)
{
PendingDatasetBase *pending = static_cast<PendingDatasetBase *>(this);
pending->UpdateDelayTimer();
}
VerifyOrExit((message = mNetif.GetCoapClient().NewMeshCoPMessage(header)) != NULL, error = kThreadError_NoBufs);
SuccessOrExit(error = message->Append(mLocal.GetBytes(), mLocal.GetSize()));
mNetif.GetMle().GetLeaderAloc(leader);
messageInfo.SetPeerAddr(leader);
messageInfo.SetPeerPort(kCoapUdpPort);
SuccessOrExit(error = mNetif.GetCoapClient().SendMessage(*message, messageInfo));
otLogInfoMeshCoP("sent dataset to leader");
exit:
if (error != kThreadError_None && message != NULL)
{
message->Free();
}
return error;
}
otError Dhcp6Server::AppendClientIdentifier(Message &aMessage, ClientIdentifier &aClient)
{
return aMessage.Append(&aClient, sizeof(aClient));
}
/**
* This method appends MPL Buffered Message metadata to the message.
*
* @param[in] aMessage A reference to the message.
*
* @retval OT_ERROR_NONE Successfully appended the bytes.
* @retval OT_ERROR_NO_BUFS Insufficient available buffers to grow the message.
*
*/
otError AppendTo(Message &aMessage) const {
return aMessage.Append(this, sizeof(*this));
};
void JoinerRouter::HandleRelayTransmit(Coap::Message &aMessage, const Ip6::MessageInfo &aMessageInfo)
{
OT_UNUSED_VARIABLE(aMessageInfo);
otError error;
JoinerUdpPortTlv joinerPort;
JoinerIidTlv joinerIid;
JoinerRouterKekTlv kek;
uint16_t offset;
uint16_t length;
Message * message = NULL;
otMessageSettings settings = {false, static_cast<otMessagePriority>(kMeshCoPMessagePriority)};
Ip6::MessageInfo messageInfo;
VerifyOrExit(aMessage.GetType() == OT_COAP_TYPE_NON_CONFIRMABLE && aMessage.GetCode() == OT_COAP_CODE_POST,
error = OT_ERROR_DROP);
otLogInfoMeshCoP("Received relay transmit");
SuccessOrExit(error = Tlv::GetTlv(aMessage, Tlv::kJoinerUdpPort, sizeof(joinerPort), joinerPort));
VerifyOrExit(joinerPort.IsValid(), error = OT_ERROR_PARSE);
SuccessOrExit(error = Tlv::GetTlv(aMessage, Tlv::kJoinerIid, sizeof(joinerIid), joinerIid));
VerifyOrExit(joinerIid.IsValid(), error = OT_ERROR_PARSE);
SuccessOrExit(error = Tlv::GetValueOffset(aMessage, Tlv::kJoinerDtlsEncapsulation, offset, length));
VerifyOrExit((message = mSocket.NewMessage(0, &settings)) != NULL, error = OT_ERROR_NO_BUFS);
while (length)
{
uint16_t copyLength = length;
uint8_t tmp[16];
if (copyLength >= sizeof(tmp))
{
copyLength = sizeof(tmp);
}
aMessage.Read(offset, copyLength, tmp);
SuccessOrExit(error = message->Append(tmp, copyLength));
offset += copyLength;
length -= copyLength;
}
aMessage.CopyTo(offset, 0, length, *message);
messageInfo.mPeerAddr.mFields.m16[0] = HostSwap16(0xfe80);
memcpy(messageInfo.mPeerAddr.mFields.m8 + 8, joinerIid.GetIid(), 8);
messageInfo.SetPeerPort(joinerPort.GetUdpPort());
messageInfo.SetInterfaceId(GetNetif().GetInterfaceId());
SuccessOrExit(error = mSocket.SendTo(*message, messageInfo));
if (Tlv::GetTlv(aMessage, Tlv::kJoinerRouterKek, sizeof(kek), kek) == OT_ERROR_NONE)
{
otLogInfoMeshCoP("Received kek");
DelaySendingJoinerEntrust(messageInfo, kek);
}
exit:
if (error != OT_ERROR_NONE && message != NULL)
{
message->Free();
}
}
/**
* Parses a message from a connection
* Sends the parsed message to the correct function in the game world with the conenction id
* Returns a vector of messages to send back out to connections
*/
Message* Parser::Parse(Message* mess) const
{
// Input message
if (mess->GetType() == 2) {
Message* gameMessage = new Message("", mess->GetSource(), Message::MessageType::gameActionMessage);
std::string buffer;
std::stringstream iss(mess->Read());
std::string command;
std::vector<std::string> tokens{ std::istream_iterator<std::string>{iss},
std::istream_iterator<std::string>{} };
command = tokens.front();
tokens.erase(tokens.begin(), tokens.begin() + 1);
#ifdef _DEBUG_FLAG
std::cout << "Command: " << command << std::endl;
#endif
for (std::size_t i = 0; i < command.length(); ++i) {
command.at(i) = std::tolower(command.at(i));
}
if (command != "say" && command != "shout" && command != "whisper" && command != "signup"
&& command != "desc" && command != "description" && command != "tell" && command != "t"
&& command != "password" && command != "login") {
for (std::size_t j = 0; j < tokens.size(); ++j) {
for (std::size_t i = 0; i < tokens.at(j).length(); ++i) {
tokens.at(j).at(i) = std::tolower(tokens.at(j).at(i));
}
#ifdef _DEBUG_FLAG
std::cout << token << std::endl;
#endif
}
}
if (command == "look")
{
//Look around room
}
else if (command == "move")
{
}
else if (command == "say")
{
}
else if (command == "take")
{
}
else if (command == "help")
{
}
else if (command == "signup")
{
}
else if (command == "login")
{
}
else if (command == "logout")
{
}
else {
//Return invalid command
}
//gameMessage->Write("Balls.");
gameMessage->Write(command);
for (std::string token : tokens) {
gameMessage->Append(" " + token);
}
return gameMessage;
}
// Game World Command Message
else if (mess->GetType() == 1) {
return nullptr;
}
// Output message
else if (mess->GetType() == 3) {
return nullptr;
}
return nullptr;
}
/**
* This method appends delayed response header to the message.
*
* @param[in] aMessage A reference to the message.
*
* @retval kThreadError_None Successfully appended the bytes.
* @retval kThreadError_NoBufs Insufficient available buffers to grow the message.
*
*/
ThreadError AppendTo(Message &aMessage) {
return aMessage.Append(this, sizeof(*this));
};