自学教程：C++ HostSwap16函数代码示例

ThreadError Tlv::GetOffset(const Message &aMessage, uint8_t aType, uint16_t &aOffset){    ThreadError error = kThreadError_Parse;    uint16_t offset = aMessage.GetOffset();    uint16_t end = aMessage.GetLength();    Tlv tlv;    while (offset < end)    {        aMessage.Read(offset, sizeof(Tlv), &tlv);        // skip extended TLV        if (tlv.GetLength() == kExtendedLength)        {            uint16_t length = 0;            offset += sizeof(tlv);            aMessage.Read(offset, sizeof(length), &length);            offset += sizeof(length) + HostSwap16(length);        }        else if (tlv.GetType() == aType && (offset + sizeof(tlv) + tlv.GetLength()) <= end)        {            aOffset = offset;            ExitNow(error = kThreadError_None);        }        else        {            offset += sizeof(tlv) + tlv.GetLength();        }    }exit:    return error;}

void JoinerRouter::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo){    ThreadNetif &          netif = GetNetif();    otError                error;    Coap::Message *        message = NULL;    Ip6::MessageInfo       messageInfo;    JoinerUdpPortTlv       udpPort;    JoinerIidTlv           iid;    JoinerRouterLocatorTlv rloc;    ExtendedTlv            tlv;    uint16_t               borderAgentRloc;    uint16_t               offset;    otLogInfoMeshCoP("JoinerRouter::HandleUdpReceive");    SuccessOrExit(error = GetBorderAgentRloc(GetNetif(), borderAgentRloc));    VerifyOrExit((message = NewMeshCoPMessage(netif.GetCoap())) != NULL, error = OT_ERROR_NO_BUFS);    message->Init(OT_COAP_TYPE_NON_CONFIRMABLE, OT_COAP_CODE_POST);    message->SetToken(Coap::Message::kDefaultTokenLength);    message->AppendUriPathOptions(OT_URI_PATH_RELAY_RX);    message->SetPayloadMarker();    udpPort.Init();    udpPort.SetUdpPort(aMessageInfo.GetPeerPort());    SuccessOrExit(error = message->Append(&udpPort, sizeof(udpPort)));    iid.Init();    iid.SetIid(aMessageInfo.GetPeerAddr().mFields.m8 + 8);    SuccessOrExit(error = message->Append(&iid, sizeof(iid)));    rloc.Init();    rloc.SetJoinerRouterLocator(netif.GetMle().GetRloc16());    SuccessOrExit(error = message->Append(&rloc, sizeof(rloc)));    tlv.SetType(Tlv::kJoinerDtlsEncapsulation);    tlv.SetLength(aMessage.GetLength() - aMessage.GetOffset());    SuccessOrExit(error = message->Append(&tlv, sizeof(tlv)));    offset = message->GetLength();    SuccessOrExit(error = message->SetLength(offset + tlv.GetLength()));    aMessage.CopyTo(aMessage.GetOffset(), offset, tlv.GetLength(), *message);    messageInfo.SetSockAddr(netif.GetMle().GetMeshLocal16());    messageInfo.SetPeerAddr(netif.GetMle().GetMeshLocal16());    messageInfo.GetPeerAddr().mFields.m16[7] = HostSwap16(borderAgentRloc);    messageInfo.SetPeerPort(kCoapUdpPort);    SuccessOrExit(error = netif.GetCoap().SendMessage(*message, messageInfo));    otLogInfoMeshCoP("Sent relay rx");exit:    if (error != OT_ERROR_NONE && message != NULL)    {        message->Free();    }}

otError Udp::UpdateChecksum(Message &aMessage, uint16_t aChecksum){    aChecksum = aMessage.UpdateChecksum(aChecksum, aMessage.GetOffset(), aMessage.GetLength() - aMessage.GetOffset());    if (aChecksum != 0xffff)    {        aChecksum = ~aChecksum;    }    aChecksum = HostSwap16(aChecksum);    aMessage.Write(aMessage.GetOffset() + UdpHeader::GetChecksumOffset(), sizeof(aChecksum), &aChecksum);    return OT_ERROR_NONE;}

ThreadError AddMplOption(Message &message, Header &header, IpProto nextHeader, uint16_t payloadLength){    ThreadError error = kThreadError_None;    HopByHopHeader hbhHeader;    OptionMpl mplOption;    hbhHeader.SetNextHeader(nextHeader);    hbhHeader.SetLength(0);    sMpl.InitOption(mplOption, HostSwap16(header.GetSource().mFields.m16[7]));    SuccessOrExit(error = message.Prepend(&mplOption, sizeof(mplOption)));    SuccessOrExit(error = message.Prepend(&hbhHeader, sizeof(hbhHeader)));    header.SetPayloadLength(sizeof(hbhHeader) + sizeof(mplOption) + payloadLength);    header.SetNextHeader(kProtoHopOpts);exit:    return error;}

void UdpExample::HandleUdpReceive(otMessage *aMessage, const otMessageInfo *aMessageInfo){    uint8_t buf[1500];    int     length;    mInterpreter.mServer->OutputFormat("%d bytes from ", otMessageGetLength(aMessage) - otMessageGetOffset(aMessage));    mInterpreter.mServer->OutputFormat(        "%x:%x:%x:%x:%x:%x:%x:%x %d ", HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[0]),        HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[1]), HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[2]),        HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[3]), HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[4]),        HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[5]), HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[6]),        HostSwap16(aMessageInfo->mPeerAddr.mFields.m16[7]), aMessageInfo->mPeerPort);    length      = otMessageRead(aMessage, otMessageGetOffset(aMessage), buf, sizeof(buf) - 1);    buf[length] = '/0';    mInterpreter.mServer->OutputFormat("%s/r/n", buf);}

