From 1ece777a8232227c462e6766b17c0b910e42388b Mon Sep 17 00:00:00 2001 From: Buke Po Date: Thu, 11 May 2017 08:57:35 +0800 Subject: [PATCH] sync parameter names in ip6.cpp with ip6.hpp (#1755) --- src/core/net/ip6.cpp | 250 +++++++++++++++++++++---------------------- src/core/net/ip6.hpp | 20 ++-- 2 files changed, 135 insertions(+), 135 deletions(-) diff --git a/src/core/net/ip6.cpp b/src/core/net/ip6.cpp index d9d43dd7f..7e26a4888 100644 --- a/src/core/net/ip6.cpp +++ b/src/core/net/ip6.cpp @@ -71,42 +71,43 @@ Ip6::Ip6(void): { } -Message *Ip6::NewMessage(uint16_t reserved) +Message *Ip6::NewMessage(uint16_t aReserved) { - return mMessagePool.New(Message::kTypeIp6, sizeof(Header) + sizeof(HopByHopHeader) + sizeof(OptionMpl) + reserved); + return mMessagePool.New(Message::kTypeIp6, sizeof(Header) + sizeof(HopByHopHeader) + sizeof(OptionMpl) + aReserved); } -uint16_t Ip6::UpdateChecksum(uint16_t checksum, uint16_t val) +uint16_t Ip6::UpdateChecksum(uint16_t aChecksum, uint16_t aValue) { - uint16_t result = checksum + val; - return result + (result < checksum); + uint16_t result = aChecksum + aValue; + return result + (result < aChecksum); } -uint16_t Ip6::UpdateChecksum(uint16_t checksum, const void *buf, uint16_t len) +uint16_t Ip6::UpdateChecksum(uint16_t aChecksum, const void *aBuf, uint16_t aLength) { - const uint8_t *bytes = reinterpret_cast(buf); + const uint8_t *bytes = reinterpret_cast(aBuf); - for (int i = 0; i < len; i++) + for (int i = 0; i < aLength; i++) { - checksum = Ip6::UpdateChecksum(checksum, (i & 1) ? bytes[i] : static_cast(bytes[i] << 8)); + aChecksum = Ip6::UpdateChecksum(aChecksum, (i & 1) ? bytes[i] : static_cast(bytes[i] << 8)); } - return checksum; + return aChecksum; } -uint16_t Ip6::UpdateChecksum(uint16_t checksum, const Address &address) +uint16_t Ip6::UpdateChecksum(uint16_t aChecksum, const Address &aAddress) { - return Ip6::UpdateChecksum(checksum, address.mFields.m8, sizeof(address)); + return Ip6::UpdateChecksum(aChecksum, aAddress.mFields.m8, sizeof(aAddress)); } -uint16_t Ip6::ComputePseudoheaderChecksum(const Address &src, const Address &dst, uint16_t length, IpProto proto) +uint16_t Ip6::ComputePseudoheaderChecksum(const Address &aSource, const Address &aDestination, uint16_t aLength, + IpProto aProto) { uint16_t checksum; - checksum = Ip6::UpdateChecksum(0, length); - checksum = Ip6::UpdateChecksum(checksum, static_cast(proto)); - checksum = UpdateChecksum(checksum, src); - checksum = UpdateChecksum(checksum, dst); + checksum = Ip6::UpdateChecksum(0, aLength); + checksum = Ip6::UpdateChecksum(checksum, static_cast(aProto)); + checksum = UpdateChecksum(checksum, aSource); + checksum = UpdateChecksum(checksum, aDestination); return checksum; } @@ -117,28 +118,28 @@ void Ip6::SetReceiveDatagramCallback(otIp6ReceiveCallback aCallback, void *aCall mReceiveIp6DatagramCallbackContext = aCallbackContext; } -ThreadError Ip6::AddMplOption(Message &message, Header &header) +ThreadError Ip6::AddMplOption(Message &aMessage, Header &aHeader) { ThreadError error = kThreadError_None; HopByHopHeader hbhHeader; OptionMpl mplOption; OptionPadN padOption; - hbhHeader.SetNextHeader(header.GetNextHeader()); + hbhHeader.SetNextHeader(aHeader.GetNextHeader()); hbhHeader.SetLength(0); - mMpl.InitOption(mplOption, header.GetSource()); + mMpl.InitOption(mplOption, aHeader.GetSource()); // Mpl option may require two bytes padding. if ((mplOption.GetTotalLength() + sizeof(hbhHeader)) % 8) { padOption.Init(2); - SuccessOrExit(error = message.Prepend(&padOption, padOption.GetTotalLength())); + SuccessOrExit(error = aMessage.Prepend(&padOption, padOption.GetTotalLength())); } - SuccessOrExit(error = message.Prepend(&mplOption, mplOption.GetTotalLength())); - SuccessOrExit(error = message.Prepend(&hbhHeader, sizeof(hbhHeader))); - header.SetPayloadLength(header.GetPayloadLength() + sizeof(hbhHeader) + sizeof(mplOption)); - header.SetNextHeader(kProtoHopOpts); + SuccessOrExit(error = aMessage.Prepend(&mplOption, mplOption.GetTotalLength())); + SuccessOrExit(error = aMessage.Prepend(&hbhHeader, sizeof(hbhHeader))); + aHeader.SetPayloadLength(aHeader.GetPayloadLength() + sizeof(hbhHeader) + sizeof(mplOption)); + aHeader.SetNextHeader(kProtoHopOpts); exit: return error; } @@ -350,63 +351,63 @@ void Ip6::EnqueueDatagram(Message &aMessage) mSendQueueTask.Post(); } -ThreadError Ip6::SendDatagram(Message &message, MessageInfo &messageInfo, IpProto ipproto) +ThreadError Ip6::SendDatagram(Message &aMessage, MessageInfo &aMessageInfo, IpProto aIpProto) { ThreadError error = kThreadError_None; Header header; - uint16_t payloadLength = message.GetLength(); + uint16_t payloadLength = aMessage.GetLength(); uint16_t checksum; const NetifUnicastAddress *source; header.Init(); header.SetPayloadLength(payloadLength); - header.SetNextHeader(ipproto); - header.SetHopLimit(messageInfo.mHopLimit ? messageInfo.mHopLimit : static_cast(kDefaultHopLimit)); + header.SetNextHeader(aIpProto); + header.SetHopLimit(aMessageInfo.mHopLimit ? aMessageInfo.mHopLimit : static_cast(kDefaultHopLimit)); - if (messageInfo.GetSockAddr().IsUnspecified() || - messageInfo.GetSockAddr().IsMulticast()) + if (aMessageInfo.GetSockAddr().IsUnspecified() || + aMessageInfo.GetSockAddr().IsMulticast()) { - VerifyOrExit((source = SelectSourceAddress(messageInfo)) != NULL, + VerifyOrExit((source = SelectSourceAddress(aMessageInfo)) != NULL, error = kThreadError_Error); header.SetSource(source->GetAddress()); } else { - header.SetSource(messageInfo.GetSockAddr()); + header.SetSource(aMessageInfo.GetSockAddr()); } - header.SetDestination(messageInfo.GetPeerAddr()); + header.SetDestination(aMessageInfo.GetPeerAddr()); if (header.GetDestination().IsLinkLocal() || header.GetDestination().IsLinkLocalMulticast()) { - VerifyOrExit(messageInfo.GetInterfaceId() != 0, error = kThreadError_Drop); + VerifyOrExit(aMessageInfo.GetInterfaceId() != 0, error = kThreadError_Drop); } - if (messageInfo.GetPeerAddr().IsRealmLocalMulticast()) + if (aMessageInfo.GetPeerAddr().IsRealmLocalMulticast()) { - SuccessOrExit(error = AddMplOption(message, header)); + SuccessOrExit(error = AddMplOption(aMessage, header)); } - SuccessOrExit(error = message.Prepend(&header, sizeof(header))); + SuccessOrExit(error = aMessage.Prepend(&header, sizeof(header))); - if (messageInfo.GetPeerAddr().IsMulticast() && - messageInfo.GetPeerAddr().GetScope() > Address::kRealmLocalScope) + if (aMessageInfo.GetPeerAddr().IsMulticast() && + aMessageInfo.GetPeerAddr().GetScope() > Address::kRealmLocalScope) { - SuccessOrExit(error = AddTunneledMplOption(message, header, messageInfo)); + SuccessOrExit(error = AddTunneledMplOption(aMessage, header, aMessageInfo)); } // compute checksum checksum = ComputePseudoheaderChecksum(header.GetSource(), header.GetDestination(), - payloadLength, ipproto); + payloadLength, aIpProto); - switch (ipproto) + switch (aIpProto) { case kProtoUdp: - SuccessOrExit(error = mUdp.UpdateChecksum(message, checksum)); + SuccessOrExit(error = mUdp.UpdateChecksum(aMessage, checksum)); break; case kProtoIcmp6: - SuccessOrExit(error = mIcmp.UpdateChecksum(message, checksum)); + SuccessOrExit(error = mIcmp.UpdateChecksum(aMessage, checksum)); break; default: @@ -417,8 +418,8 @@ exit: if (error == kThreadError_None) { - message.SetInterfaceId(messageInfo.GetInterfaceId()); - EnqueueDatagram(message); + aMessage.SetInterfaceId(aMessageInfo.GetInterfaceId()); + EnqueueDatagram(aMessage); } return error; @@ -440,39 +441,39 @@ void Ip6::HandleSendQueue(void) } } -ThreadError Ip6::HandleOptions(Message &message, Header &header, bool &forward) +ThreadError Ip6::HandleOptions(Message &aMessage, Header &aHeader, bool &aForward) { ThreadError error = kThreadError_None; HopByHopHeader hbhHeader; OptionHeader optionHeader; uint16_t endOffset; - VerifyOrExit(message.Read(message.GetOffset(), sizeof(hbhHeader), &hbhHeader) == sizeof(hbhHeader), + VerifyOrExit(aMessage.Read(aMessage.GetOffset(), sizeof(hbhHeader), &hbhHeader) == sizeof(hbhHeader), error = kThreadError_Drop); - endOffset = message.GetOffset() + (hbhHeader.GetLength() + 1) * 8; + endOffset = aMessage.GetOffset() + (hbhHeader.GetLength() + 1) * 8; - VerifyOrExit(endOffset <= message.GetLength(), error = kThreadError_Drop); + VerifyOrExit(endOffset <= aMessage.GetLength(), error = kThreadError_Drop); - message.MoveOffset(sizeof(optionHeader)); + aMessage.MoveOffset(sizeof(optionHeader)); - while (message.GetOffset() < endOffset) + while (aMessage.GetOffset() < endOffset) { - VerifyOrExit(message.Read(message.GetOffset(), sizeof(optionHeader), &optionHeader) == sizeof(optionHeader), + VerifyOrExit(aMessage.Read(aMessage.GetOffset(), sizeof(optionHeader), &optionHeader) == sizeof(optionHeader), error = kThreadError_Drop); if (optionHeader.GetType() == OptionPad1::kType) { - message.MoveOffset(sizeof(OptionPad1)); + aMessage.MoveOffset(sizeof(OptionPad1)); continue; } - VerifyOrExit(message.GetOffset() + sizeof(optionHeader) + optionHeader.GetLength() <= endOffset, + VerifyOrExit(aMessage.GetOffset() + sizeof(optionHeader) + optionHeader.GetLength() <= endOffset, error = kThreadError_Drop); switch (optionHeader.GetType()) { case OptionMpl::kType: - SuccessOrExit(error = mMpl.ProcessOption(message, header.GetSource(), forward)); + SuccessOrExit(error = mMpl.ProcessOption(aMessage, aHeader.GetSource(), aForward)); break; default: @@ -497,53 +498,53 @@ ThreadError Ip6::HandleOptions(Message &message, Header &header, bool &forward) break; } - message.MoveOffset(sizeof(optionHeader) + optionHeader.GetLength()); + aMessage.MoveOffset(sizeof(optionHeader) + optionHeader.GetLength()); } exit: return error; } -ThreadError Ip6::HandleFragment(Message &message) +ThreadError Ip6::HandleFragment(Message &aMessage) { ThreadError error = kThreadError_None; FragmentHeader fragmentHeader; - VerifyOrExit(message.Read(message.GetOffset(), sizeof(fragmentHeader), &fragmentHeader) == sizeof(fragmentHeader), + VerifyOrExit(aMessage.Read(aMessage.GetOffset(), sizeof(fragmentHeader), &fragmentHeader) == sizeof(fragmentHeader), error = kThreadError_Drop); VerifyOrExit(fragmentHeader.GetOffset() == 0 && fragmentHeader.IsMoreFlagSet() == false, error = kThreadError_Drop); - message.MoveOffset(sizeof(fragmentHeader)); + aMessage.MoveOffset(sizeof(fragmentHeader)); exit: return error; } -ThreadError Ip6::HandleExtensionHeaders(Message &message, Header &header, uint8_t &nextHeader, bool forward, - bool receive) +ThreadError Ip6::HandleExtensionHeaders(Message &aMessage, Header &aHeader, uint8_t &aNextHeader, bool aForward, + bool aReceive) { ThreadError error = kThreadError_None; ExtensionHeader extHeader; - while (receive == true || nextHeader == kProtoHopOpts) + while (aReceive == true || aNextHeader == kProtoHopOpts) { - VerifyOrExit(message.Read(message.GetOffset(), sizeof(extHeader), &extHeader) == sizeof(extHeader), + VerifyOrExit(aMessage.Read(aMessage.GetOffset(), sizeof(extHeader), &extHeader) == sizeof(extHeader), error = kThreadError_Drop); - switch (nextHeader) + switch (aNextHeader) { case kProtoHopOpts: - SuccessOrExit(error = HandleOptions(message, header, forward)); + SuccessOrExit(error = HandleOptions(aMessage, aHeader, aForward)); break; case kProtoFragment: - SuccessOrExit(error = HandleFragment(message)); + SuccessOrExit(error = HandleFragment(aMessage)); break; case kProtoDstOpts: - SuccessOrExit(error = HandleOptions(message, header, forward)); + SuccessOrExit(error = HandleOptions(aMessage, aHeader, aForward)); break; case kProtoIp6: @@ -557,46 +558,46 @@ ThreadError Ip6::HandleExtensionHeaders(Message &message, Header &header, uint8_ ExitNow(); } - nextHeader = static_cast(extHeader.GetNextHeader()); + aNextHeader = static_cast(extHeader.GetNextHeader()); } exit: return error; } -ThreadError Ip6::HandlePayload(Message &message, MessageInfo &messageInfo, uint8_t ipproto) +ThreadError Ip6::HandlePayload(Message &aMessage, MessageInfo &aMessageInfo, uint8_t aIpProto) { ThreadError error = kThreadError_None; - switch (ipproto) + switch (aIpProto) { case kProtoUdp: - ExitNow(error = mUdp.HandleMessage(message, messageInfo)); + ExitNow(error = mUdp.HandleMessage(aMessage, aMessageInfo)); case kProtoIcmp6: - ExitNow(error = mIcmp.HandleMessage(message, messageInfo)); + ExitNow(error = mIcmp.HandleMessage(aMessage, aMessageInfo)); } exit: return error; } -ThreadError Ip6::ProcessReceiveCallback(const Message &aMessage, const MessageInfo &messageInfo, uint8_t aIpProto, - bool fromLocalHost) +ThreadError Ip6::ProcessReceiveCallback(const Message &aMessage, const MessageInfo &aMessageInfo, uint8_t aIpProto, + bool aFromNcpHost) { ThreadError error = kThreadError_None; Message *messageCopy = NULL; - VerifyOrExit(fromLocalHost == false, error = kThreadError_Drop); + VerifyOrExit(aFromNcpHost == false, error = kThreadError_Drop); VerifyOrExit(mReceiveIp6DatagramCallback != NULL, error = kThreadError_NoRoute); if (mIsReceiveIp6FilterEnabled) { // do not pass messages sent to/from an RLOC - VerifyOrExit(!messageInfo.GetSockAddr().IsRoutingLocator() && - !messageInfo.GetPeerAddr().IsRoutingLocator() && - !messageInfo.GetSockAddr().IsAnycastRoutingLocator() && - !messageInfo.GetPeerAddr().IsAnycastRoutingLocator(), + VerifyOrExit(!aMessageInfo.GetSockAddr().IsRoutingLocator() && + !aMessageInfo.GetPeerAddr().IsRoutingLocator() && + !aMessageInfo.GetSockAddr().IsAnycastRoutingLocator() && + !aMessageInfo.GetPeerAddr().IsAnycastRoutingLocator(), error = kThreadError_NoRoute); switch (aIpProto) @@ -614,8 +615,8 @@ ThreadError Ip6::ProcessReceiveCallback(const Message &aMessage, const MessageIn break; case kProtoUdp: - if (messageInfo.GetSockAddr().IsLinkLocal() || - messageInfo.GetSockAddr().IsLinkLocalMulticast()) + if (aMessageInfo.GetSockAddr().IsLinkLocal() || + aMessageInfo.GetSockAddr().IsLinkLocalMulticast()) { UdpHeader udp; aMessage.Read(aMessage.GetOffset(), sizeof(udp), &udp); @@ -657,8 +658,8 @@ exit: return error; } -ThreadError Ip6::HandleDatagram(Message &message, Netif *netif, int8_t interfaceId, const void *linkMessageInfo, - bool fromLocalHost) +ThreadError Ip6::HandleDatagram(Message &aMessage, Netif *aNetif, int8_t aInterfaceId, const void *aLinkMessageInfo, + bool aFromNcpHost) { ThreadError error = kThreadError_None; MessageInfo messageInfo; @@ -676,49 +677,48 @@ ThreadError Ip6::HandleDatagram(Message &message, Netif *netif, int8_t interface #if 0 uint8_t buf[1024]; - message.Read(0, sizeof(buf), buf); - dump("handle datagram", buf, message.GetLength()); + aMessage.Read(0, sizeof(buf), buf); + dump("handle datagram", buf, aMessage.GetLength()); #endif - // check message length - VerifyOrExit(message.Read(0, sizeof(header), &header) == sizeof(header), error = kThreadError_Drop); + // check aMessage length + VerifyOrExit(aMessage.Read(0, sizeof(header), &header) == sizeof(header), error = kThreadError_Drop); payloadLength = header.GetPayloadLength(); // check Version VerifyOrExit(header.IsVersion6(), error = kThreadError_Drop); // check Payload Length - VerifyOrExit(sizeof(header) + payloadLength == message.GetLength() && + VerifyOrExit(sizeof(header) + payloadLength == aMessage.GetLength() && sizeof(header) + payloadLength <= Ip6::kMaxDatagramLength, error = kThreadError_Drop); messageInfo.SetPeerAddr(header.GetSource()); messageInfo.SetSockAddr(header.GetDestination()); - messageInfo.SetInterfaceId(interfaceId); + messageInfo.SetInterfaceId(aInterfaceId); messageInfo.SetHopLimit(header.GetHopLimit()); - messageInfo.SetLinkInfo(linkMessageInfo); + messageInfo.SetLinkInfo(aLinkMessageInfo); // determine destination of packet if (header.GetDestination().IsMulticast()) { - if (netif != NULL) + if (aNetif != NULL) { - if (netif->IsMulticastSubscribed(header.GetDestination())) + if (aNetif->IsMulticastSubscribed(header.GetDestination())) { receive = true; } - else if (netif->IsMulticastPromiscuousEnabled()) + else if (aNetif->IsMulticastPromiscuousEnabled()) { multicastPromiscuous = true; } } - - if (netif == NULL) + else { forward = true; - if (fromLocalHost) + if (aFromNcpHost) { - SuccessOrExit(error = InsertMplOption(message, header, messageInfo)); + SuccessOrExit(error = InsertMplOption(aMessage, header, messageInfo)); } } } @@ -732,20 +732,20 @@ ThreadError Ip6::HandleDatagram(Message &message, Netif *netif, int8_t interface { forward = true; } - else if (netif == NULL) + else if (aNetif == NULL) { forward = true; } } - message.SetInterfaceId(interfaceId); - message.SetOffset(sizeof(header)); + aMessage.SetInterfaceId(aInterfaceId); + aMessage.SetOffset(sizeof(header)); // process IPv6 Extension Headers nextHeader = static_cast(header.GetNextHeader()); - SuccessOrExit(error = HandleExtensionHeaders(message, header, nextHeader, forward, receive)); + SuccessOrExit(error = HandleExtensionHeaders(aMessage, header, nextHeader, forward, receive)); - if (!mForwardingEnabled && netif != NULL) + if (!mForwardingEnabled && aNetif != NULL) { forward = false; } @@ -756,19 +756,19 @@ ThreadError Ip6::HandleDatagram(Message &message, Netif *netif, int8_t interface if (nextHeader == kProtoIp6) { // Remove encapsulating header. - message.RemoveHeader(message.GetOffset()); + aMessage.RemoveHeader(aMessage.GetOffset()); - HandleDatagram(message, netif, interfaceId, linkMessageInfo, fromLocalHost); + HandleDatagram(aMessage, aNetif, aInterfaceId, aLinkMessageInfo, aFromNcpHost); ExitNow(tunnel = true); } - ProcessReceiveCallback(message, messageInfo, nextHeader, fromLocalHost); + ProcessReceiveCallback(aMessage, messageInfo, nextHeader, aFromNcpHost); - SuccessOrExit(error = HandlePayload(message, messageInfo, nextHeader)); + SuccessOrExit(error = HandlePayload(aMessage, messageInfo, nextHeader)); } else if (multicastPromiscuous) { - ProcessReceiveCallback(message, messageInfo, nextHeader, fromLocalHost); + ProcessReceiveCallback(aMessage, messageInfo, nextHeader, aFromNcpHost); } if (forward) @@ -778,15 +778,15 @@ ThreadError Ip6::HandleDatagram(Message &message, Netif *netif, int8_t interface if (forwardInterfaceId == 0) { // try passing to host - SuccessOrExit(error = ProcessReceiveCallback(message, messageInfo, nextHeader, fromLocalHost)); + SuccessOrExit(error = ProcessReceiveCallback(aMessage, messageInfo, nextHeader, aFromNcpHost)); - // the caller transfers custody in the success case, so free the message here - message.Free(); + // the caller transfers custody in the success case, so free the aMessage here + aMessage.Free(); ExitNow(); } - if (netif != NULL) + if (aNetif != NULL) { header.SetHopLimit(header.GetHopLimit() - 1); } @@ -799,11 +799,11 @@ ThreadError Ip6::HandleDatagram(Message &message, Netif *netif, int8_t interface else { hopLimit = header.GetHopLimit(); - message.Write(Header::GetHopLimitOffset(), Header::GetHopLimitSize(), &hopLimit); + aMessage.Write(Header::GetHopLimitOffset(), Header::GetHopLimitSize(), &hopLimit); - // submit message to interface - VerifyOrExit((netif = GetNetifById(forwardInterfaceId)) != NULL, error = kThreadError_NoRoute); - SuccessOrExit(error = netif->SendMessage(message)); + // submit aMessage to interface + VerifyOrExit((aNetif = GetNetifById(forwardInterfaceId)) != NULL, error = kThreadError_NoRoute); + SuccessOrExit(error = aNetif->SendMessage(aMessage)); } } @@ -811,35 +811,35 @@ exit: if (!tunnel && (error != kThreadError_None || !forward)) { - message.Free(); + aMessage.Free(); } otLogFuncExitErr(error); return error; } -int8_t Ip6::FindForwardInterfaceId(const MessageInfo &messageInfo) +int8_t Ip6::FindForwardInterfaceId(const MessageInfo &aMessageInfo) { int8_t interfaceId; otLogFuncEntry(); - if (messageInfo.GetSockAddr().IsMulticast()) + if (aMessageInfo.GetSockAddr().IsMulticast()) { // multicast - interfaceId = messageInfo.mInterfaceId; + interfaceId = aMessageInfo.mInterfaceId; } - else if (messageInfo.GetSockAddr().IsLinkLocal()) + else if (aMessageInfo.GetSockAddr().IsLinkLocal()) { // on-link link-local address - interfaceId = messageInfo.mInterfaceId; + interfaceId = aMessageInfo.mInterfaceId; } - else if ((interfaceId = GetOnLinkNetif(messageInfo.GetSockAddr())) > 0) + else if ((interfaceId = GetOnLinkNetif(aMessageInfo.GetSockAddr())) > 0) { // on-link global address ; } - else if ((interfaceId = mRoutes.Lookup(messageInfo.GetPeerAddr(), messageInfo.GetSockAddr())) > 0) + else if ((interfaceId = mRoutes.Lookup(aMessageInfo.GetPeerAddr(), aMessageInfo.GetSockAddr())) > 0) { // route ; diff --git a/src/core/net/ip6.hpp b/src/core/net/ip6.hpp index 17c416a92..20f529bd2 100644 --- a/src/core/net/ip6.hpp +++ b/src/core/net/ip6.hpp @@ -369,17 +369,17 @@ private: void HandleSendQueue(void); ThreadError ProcessReceiveCallback(const Message &aMessage, const MessageInfo &aMessageInfo, uint8_t aIpProto, - bool fromLocalHost); - ThreadError HandleExtensionHeaders(Message &message, Header &header, uint8_t &nextHeader, bool forward, - bool receive); - ThreadError HandleFragment(Message &message); - ThreadError AddMplOption(Message &message, Header &header); - ThreadError AddTunneledMplOption(Message &message, Header &header, MessageInfo &messageInfo); - ThreadError InsertMplOption(Message &message, Header &header, MessageInfo &messageInfo); + bool aFromNcpHost); + ThreadError HandleExtensionHeaders(Message &aMessage, Header &aHeader, uint8_t &aNextHeader, bool aForward, + bool aReceive); + ThreadError HandleFragment(Message &aMessage); + ThreadError AddMplOption(Message &aMessage, Header &aHeader); + ThreadError AddTunneledMplOption(Message &aMessage, Header &aHeader, MessageInfo &aMessageInfo); + ThreadError InsertMplOption(Message &aMessage, Header &aHeader, MessageInfo &aMessageInfo); ThreadError RemoveMplOption(Message &aMessage); - ThreadError HandleOptions(Message &message, Header &header, bool &forward); - ThreadError HandlePayload(Message &message, MessageInfo &messageInfo, uint8_t ipproto); - int8_t FindForwardInterfaceId(const MessageInfo &messageInfo); + ThreadError HandleOptions(Message &aMessage, Header &aHeader, bool &aForward); + ThreadError HandlePayload(Message &aMessage, MessageInfo &aMessageInfo, uint8_t aIpProto); + int8_t FindForwardInterfaceId(const MessageInfo &aMessageInfo); bool mForwardingEnabled;