diff --git a/include/openthread-types.h b/include/openthread-types.h index 505ff6f00..25d64021b 100644 --- a/include/openthread-types.h +++ b/include/openthread-types.h @@ -125,12 +125,51 @@ typedef enum ThreadError kThreadError_Error = 255, } ThreadError; +#define OT_IP6_IID_SIZE 8 ///< Size of an IPv6 Interface Identifier (bytes) -#define OT_EXT_ADDRESS_SIZE 8 ///< Size of an IEEE 802.15.4 Extended Address (bytes) -#define OT_EXT_PAN_ID_SIZE 8 ///< Size of a Thread PAN ID (bytes) -#define OT_NETWORK_NAME_SIZE 16 ///< Size of the Thread Network Name field (bytes) -#define OT_IP6_ADDRESS_SIZE 16 ///< Size of an IPv6 address (bytes) -#define OT_IP6_IID_SIZE 8 ///< Size of an IPv6 Interface Identifier (bytes) +#define OT_MASTER_KEY_SIZE 16 ///< Size of the Thread Master Key (bytes) + +/** + * This structure represents a Thread Master Key. + * + */ +typedef struct otMasterKey +{ + uint8_t m8[OT_MASTER_KEY_SIZE]; +} otMasterKey; + +#define OT_NETWORK_NAME_SIZE 16 ///< Size of the Thread Network Name field (bytes) + +/** + * This structure represents a Network Name. + * + */ +typedef struct otNetworkName +{ + char m8[OT_NETWORK_NAME_SIZE]; +} otNetworkName; + +#define OT_EXT_PAN_ID_SIZE 8 ///< Size of a Thread PAN ID (bytes) + +/** + * This structure represents an Extended PAN ID. + * + */ +typedef struct otExtendedPanId +{ + uint8_t m8[OT_EXT_PAN_ID_SIZE]; +} otExtendedPanId; + +#define OT_MESH_LOCAL_PREFIX_SIZE 8 ///< Size of the Mesh Local Prefix (bytes) + +/** + * This structure represents a Mesh Local Prefix. + * + */ +typedef struct otMeshLocalPrefix +{ + uint8_t m8[OT_MESH_LOCAL_PREFIX_SIZE]; +} otMeshLocalPrefix; /** * This type represents the IEEE 802.15.4 PAN ID. @@ -144,6 +183,8 @@ typedef uint16_t otPanId; */ typedef uint16_t otShortAddress; +#define OT_EXT_ADDRESS_SIZE 8 ///< Size of an IEEE 802.15.4 Extended Address (bytes) + /** * This type represents the IEEE 802.15.4 Extended Address. * @@ -153,6 +194,21 @@ typedef struct otExtAddress uint8_t m8[OT_EXT_ADDRESS_SIZE]; ///< IEEE 802.15.4 Extended Address bytes } otExtAddress; +#define OT_IP6_ADDRESS_SIZE 16 ///< Size of an IPv6 address (bytes) + +/** + * This structure represents an IPv6 address. + */ +typedef OT_TOOL_PACKED_BEGIN struct otIp6Address +{ + union + { + uint8_t m8[OT_IP6_ADDRESS_SIZE]; ///< 8-bit fields + uint16_t m16[OT_IP6_ADDRESS_SIZE / sizeof(uint16_t)]; ///< 16-bit fields + uint32_t m32[OT_IP6_ADDRESS_SIZE / sizeof(uint32_t)]; ///< 32-bit fields + } mFields; ///< IPv6 accessor fields +} OT_TOOL_PACKED_END otIp6Address; + /** * @addtogroup commands Commands * @@ -224,6 +280,33 @@ typedef struct otActiveScanResult * */ +/** + * This structure represents an Active or Pending Operational Dataset. + * + */ +typedef struct otOperationalDataset +{ + uint64_t mActiveTimestamp; ///< Active Timestamp + uint64_t mPendingTimestamp; ///< Pending Timestamp + otMasterKey mMasterKey; ///< Network Master Key + otNetworkName mNetworkName; ///< Network Name + otExtendedPanId mExtendedPanId; ///< Extended PAN ID + otMeshLocalPrefix mMeshLocalPrefix; ///< Mesh Local Prefix + uint32_t mDelay; ///< Delay Timer + otPanId mPanId; ///< PAN ID + uint8_t mChannel; ///< Channel + + bool mIsActiveTimestampSet : 1; ///< TRUE if Active Timestamp is set, FALSE otherwise. + bool mIsPendingTimestampSet : 1; ///< TRUE if Pending Timestamp is set, FALSE otherwise. + bool mIsMasterKeySet : 1; ///< TRUE if Network Master Key is set, FALSE otherwise. + bool mIsNetworkNameSet : 1; ///< TRUE if Network Name is set, FALSE otherwise. + bool mIsExtendedPanIdSet : 1; ///< TRUE if Extended PAN ID is set, FALSE otherwise. + bool mIsMeshLocalPrefixSet : 1; ///< TRUE if Mesh Local Prefix is set, FALSE otherwise. + bool mIsDelaySet : 1; ///< TRUE if Delay Timer is set, FALSE otherwise. + bool mIsPanIdSet : 1; ///< TRUE if PAN ID is set, FALSE otherwise. + bool mIsChannelSet : 1; ///< TRUE if Channel is set, FALSE otherwise. +} otOperationalDataset; + /** * This structure represents an MLE Link Mode configuration. */ @@ -285,19 +368,6 @@ enum * */ -/** - * This structure represents an IPv6 address. - */ -typedef OT_TOOL_PACKED_BEGIN struct otIp6Address -{ - union - { - uint8_t m8[OT_IP6_ADDRESS_SIZE]; ///< 8-bit fields - uint16_t m16[OT_IP6_ADDRESS_SIZE / sizeof(uint16_t)]; ///< 16-bit fields - uint32_t m32[OT_IP6_ADDRESS_SIZE / sizeof(uint32_t)]; ///< 32-bit fields - } mFields; ///< IPv6 accessor fields -} OT_TOOL_PACKED_END otIp6Address; - /** * This structure represents an IPv6 prefix. */ diff --git a/include/openthread.h b/include/openthread.h index f014d82cf..d1bcc96d6 100644 --- a/include/openthread.h +++ b/include/openthread.h @@ -584,6 +584,52 @@ typedef void (*otStateChangedCallback)(uint32_t aFlags, void *aContext); */ void otSetStateChangedCallback(otStateChangedCallback aCallback, void *aContext); +/** + * This function gets the Active Operational Dataset. + * + * @param[out] aDataset A pointer to where the Active Operational Dataset will be placed. + * + * @retval kThreadError_None Successfully retrieved the Active Operational Dataset. + * @retval kThreadError_InvalidArgs @p aDataset was NULL. + * + */ +ThreadError otGetActiveDataset(otOperationalDataset *aDataset); + +/** + * This function sets the Active Operational Dataset. + * + * @param[in] aDataset A pointer to the Active Operational Dataset. + * + * @retval kThreadError_None Successfully set the Active Operational Dataset. + * @retval kThreadError_NoBufs Insufficient buffer space to set the Active Operational Datset. + * @retval kThreadError_InvalidArgs @p aDataset was NULL. + * + */ +ThreadError otSetActiveDataset(otOperationalDataset *aDataset); + +/** + * This function gets the Pending Operational Dataset. + * + * @param[out] aDataset A pointer to where the Pending Operational Dataset will be placed. + * + * @retval kThreadError_None Successfully retrieved the Pending Operational Dataset. + * @retval kThreadError_InvalidArgs @p aDataset was NULL. + * + */ +ThreadError otGetPendingDataset(otOperationalDataset *aDataset); + +/** + * This function sets the Pending Operational Dataset. + * + * @param[in] aDataset A pointer to the Pending Operational Dataset. + * + * @retval kThreadError_None Successfully set the Pending Operational Dataset. + * @retval kThreadError_NoBufs Insufficient buffer space to set the Pending Operational Datset. + * @retval kThreadError_InvalidArgs @p aDataset was NULL. + * + */ +ThreadError otSetPendingDataset(otOperationalDataset *aDataset); + /** * @} */ diff --git a/src/cli/cli_dataset.cpp b/src/cli/cli_dataset.cpp index a6dc0771b..1bbf3225b 100644 --- a/src/cli/cli_dataset.cpp +++ b/src/cli/cli_dataset.cpp @@ -40,17 +40,8 @@ #include "cli.hpp" #include "cli_dataset.hpp" -#include -#include -#include - -using Thread::Encoding::BigEndian::HostSwap16; -using Thread::Encoding::BigEndian::HostSwap32; namespace Thread { - -extern ThreadNetif *sThreadNetif; - namespace Cli { const DatasetCommand Dataset::sCommands[] = @@ -68,11 +59,11 @@ const DatasetCommand Dataset::sCommands[] = { "networkname", &ProcessNetworkName }, { "panid", &ProcessPanId }, { "pending", &ProcessPending }, - { "timestamp", &ProcessTimestamp }, + { "pendingtimestamp", &ProcessPendingTimestamp }, }; Server *Dataset::sServer; -MeshCoP::Dataset sDataset; +otOperationalDataset Dataset::sDataset; void Dataset::OutputBytes(const uint8_t *aBytes, uint8_t aLength) { @@ -82,42 +73,38 @@ void Dataset::OutputBytes(const uint8_t *aBytes, uint8_t aLength) } } -ThreadError Dataset::Print(MeshCoP::Dataset &aDataset) +ThreadError Dataset::Print(otOperationalDataset &aDataset) { - MeshCoP::Tlv *tlv; - - sServer->OutputFormat("Timestamp: %d\r\n", aDataset.GetTimestamp().GetSeconds()); - - if ((tlv = aDataset.Get(MeshCoP::Tlv::kActiveTimestamp)) != NULL) + if (aDataset.mIsPendingTimestampSet) { - MeshCoP::ActiveTimestampTlv *tmp = static_cast(tlv); - sServer->OutputFormat("Active Timestamp: %d\r\n", tmp->GetSeconds()); + sServer->OutputFormat("Pending Timestamp: %d\r\n", aDataset.mPendingTimestamp); } - if ((tlv = aDataset.Get(MeshCoP::Tlv::kChannel)) != NULL) + if (aDataset.mIsActiveTimestampSet) { - MeshCoP::ChannelTlv *tmp = static_cast(tlv); - sServer->OutputFormat("Channel: %d\r\n", tmp->GetChannel()); + sServer->OutputFormat("Active Timestamp: %d\r\n", aDataset.mActiveTimestamp); } - if ((tlv = aDataset.Get(MeshCoP::Tlv::kDelayTimer)) != NULL) + if (aDataset.mIsChannelSet) { - MeshCoP::DelayTimerTlv *tmp = static_cast(tlv); - sServer->OutputFormat("Delay: %d\r\n", tmp->GetDelayTimer()); + sServer->OutputFormat("Channel: %d\r\n", aDataset.mChannel); } - if ((tlv = aDataset.Get(MeshCoP::Tlv::kExtendedPanId)) != NULL) + if (aDataset.mIsDelaySet) + { + sServer->OutputFormat("Delay: %d\r\n", aDataset.mDelay); + } + + if (aDataset.mIsExtendedPanIdSet) { - MeshCoP::ExtendedPanIdTlv *tmp = static_cast(tlv); sServer->OutputFormat("Ext PAN ID: "); - OutputBytes(tmp->GetExtendedPanId(), OT_EXT_PAN_ID_SIZE); + OutputBytes(aDataset.mExtendedPanId.m8, sizeof(aDataset.mExtendedPanId)); sServer->OutputFormat("\r\n"); } - if ((tlv = aDataset.Get(MeshCoP::Tlv::kMeshLocalPrefix)) != NULL) + if (aDataset.mIsMeshLocalPrefixSet) { - MeshCoP::MeshLocalPrefixTlv *tmp = static_cast(tlv); - const uint8_t *prefix = tmp->GetMeshLocalPrefix(); + const uint8_t *prefix = aDataset.mMeshLocalPrefix.m8; sServer->OutputFormat("Mesh Local Prefix: %x:%x:%x:%x/64\r\n", (static_cast(prefix[0]) << 16) | prefix[1], (static_cast(prefix[2]) << 16) | prefix[3], @@ -125,25 +112,22 @@ ThreadError Dataset::Print(MeshCoP::Dataset &aDataset) (static_cast(prefix[6]) << 16) | prefix[7]); } - if ((tlv = aDataset.Get(MeshCoP::Tlv::kNetworkMasterKey)) != NULL) + if (aDataset.mIsMasterKeySet) { - MeshCoP::NetworkMasterKeyTlv *tmp = static_cast(tlv); sServer->OutputFormat("Master Key: "); - OutputBytes(tmp->GetNetworkMasterKey(), tmp->GetLength()); + OutputBytes(aDataset.mMasterKey.m8, sizeof(aDataset.mMasterKey)); sServer->OutputFormat("\r\n"); } - if ((tlv = aDataset.Get(MeshCoP::Tlv::kNetworkName)) != NULL) + if (aDataset.mIsNetworkNameSet) { - MeshCoP::NetworkNameTlv *tmp = static_cast(tlv); sServer->OutputFormat("Network Name: "); - sServer->OutputFormat("%.*s\r\n", OT_NETWORK_NAME_SIZE, tmp->GetNetworkName()); + sServer->OutputFormat("%.*s\r\n", sizeof(aDataset.mNetworkName), aDataset.mNetworkName.m8); } - if ((tlv = aDataset.Get(MeshCoP::Tlv::kPanId)) != NULL) + if (aDataset.mIsPanIdSet) { - MeshCoP::PanIdTlv *tmp = static_cast(tlv); - sServer->OutputFormat("PAN ID: 0x%04x\r\n", tmp->GetPanId()); + sServer->OutputFormat("PAN ID: 0x%04x\r\n", aDataset.mPanId); } return kThreadError_None; @@ -187,25 +171,24 @@ ThreadError Dataset::ProcessHelp(int argc, char *argv[]) ThreadError Dataset::ProcessActive(int argc, char *argv[]) { + otOperationalDataset dataset; + otGetActiveDataset(&dataset); + (void)argc; (void)argv; - return Print(sThreadNetif->GetActiveDataset().GetLocal()); + return Print(dataset); } ThreadError Dataset::ProcessActiveTimestamp(int argc, char *argv[]) { ThreadError error = kThreadError_None; - MeshCoP::ActiveTimestampTlv tlv; long value; VerifyOrExit(argc > 0, ;); SuccessOrExit(error = Interpreter::ParseLong(argv[0], value)); - tlv.Init(); - tlv.SetSeconds(value); - tlv.SetTicks(0); - tlv.SetAuthoritative(false); - error = sDataset.Set(tlv); + sDataset.mActiveTimestamp = value; + sDataset.mIsActiveTimestampSet = true; exit: return error; @@ -214,15 +197,12 @@ exit: ThreadError Dataset::ProcessChannel(int argc, char *argv[]) { ThreadError error = kThreadError_None; - MeshCoP::ChannelTlv tlv; long value; VerifyOrExit(argc > 0, error = kThreadError_Parse); SuccessOrExit(error = Interpreter::ParseLong(argv[0], value)); - tlv.Init(); - tlv.SetChannelPage(0); - tlv.SetChannel(value); - error = sDataset.Set(tlv); + sDataset.mChannel = value; + sDataset.mIsChannelSet = true; exit: return error; @@ -230,7 +210,7 @@ exit: ThreadError Dataset::ProcessClear(int argc, char *argv[]) { - sDataset.Clear(); + memset(&sDataset, 0, sizeof(sDataset)); (void)argc; (void)argv; return kThreadError_None; @@ -244,20 +224,17 @@ ThreadError Dataset::ProcessCommit(int argc, char *argv[]) if (strcmp(argv[0], "active") == 0) { - sThreadNetif->GetActiveDataset().Set(sDataset); + SuccessOrExit(error = otSetActiveDataset(&sDataset)); } else if (strcmp(argv[0], "pending") == 0) { - sThreadNetif->GetPendingDataset().Set(sDataset); + SuccessOrExit(error = otSetPendingDataset(&sDataset)); } else { ExitNow(error = kThreadError_Parse); } - sThreadNetif->GetNetworkDataLeader().IncrementVersion(); - sThreadNetif->GetNetworkDataLeader().IncrementStableVersion(); - exit: return error; } @@ -265,14 +242,12 @@ exit: ThreadError Dataset::ProcessDelay(int argc, char *argv[]) { ThreadError error = kThreadError_None; - MeshCoP::DelayTimerTlv tlv; long value; VerifyOrExit(argc > 0, error = kThreadError_Parse); SuccessOrExit(error = Interpreter::ParseLong(argv[0], value)); - tlv.Init(); - tlv.SetDelayTimer(value); - error = sDataset.Set(tlv); + sDataset.mDelay = value; + sDataset.mIsDelaySet = true; exit: return error; @@ -281,15 +256,13 @@ exit: ThreadError Dataset::ProcessExtPanId(int argc, char *argv[]) { ThreadError error = kThreadError_None; - MeshCoP::ExtendedPanIdTlv tlv; - uint8_t extPanId[8]; + uint8_t extPanId[OT_EXT_PAN_ID_SIZE]; VerifyOrExit(argc > 0, error = kThreadError_Parse); VerifyOrExit(Interpreter::Hex2Bin(argv[0], extPanId, sizeof(extPanId)) >= 0, error = kThreadError_Parse); - tlv.Init(); - tlv.SetExtendedPanId(extPanId); - error = sDataset.Set(tlv); + memcpy(sDataset.mExtendedPanId.m8, extPanId, sizeof(sDataset.mExtendedPanId)); + sDataset.mIsExtendedPanIdSet = true; exit: return error; @@ -298,15 +271,15 @@ exit: ThreadError Dataset::ProcessMasterKey(int argc, char *argv[]) { ThreadError error = kThreadError_None; - MeshCoP::NetworkMasterKeyTlv tlv; int8_t keyLength; - uint8_t key[16]; + uint8_t key[OT_MASTER_KEY_SIZE]; VerifyOrExit(argc > 0, error = kThreadError_Parse); - VerifyOrExit((keyLength = Interpreter::Hex2Bin(argv[0], key, sizeof(key))) == 16, error = kThreadError_Parse); - tlv.Init(); - tlv.SetNetworkMasterKey(key); - error = sDataset.Set(tlv); + VerifyOrExit((keyLength = Interpreter::Hex2Bin(argv[0], key, sizeof(key))) == OT_MASTER_KEY_SIZE, + error = kThreadError_Parse); + + memcpy(sDataset.mMasterKey.m8, key, sizeof(sDataset.mMasterKey)); + sDataset.mIsMasterKeySet = true; exit: return error; @@ -315,14 +288,13 @@ exit: ThreadError Dataset::ProcessMeshLocalPrefix(int argc, char *argv[]) { ThreadError error = kThreadError_None; - MeshCoP::MeshLocalPrefixTlv tlv; - struct otIp6Address prefix; + otIp6Address prefix; VerifyOrExit(argc > 0, error = kThreadError_Parse); SuccessOrExit(error = otIp6AddressFromString(argv[0], &prefix)); - tlv.Init(); - tlv.SetMeshLocalPrefix(prefix.mFields.m8); - error = sDataset.Set(tlv); + + memcpy(sDataset.mMeshLocalPrefix.m8, prefix.mFields.m8, sizeof(sDataset.mMeshLocalPrefix.m8)); + sDataset.mIsMeshLocalPrefixSet = true; exit: return error; @@ -331,12 +303,14 @@ exit: ThreadError Dataset::ProcessNetworkName(int argc, char *argv[]) { ThreadError error = kThreadError_None; - MeshCoP::NetworkNameTlv tlv; + int length; VerifyOrExit(argc > 0, error = kThreadError_Parse); - tlv.Init(); - tlv.SetNetworkName(argv[0]); - error = sDataset.Set(tlv); + VerifyOrExit((length = strlen(argv[0])) <= OT_NETWORK_NAME_SIZE, error = kThreadError_Parse); + + memset(&sDataset.mNetworkName, 0, sizeof(sDataset.mNetworkName)); + memcpy(sDataset.mNetworkName.m8, argv[0], length); + sDataset.mIsNetworkNameSet = true; exit: return error; @@ -345,14 +319,12 @@ exit: ThreadError Dataset::ProcessPanId(int argc, char *argv[]) { ThreadError error = kThreadError_None; - MeshCoP::PanIdTlv tlv; long value; VerifyOrExit(argc > 0, error = kThreadError_Parse); SuccessOrExit(error = Interpreter::ParseLong(argv[0], value)); - tlv.Init(); - tlv.SetPanId(value); - error = sDataset.Set(tlv); + sDataset.mPanId = value; + sDataset.mIsPanIdSet = true; exit: return error; @@ -360,23 +332,24 @@ exit: ThreadError Dataset::ProcessPending(int argc, char *argv[]) { + otOperationalDataset dataset; + otGetPendingDataset(&dataset); + (void)argc; (void)argv; - return Print(sThreadNetif->GetPendingDataset().GetLocal()); + return Print(dataset); } -ThreadError Dataset::ProcessTimestamp(int argc, char *argv[]) +ThreadError Dataset::ProcessPendingTimestamp(int argc, char *argv[]) { ThreadError error = kThreadError_None; - MeshCoP::Timestamp timestamp; long value; VerifyOrExit(argc > 0, error = kThreadError_Parse); SuccessOrExit(error = Interpreter::ParseLong(argv[0], value)); - timestamp.Init(); - timestamp.SetSeconds(value); - sDataset.SetTimestamp(timestamp); + sDataset.mPendingTimestamp = value; + sDataset.mIsPendingTimestampSet = true; exit: return error; diff --git a/src/cli/cli_dataset.hpp b/src/cli/cli_dataset.hpp index 790ce4aea..daeb5d994 100644 --- a/src/cli/cli_dataset.hpp +++ b/src/cli/cli_dataset.hpp @@ -70,7 +70,7 @@ public: private: static void OutputBytes(const uint8_t *aBytes, uint8_t aLength); - static ThreadError Print(MeshCoP::Dataset &aDataset); + static ThreadError Print(otOperationalDataset &aDataset); static ThreadError ProcessHelp(int argc, char *argv[]); static ThreadError ProcessActive(int argc, char *argv[]); @@ -85,9 +85,10 @@ private: static ThreadError ProcessNetworkName(int argc, char *argv[]); static ThreadError ProcessPanId(int argc, char *argv[]); static ThreadError ProcessPending(int argc, char *argv[]); - static ThreadError ProcessTimestamp(int argc, char *argv[]); + static ThreadError ProcessPendingTimestamp(int argc, char *argv[]); static const DatasetCommand sCommands[]; + static otOperationalDataset sDataset; static Server *sServer; }; diff --git a/src/core/openthread.cpp b/src/core/openthread.cpp index cb2020e5b..1af9b36d4 100644 --- a/src/core/openthread.cpp +++ b/src/core/openthread.cpp @@ -925,6 +925,54 @@ void otSetIcmpEchoEnabled(bool aEnabled) Ip6::Icmp::SetEchoEnabled(aEnabled); } +ThreadError otGetActiveDataset(otOperationalDataset *aDataset) +{ + ThreadError error = kThreadError_None; + + VerifyOrExit(aDataset != NULL, error = kThreadError_InvalidArgs); + + sThreadNetif->GetActiveDataset().Get(*aDataset); + +exit: + return error; +} + +ThreadError otSetActiveDataset(otOperationalDataset *aDataset) +{ + ThreadError error; + + VerifyOrExit(aDataset != NULL, error = kThreadError_InvalidArgs); + + error = sThreadNetif->GetActiveDataset().Set(*aDataset); + +exit: + return error; +} + +ThreadError otGetPendingDataset(otOperationalDataset *aDataset) +{ + ThreadError error = kThreadError_None; + + VerifyOrExit(aDataset != NULL, error = kThreadError_InvalidArgs); + + sThreadNetif->GetPendingDataset().Get(*aDataset); + +exit: + return error; +} + +ThreadError otSetPendingDataset(otOperationalDataset *aDataset) +{ + ThreadError error; + + VerifyOrExit(aDataset != NULL, error = kThreadError_InvalidArgs); + + error = sThreadNetif->GetPendingDataset().Set(*aDataset); + +exit: + return error; +} + #ifdef __cplusplus } // extern "C" #endif diff --git a/src/core/thread/meshcop_dataset.cpp b/src/core/thread/meshcop_dataset.cpp index 6c75f07e3..25ec40359 100644 --- a/src/core/thread/meshcop_dataset.cpp +++ b/src/core/thread/meshcop_dataset.cpp @@ -93,6 +93,187 @@ exit: return rval; } +void Dataset::Get(otOperationalDataset &aDataset) +{ + const Tlv *cur = reinterpret_cast(mTlvs); + const Tlv *end = reinterpret_cast(mTlvs + mLength); + + memset(&aDataset, 0, sizeof(aDataset)); + + while (cur < end) + { + switch (cur->GetType()) + { + + case Tlv::kActiveTimestamp: + { + const ActiveTimestampTlv *tlv = static_cast(cur); + aDataset.mActiveTimestamp = tlv->GetSeconds(); + aDataset.mIsActiveTimestampSet = true; + break; + } + + case Tlv::kChannel: + { + const ChannelTlv *tlv = static_cast(cur); + aDataset.mChannel = tlv->GetChannel(); + aDataset.mIsChannelSet = true; + break; + } + + case Tlv::kDelayTimer: + { + const DelayTimerTlv *tlv = static_cast(cur); + aDataset.mDelay = tlv->GetDelayTimer(); + aDataset.mIsDelaySet = true; + break; + } + + case Tlv::kExtendedPanId: + { + const ExtendedPanIdTlv *tlv = static_cast(cur); + memcpy(aDataset.mExtendedPanId.m8, tlv->GetExtendedPanId(), sizeof(aDataset.mExtendedPanId)); + aDataset.mIsExtendedPanIdSet = true; + break; + } + + case Tlv::kMeshLocalPrefix: + { + const MeshLocalPrefixTlv *tlv = static_cast(cur); + memcpy(aDataset.mMeshLocalPrefix.m8, tlv->GetMeshLocalPrefix(), sizeof(aDataset.mMeshLocalPrefix)); + aDataset.mIsMeshLocalPrefixSet = true; + break; + } + + case Tlv::kNetworkMasterKey: + { + const NetworkMasterKeyTlv *tlv = static_cast(cur); + memcpy(aDataset.mMasterKey.m8, tlv->GetNetworkMasterKey(), sizeof(aDataset.mMasterKey)); + aDataset.mIsMasterKeySet = true; + break; + } + + case Tlv::kNetworkName: + { + const NetworkNameTlv *tlv = static_cast(cur); + memcpy(aDataset.mMasterKey.m8, tlv->GetNetworkName(), tlv->GetLength()); + aDataset.mIsMasterKeySet = true; + break; + } + + case Tlv::kPanId: + { + const PanIdTlv *panid = static_cast(cur); + aDataset.mPanId = panid->GetPanId(); + aDataset.mIsPanIdSet = true; + break; + } + + case Tlv::kPendingTimestamp: + { + const PendingTimestampTlv *tlv = static_cast(cur); + aDataset.mPendingTimestamp = tlv->GetSeconds(); + aDataset.mIsPendingTimestampSet = true; + break; + } + + default: + { + break; + } + } + + cur = cur->GetNext(); + } +} + +ThreadError Dataset::Set(const otOperationalDataset &aDataset, bool aActive) +{ + ThreadError error = kThreadError_None; + + VerifyOrExit(aDataset.mIsActiveTimestampSet, error = kThreadError_InvalidArgs); + + if (aActive) + { + mTimestamp.SetSeconds(aDataset.mActiveTimestamp); + mTimestamp.SetTicks(0); + mTimestamp.SetAuthoritative(false); + } + else + { + MeshCoP::ActiveTimestampTlv tlv; + + VerifyOrExit(aDataset.mIsPendingTimestampSet, error = kThreadError_InvalidArgs); + mTimestamp.SetSeconds(aDataset.mPendingTimestamp); + mTimestamp.SetTicks(0); + mTimestamp.SetAuthoritative(false); + + tlv.Init(); + tlv.SetSeconds(aDataset.mActiveTimestamp); + Set(tlv); + } + + if (aDataset.mIsChannelSet) + { + MeshCoP::ChannelTlv tlv; + tlv.Init(); + tlv.SetChannelPage(0); + tlv.SetChannel(aDataset.mChannel); + Set(tlv); + } + + if (aDataset.mIsDelaySet) + { + MeshCoP::DelayTimerTlv tlv; + tlv.Init(); + tlv.SetDelayTimer(aDataset.mDelay); + Set(tlv); + } + + if (aDataset.mIsExtendedPanIdSet) + { + MeshCoP::ExtendedPanIdTlv tlv; + tlv.Init(); + tlv.SetExtendedPanId(aDataset.mExtendedPanId.m8); + Set(tlv); + } + + if (aDataset.mIsMeshLocalPrefixSet) + { + MeshCoP::MeshLocalPrefixTlv tlv; + tlv.Init(); + tlv.SetMeshLocalPrefix(aDataset.mMeshLocalPrefix.m8); + Set(tlv); + } + + if (aDataset.mIsMasterKeySet) + { + MeshCoP::NetworkMasterKeyTlv tlv; + tlv.Init(); + tlv.SetNetworkMasterKey(aDataset.mMasterKey.m8); + Set(tlv); + } + + if (aDataset.mIsNetworkNameSet) + { + MeshCoP::NetworkNameTlv tlv; + tlv.Init(); + tlv.SetNetworkName(aDataset.mNetworkName.m8); + Set(tlv); + } + + if (aDataset.mIsPanIdSet) + { + MeshCoP::PanIdTlv tlv; + tlv.Init(); + tlv.SetPanId(aDataset.mPanId); + Set(tlv); + } + +exit: + return error; +} + const Timestamp &Dataset::GetTimestamp(void) const { return mTimestamp; diff --git a/src/core/thread/meshcop_dataset.hpp b/src/core/thread/meshcop_dataset.hpp index 3c62229b8..3e4b9a9f2 100644 --- a/src/core/thread/meshcop_dataset.hpp +++ b/src/core/thread/meshcop_dataset.hpp @@ -85,6 +85,12 @@ public: */ const uint8_t *GetBytes(void) const { return mTlvs; } + /** + * This method converts the TLV representation to structure representation. + * + */ + void Get(otOperationalDataset &aDataset); + /** * This method returns the Dataset size in bytes. * @@ -120,6 +126,8 @@ public: ThreadError Set(const Message &aMessage, uint16_t aOffset, uint16_t aLength); + ThreadError Set(const otOperationalDataset &aDataset, bool aActive); + void Remove(Tlv::Type aType); private: diff --git a/src/core/thread/meshcop_dataset_manager.cpp b/src/core/thread/meshcop_dataset_manager.cpp index f5ecac438..1db6b55b1 100644 --- a/src/core/thread/meshcop_dataset_manager.cpp +++ b/src/core/thread/meshcop_dataset_manager.cpp @@ -302,6 +302,14 @@ ActiveDataset::ActiveDataset(ThreadNetif &aThreadNetif): { } +void ActiveDataset::Get(otOperationalDataset &aDataset) +{ + memset(&aDataset, 0, sizeof(aDataset)); + mLocal.Get(aDataset); + aDataset.mActiveTimestamp = mLocal.GetTimestamp().GetSeconds(); + aDataset.mIsActiveTimestampSet = true; +} + ThreadError ActiveDataset::Set(const Dataset &aDataset) { ThreadError error = kThreadError_None; @@ -314,6 +322,18 @@ exit: return error; } +ThreadError ActiveDataset::Set(const otOperationalDataset &aDataset) +{ + ThreadError error = kThreadError_None; + Dataset dataset; + + SuccessOrExit(error = dataset.Set(aDataset, true)); + SuccessOrExit(error = Set(dataset)); + +exit: + return error; +} + ThreadError ActiveDataset::Set(const Timestamp &aTimestamp, const Message &aMessage, uint16_t aOffset, uint16_t aLength) { @@ -403,6 +423,14 @@ PendingDataset::PendingDataset(ThreadNetif &aThreadNetif): { } +void PendingDataset::Get(otOperationalDataset &aDataset) +{ + memset(&aDataset, 0, sizeof(aDataset)); + mLocal.Get(aDataset); + aDataset.mPendingTimestamp = mLocal.GetTimestamp().GetSeconds(); + aDataset.mIsPendingTimestampSet = true; +} + ThreadError PendingDataset::Set(const Dataset &aDataset) { ThreadError error = kThreadError_None; @@ -415,6 +443,18 @@ exit: return error; } +ThreadError PendingDataset::Set(const otOperationalDataset &aDataset) +{ + ThreadError error = kThreadError_None; + Dataset dataset; + + SuccessOrExit(error = dataset.Set(aDataset, false)); + SuccessOrExit(error = Set(dataset)); + +exit: + return error; +} + ThreadError PendingDataset::Set(const Timestamp &aTimestamp, const Message &aMessage, uint16_t aOffset, uint16_t aLength) { diff --git a/src/core/thread/meshcop_dataset_manager.hpp b/src/core/thread/meshcop_dataset_manager.hpp index ff05ffd1f..d60869c41 100644 --- a/src/core/thread/meshcop_dataset_manager.hpp +++ b/src/core/thread/meshcop_dataset_manager.hpp @@ -35,6 +35,8 @@ #ifndef MESHCOP_DATASET_MANAGER_HPP_ #define MESHCOP_DATASET_MANAGER_HPP_ +#include + #include #include #include @@ -109,8 +111,12 @@ class ActiveDataset: public DatasetManager public: ActiveDataset(ThreadNetif &aThreadNetif); + void Get(otOperationalDataset &aDataset); + ThreadError Set(const Dataset &aDataset); + ThreadError Set(const otOperationalDataset &aDataset); + ThreadError Set(const Timestamp &aTimestamp, const Message &aMessage, uint16_t aOffset, uint16_t aLength); ThreadError ApplyConfiguration(void); @@ -121,8 +127,12 @@ class PendingDataset: public DatasetManager public: PendingDataset(ThreadNetif &aThreadNetif); + void Get(otOperationalDataset &aDataset); + ThreadError Set(const Dataset &aDataset); + ThreadError Set(const otOperationalDataset &aDataset); + ThreadError Set(const Timestamp &aTimestamp, const Message &aMessage, uint16_t aOffset, uint16_t aLength); void ApplyLocalToNetwork(void);