void Leader::HandlePetition(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo){    CommissioningData data;    CommissionerIdTlv commissionerId;    StateTlv::State state = StateTlv::kReject;    otLogInfoMeshCoP(GetInstance(), "received petition");    SuccessOrExit(Tlv::GetTlv(aMessage, Tlv::kCommissionerId, sizeof(commissionerId), commissionerId));    VerifyOrExit(commissionerId.IsValid());    if (mTimer.IsRunning())    {        VerifyOrExit(!strncmp(commissionerId.GetCommissionerId(), mCommissionerId.GetCommissionerId(),                              sizeof(mCommissionerId)));        ResignCommissioner();    }    data.mBorderAgentLocator.Init();    data.mBorderAgentLocator.SetBorderAgentLocator(HostSwap16(aMessageInfo.GetPeerAddr().mFields.m16[7]));    data.mCommissionerSessionId.Init();    data.mCommissionerSessionId.SetCommissionerSessionId(++mSessionId);    data.mSteeringData.Init();    data.mSteeringData.SetLength(1);    data.mSteeringData.Clear();    SuccessOrExit(GetNetif().GetNetworkDataLeader().SetCommissioningData(reinterpret_cast<uint8_t *>(&data),                                                                         data.GetLength()));    mCommissionerId = commissionerId;    state = StateTlv::kAccept;    mTimer.Start(TimerMilli::SecToMsec(kTimeoutLeaderPetition));exit:    OT_UNUSED_VARIABLE(aMessageInfo);    SendPetitionResponse(aHeader, aMessageInfo, state);}

