espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-10-14 19:57:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

sync parameter names in ip6.cpp with ip6.hpp (#1755)

Browse Source
This commit is contained in:
Buke Po
2017-05-10 17:57:35 -07:00
committed by Jonathan Hui
parent 9f3ee5cd52
commit 1ece777a82
2 changed files with 135 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/core/net/ip6.cpp
+125 -125
View File
@@ -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<const uint8_t *>(buf);
const uint8_t *bytes = reinterpret_cast<const uint8_t *>(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<uint16_t>(bytes[i] << 8));
aChecksum = Ip6::UpdateChecksum(aChecksum, (i & 1) ? bytes[i] : static_cast<uint16_t>(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<uint16_t>(proto));
checksum = UpdateChecksum(checksum, src);
checksum = UpdateChecksum(checksum, dst);
checksum = Ip6::UpdateChecksum(0, aLength);
checksum = Ip6::UpdateChecksum(checksum, static_cast<uint16_t>(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<uint8_t>(kDefaultHopLimit));
header.SetNextHeader(aIpProto);
header.SetHopLimit(aMessageInfo.mHopLimit ? aMessageInfo.mHopLimit : static_cast<uint8_t>(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<uint8_t>(extHeader.GetNextHeader());
aNextHeader = static_cast<uint8_t>(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<uint8_t>(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
;
src/core/net/ip6.hpp
+10 -10
View File
@@ -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;