void ChannelTlv::SetChannel(uint16_t aChannel){    uint8_t channelPage = OT_RADIO_CHANNEL_PAGE_0;#if OPENTHREAD_CONFIG_RADIO_2P4GHZ_OQPSK_SUPPORT    if ((OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MIN <= aChannel) && (aChannel <= OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MAX))    {        channelPage = OT_RADIO_CHANNEL_PAGE_0;    }#endif#if OPENTHREAD_CONFIG_RADIO_915MHZ_OQPSK_SUPPORT    if ((OT_RADIO_915MHZ_OQPSK_CHANNEL_MIN <= aChannel) && (aChannel <= OT_RADIO_915MHZ_OQPSK_CHANNEL_MAX))    {        channelPage = OT_RADIO_CHANNEL_PAGE_2;    }#endif    SetChannelPage(channelPage);    mChannel = HostSwap16(aChannel);}

otError Joiner::TryNextJoin(){    ThreadNetif & netif        = GetNetif();    otError       error        = OT_ERROR_NOT_FOUND;    JoinerRouter *joinerRouter = &mJoinerRouters[0];    for (size_t i = 1; i < OPENTHREAD_CONFIG_MAX_JOINER_ROUTER_ENTRIES; i++)    {        if (mJoinerRouters[i].mPriority > joinerRouter->mPriority)        {            joinerRouter = &mJoinerRouters[i];        }    }    if (joinerRouter->mPriority > 0)    {        Ip6::SockAddr sockaddr;        joinerRouter->mPriority = 0;        netif.GetMac().SetPanId(joinerRouter->mPanId);        netif.GetMac().SetPanChannel(joinerRouter->mChannel);        netif.GetIp6Filter().AddUnsecurePort(OPENTHREAD_CONFIG_JOINER_UDP_PORT);        sockaddr.GetAddress().mFields.m16[0] = HostSwap16(0xfe80);        sockaddr.GetAddress().SetIid(joinerRouter->mExtAddr);        sockaddr.mPort    = joinerRouter->mJoinerUdpPort;        sockaddr.mScopeId = OT_NETIF_INTERFACE_ID_THREAD;        netif.GetCoapSecure().Connect(sockaddr, Joiner::HandleSecureCoapClientConnect, this);        mState = OT_JOINER_STATE_CONNECT;        error  = OT_ERROR_NONE;    }    else    {        otLogDebgMeshCoP("No joinable networks remaining to try");    }    return error;}

otError Tlv::GetOffset(const Message &aMessage, uint8_t aType, uint16_t &aOffset){    otError error = OT_ERROR_NOT_FOUND;    uint16_t offset = aMessage.GetOffset();    uint16_t end = aMessage.GetLength();    Tlv tlv;    while (offset + sizeof(tlv) <= end)    {        uint32_t length = sizeof(tlv);        aMessage.Read(offset, sizeof(tlv), &tlv);        if (tlv.GetLength() != kExtendedLength)        {            length += tlv.GetLength();        }        else        {            uint16_t extLength;            VerifyOrExit(sizeof(extLength) == aMessage.Read(offset + sizeof(tlv), sizeof(extLength), &extLength));            length += sizeof(extLength) + HostSwap16(extLength);        }        VerifyOrExit(offset + length <= end);        if (tlv.GetType() == aType)        {            aOffset = offset;            ExitNow(error = OT_ERROR_NONE);        }        offset += static_cast<uint16_t>(length);    }exit:    return error;}

otError Mpl::ProcessOption(Message &aMessage, const Address &aAddress, bool aIsOutbound){    otError error;    OptionMpl option;    VerifyOrExit(aMessage.Read(aMessage.GetOffset(), sizeof(option), &option) >= OptionMpl::kMinLength &&                 (option.GetSeedIdLength() == OptionMpl::kSeedIdLength0 ||                  option.GetSeedIdLength() == OptionMpl::kSeedIdLength2),                 error = OT_ERROR_DROP);    if (option.GetSeedIdLength() == OptionMpl::kSeedIdLength0)    {        // Retrieve MPL Seed Id from the IPv6 Source Address.        option.SetSeedId(HostSwap16(aAddress.mFields.m16[7]));    }    // Check MPL Data Messages in the MPL Buffered Set against sequence number.    UpdateBufferedSet(option.GetSeedId(), option.GetSequence());    // Check if the MPL Data Message is new.    error = UpdateSeedSet(option.GetSeedId(), option.GetSequence());    if (error == OT_ERROR_NONE)    {        AddBufferedMessage(aMessage, option.GetSeedId(), option.GetSequence(), aIsOutbound);    }    else if (aIsOutbound)    {        // In case MPL Data Message is generated locally, ignore potential error of the MPL Seed Set        // to allow subsequent retransmissions with the same sequence number.        ExitNow(error = OT_ERROR_NONE);    }exit:    return error;}

 /**  * This method returns the TCP Flags.  *  * @returns The TCP Flags.  *  */ uint16_t GetFlags(void) const { return HostSwap16(mFlags); }

 /**  * This method sets the MPL Seed Id value.  *  * @param[in]  aSeedId  The MPL Seed Id value.  *  */ void SetSeedId(uint16_t aSeedId) { mSeedId = HostSwap16(aSeedId); }

 /**  * This method returns the MPL Seed Id value.  *  * @returns The MPL Seed Id value.  *  */ uint16_t GetSeedId(void) const { return HostSwap16(mSeedId); }

 /**  * This method sets the ICMPv6 message sequence for Echo Requests and Replies.  *  * @param[in]  aSequence  The ICMPv6 message sequence.  *  */ void SetSequence(uint16_t aSequence) { mData.m16[1] = HostSwap16(aSequence); }

 /**  * This method returns the ICMPv6 message sequence for Echo Requests and Replies.  *  * @returns The ICMPv6 message sequence.  *  */ uint16_t GetSequence(void) const { return HostSwap16(mData.m16[1]); }

 /**  * This method returns the Length value.  *  */ uint16_t GetLength(void) const { return HostSwap16(mLength); }

 /**  * This method returns the TCP Destination Port.  *  * @returns The TCP Destination Port.  *  */ uint16_t GetDestinationPort(void) const { return HostSwap16(mDestination); }

 /**  * This method returns the TCP Urgent Pointer.  *  * @returns The TCP Urgent Pointer.  *  */ uint16_t GetUrgentPointer(void) const { return HostSwap16(mUrgentPointer); }

 /**  * This method returns the TCP Window.  *  * @returns The TCP Window.  *  */ uint16_t GetWindow(void) const { return HostSwap16(mWindow); }

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();    }}

 /**  * This method sets the Length value.  *  * @param[in]  aLength  The Length value.  *  */ void SetLength(uint16_t aLength) {     Tlv::SetLength(kExtendedLength);     mLength = HostSwap16(aLength); }

void Coap::HandleServerResponse(otCoapHeader *aHeader, otMessage *aMessage, const otMessageInfo *aMessageInfo){    otError error = OT_ERROR_NONE;    otCoapHeader responseHeader;    otMessage *responseMessage;    otCoapCode responseCode = OT_COAP_CODE_EMPTY;    char responseContent = '0';    mInterpreter.mServer->OutputFormat("Received coap request from [%x:%x:%x:%x:%x:%x:%x:%x]: ",                                       HostSwap16(aMessageInfo->mSockAddr.mFields.m16[0]),                                       HostSwap16(aMessageInfo->mSockAddr.mFields.m16[1]),                                       HostSwap16(aMessageInfo->mSockAddr.mFields.m16[2]),                                       HostSwap16(aMessageInfo->mSockAddr.mFields.m16[3]),                                       HostSwap16(aMessageInfo->mSockAddr.mFields.m16[4]),                                       HostSwap16(aMessageInfo->mSockAddr.mFields.m16[5]),                                       HostSwap16(aMessageInfo->mSockAddr.mFields.m16[6]),                                       HostSwap16(aMessageInfo->mSockAddr.mFields.m16[7]));    switch (otCoapHeaderGetCode(aHeader))    {    case OT_COAP_CODE_GET:        mInterpreter.mServer->OutputFormat("GET");        break;    case OT_COAP_CODE_DELETE:        mInterpreter.mServer->OutputFormat("DELETE");        break;    case OT_COAP_CODE_PUT:        mInterpreter.mServer->OutputFormat("PUT");        break;    case OT_COAP_CODE_POST:        mInterpreter.mServer->OutputFormat("POST");        break;    default:        mInterpreter.mServer->OutputFormat("Undefined/r/n");        return;    }    PrintPayload(aMessage);    if ((otCoapHeaderGetType(aHeader) == OT_COAP_TYPE_CONFIRMABLE) || otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)    {        if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)        {            responseCode = OT_COAP_CODE_CONTENT;        }        else        {            responseCode = OT_COAP_CODE_VALID;        }        otCoapHeaderInit(&responseHeader, OT_COAP_TYPE_ACKNOWLEDGMENT, responseCode);        otCoapHeaderSetMessageId(&responseHeader, otCoapHeaderGetMessageId(aHeader));        otCoapHeaderSetToken(&responseHeader, otCoapHeaderGetToken(aHeader), otCoapHeaderGetTokenLength(aHeader));        if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)        {            otCoapHeaderSetPayloadMarker(&responseHeader);        }        responseMessage = otCoapNewMessage(mInterpreter.mInstance, &responseHeader);        VerifyOrExit(responseMessage != NULL, error = OT_ERROR_NO_BUFS);        if (otCoapHeaderGetCode(aHeader) == OT_COAP_CODE_GET)        {            SuccessOrExit(error = otMessageAppend(responseMessage, &responseContent, sizeof(responseContent)));        }        SuccessOrExit(error = otCoapSendResponse(mInterpreter.mInstance, responseMessage, aMessageInfo));    }exit:    if (error != OT_ERROR_NONE && responseMessage != NULL)    {        mInterpreter.mServer->OutputFormat("Cannot send coap response message: Error %d: %s/r/n",                                           error, otThreadErrorToString(error));        otMessageFree(responseMessage);    }    else if (responseCode >= OT_COAP_CODE_RESPONSE_MIN)    {        mInterpreter.mServer->OutputFormat("coap response sent successfully!/r/n");    }}

 /**  * This method returns the TCP Checksum.  *  * @returns The TCP Checksum.  *  */ uint16_t GetChecksum(void) const { return HostSwap16(mChecksum); }

 /**  * This method sets the ICMPv6 message checksum.  *  * @param[in]  aChecksum  The ICMPv6 message checksum.  *  */ void SetChecksum(uint16_t aChecksum) { mChecksum = HostSwap16(aChecksum); }

 /**  * This method returns the TCP Source Port.  *  * @returns The TCP Source Port.  *  */ uint16_t GetSourcePort(void) const { return HostSwap16(mSource); }

 /**  * This method returns the ICMPv6 message ID for Echo Requests and Replies.  *  * @returns The ICMPv6 message ID.  *  */ uint16_t GetId(void) const { return HostSwap16(mData.m16[0]); }

otError Dhcp6Server::UpdateService(void){    ThreadNetif &netif = GetNetif();    otError error = OT_ERROR_NONE;    bool found;    uint8_t i;    uint16_t rloc16 = netif.GetMle().GetRloc16();    Ip6::Address *address = NULL;    otNetworkDataIterator iterator;    otBorderRouterConfig config;    Lowpan::Context lowpanContext;    // remove dhcp agent aloc and prefix delegation    for (i = 0; i < OPENTHREAD_CONFIG_NUM_DHCP_PREFIXES; i++)    {        found = false;        if (!mAgentsAloc[i].mValid)        {            continue;        }        address = &(mAgentsAloc[i].GetAddress());        iterator = OT_NETWORK_DATA_ITERATOR_INIT;        while (netif.GetNetworkDataLeader().GetNextOnMeshPrefix(&iterator, rloc16, &config) == OT_ERROR_NONE)        {            if (!config.mDhcp)            {                continue;            }            netif.GetNetworkDataLeader().GetContext(*static_cast<const Ip6::Address *>(&(config.mPrefix.mPrefix)),                                                    lowpanContext);            if (address->mFields.m8[15] == lowpanContext.mContextId)            {                // still in network data                found = true;                break;            }        }        if (!found)        {            netif.GetNetworkDataLeader().GetContext(address->mFields.m8[15], lowpanContext);            netif.RemoveUnicastAddress(mAgentsAloc[i]);            mAgentsAloc[i].mValid = false;            RemovePrefixAgent(lowpanContext.mPrefix);        }    }    // add dhcp agent aloc and prefix delegation    iterator = OT_NETWORK_DATA_ITERATOR_INIT;    while (netif.GetNetworkDataLeader().GetNextOnMeshPrefix(&iterator, rloc16, &config) == OT_ERROR_NONE)    {        found = false;        if (!config.mDhcp)        {            continue;        }        netif.GetNetworkDataLeader().GetContext(*static_cast<const Ip6::Address *>(&config.mPrefix.mPrefix),                                                lowpanContext);        for (i = 0; i < OPENTHREAD_CONFIG_NUM_DHCP_PREFIXES; i++)        {            address = &(mAgentsAloc[i].GetAddress());            if ((mAgentsAloc[i].mValid) && (address->mFields.m8[15] == lowpanContext.mContextId))            {                found = true;                break;            }        }        // alreay added        if (found)        {            continue;        }        for (i = 0; i < OPENTHREAD_CONFIG_NUM_DHCP_PREFIXES; i++)        {            if (!mAgentsAloc[i].mValid)            {                address = &(mAgentsAloc[i].GetAddress());                memcpy(address, netif.GetMle().GetMeshLocalPrefix(), 8);                address->mFields.m16[4] = HostSwap16(0x0000);                address->mFields.m16[5] = HostSwap16(0x00ff);                address->mFields.m16[6] = HostSwap16(0xfe00);                address->mFields.m8[14] = Ip6::Address::kAloc16Mask;                address->mFields.m8[15] = lowpanContext.mContextId;                mAgentsAloc[i].mPrefixLength = 128;                mAgentsAloc[i].mPreferred = true;                mAgentsAloc[i].mValid = true;                netif.AddUnicastAddress(mAgentsAloc[i]);                AddPrefixAgent(config.mPrefix);//.........这里部分代码省略.........

 /**  * This method sets the ICMPv6 message ID for Echo Requests and Replies.  *  * @param[in]  aId  The ICMPv6 message ID.  *  */ void SetId(uint16_t aId) { mData.m16[0] = HostSwap16(aId); }