src/test-apps/TestInetLayerCommon.cpp - third_party/openweave-core - Git at Google

 /*
  *
  *    Copyright (c) 2019 Google LLC
  *    All rights reserved.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 /**
  *    @file
  *      This file defines common preprocessor defintions, constants,
  *      functions, and globals for unit and functional tests for the
  *      Inet layer.
  *
  */

 #include "TestInetLayerCommon.hpp"

 #include <stdlib.h>
 #include <string.h>

 #include <nlbyteorder.hpp>

 #include <InetLayer/InetLayer.h>

 #include <Weave/Support/CodeUtils.h>

 #include "ToolCommon.h"

 using namespace ::nl::Inet;
 using namespace ::nl::Weave::System;


 // Type Definitions

 struct ICMPEchoHeader {
     uint8_t  mType;
     uint8_t  mCode;
     uint16_t mChecksum;
     uint16_t mID;
     uint16_t mSequenceNumber;
 } __attribute__((packed));

 typedef struct ICMPEchoHeader ICMPv4EchoHeader;
 typedef struct ICMPEchoHeader ICMPv6EchoHeader;


 // Global Variables

 static const uint8_t     kICMPv4_EchoRequest   = 8;
 static const uint8_t     kICMPv4_EchoReply     = 0;

 static const uint8_t     kICMPv6_EchoRequest   = 128;
 static const uint8_t     kICMPv6_EchoReply     = 129;

 const uint8_t            gICMPv4Types[kICMPv4_FilterTypes] =
 {
     kICMPv4_EchoRequest,
     kICMPv4_EchoReply
 };

 const uint8_t            gICMPv6Types[kICMPv6_FilterTypes] =
 {
     kICMPv6_EchoRequest,
     kICMPv6_EchoReply
 };

 bool                     gSendIntervalExpired  = true;

 uint32_t                 gSendIntervalMs       = 1000;

 const char *             gInterfaceName        = NULL;

 InterfaceId              gInterfaceId          = INET_NULL_INTERFACEID;

 uint16_t                 gSendSize             = 59;

 uint32_t                 gOptFlags             = 0;


 namespace Common
 {

 bool IsReceiver(void)
 {
     return ((gOptFlags & kOptFlagListen) == kOptFlagListen);
 }

 bool IsSender(void)
 {
     return (!IsReceiver());
 }

 bool IsTesting(const TestStatus &aTestStatus)
 {
     bool lStatus;

     lStatus = (!aTestStatus.mFailed && !aTestStatus.mSucceeded);

     return (lStatus);
 }

 bool WasSuccessful(const TestStatus &aTestStatus)
 {
     bool lStatus = false;

     if (aTestStatus.mFailed)
         lStatus = false;
     else if (aTestStatus.mSucceeded)
         lStatus = true;

     return (lStatus);
 }

 static void FillDataBufferPattern(uint8_t *aBuffer, uint16_t aLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
 {
     for (uint16_t i = aPatternStartOffset; i < aLength; i++)
     {
         const uint8_t lValue = static_cast<uint8_t>(aFirstValue & 0xFF);

         aBuffer[i] = lValue;

         aFirstValue++;
     }
 }

 static bool CheckDataBufferPattern(const uint8_t *aBuffer, uint16_t aLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
 {
     bool lStatus = true;

     for (uint16_t i = aPatternStartOffset; i < aLength; i++)
     {
         const uint8_t lValue = aBuffer[i];

         VerifyOrExit(lValue == static_cast<uint8_t>(aFirstValue),
                      printf("Bad data value at offset %u (0x%04x): "
                             "expected 0x%02x, found 0x%02x\n",
                             i, i, aFirstValue, lValue);
                      lStatus = false;
                      DumpMemory(aBuffer + aPatternStartOffset,
                                 aLength - aPatternStartOffset,
                                 "0x",
                                 16));

         aFirstValue++;
     }

 exit:
     return (lStatus);
 }

 static PacketBuffer *MakeDataBuffer(uint16_t aDesiredLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
 {
     PacketBuffer *  lBuffer = NULL;

     VerifyOrExit(aPatternStartOffset <= aDesiredLength, );

     lBuffer = PacketBuffer::New();
     VerifyOrExit(lBuffer != NULL, );

     aDesiredLength = min(lBuffer->MaxDataLength(), aDesiredLength);

     FillDataBufferPattern(lBuffer->Start(), aDesiredLength, aPatternStartOffset, aFirstValue);

     lBuffer->SetDataLength(aDesiredLength);

 exit:
     return (lBuffer);
 }

 static PacketBuffer *MakeDataBuffer(uint16_t aDesiredLength, uint16_t aPatternStartOffset)
 {
     const uint8_t   lFirstValue = 0;
     PacketBuffer *  lBuffer = NULL;

     lBuffer = MakeDataBuffer(aDesiredLength, aPatternStartOffset, lFirstValue);
     VerifyOrExit(lBuffer != NULL, );

 exit:
     return (lBuffer);
 }

 template <typename tType>
 static PacketBuffer *MakeICMPDataBuffer(uint16_t aDesiredUserLength, uint16_t aHeaderLength, uint16_t aPatternStartOffset, uint8_t aType)
 {
     static uint16_t  lSequenceNumber = 0;
     PacketBuffer *   lBuffer = NULL;

     // To ensure there is enough room for the user data and the ICMP
     // header, include both the user data size and the ICMP header length.

     lBuffer = MakeDataBuffer(aDesiredUserLength + aHeaderLength, aPatternStartOffset);

     if (lBuffer != NULL)
     {
         tType *lHeader = reinterpret_cast<tType *>(lBuffer->Start());

         lHeader->mType           = aType;
         lHeader->mCode           = 0;
         lHeader->mChecksum       = 0;
         lHeader->mID             = rand() & UINT16_MAX;
         lHeader->mSequenceNumber = nlByteOrderSwap16HostToBig(lSequenceNumber++);
     }

     return (lBuffer);
 }

 PacketBuffer *MakeICMPv4DataBuffer(uint16_t aDesiredUserLength)
 {
     const uint16_t  lICMPHeaderLength = sizeof (ICMPv4EchoHeader);
     const uint16_t  lPatternStartOffset = lICMPHeaderLength;
     const uint8_t   lType = gICMPv4Types[kICMP_EchoRequestIndex];
     PacketBuffer *  lBuffer = NULL;

     lBuffer = MakeICMPDataBuffer<ICMPv4EchoHeader>(aDesiredUserLength, lICMPHeaderLength, lPatternStartOffset, lType);

     return (lBuffer);
 }

 PacketBuffer *MakeICMPv6DataBuffer(uint16_t aDesiredUserLength)
 {
     const uint16_t  lICMPHeaderLength = sizeof (ICMPv6EchoHeader);
     const uint16_t  lPatternStartOffset = lICMPHeaderLength;
     const uint8_t   lType = gICMPv6Types[kICMP_EchoRequestIndex];
     PacketBuffer *  lBuffer = NULL;

     lBuffer = MakeICMPDataBuffer<ICMPv6EchoHeader>(aDesiredUserLength, lICMPHeaderLength, lPatternStartOffset, lType);

     return (lBuffer);
 }

 PacketBuffer *MakeDataBuffer(uint16_t aDesiredLength, uint8_t aFirstValue)
 {
     const uint16_t  lPatternStartOffset = 0;
     PacketBuffer *  lBuffer = NULL;

     lBuffer = MakeDataBuffer(aDesiredLength, lPatternStartOffset, aFirstValue);

     return (lBuffer);
 }

 PacketBuffer *MakeDataBuffer(uint16_t aDesiredLength)
 {
     const uint16_t  lPatternStartOffset = 0;
     PacketBuffer *  lBuffer = NULL;

     lBuffer = MakeDataBuffer(aDesiredLength, lPatternStartOffset);

     return (lBuffer);
 }

 static bool HandleDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer, uint16_t aPatternStartOffset, uint8_t aFirstValue)
 {
     bool      lStatus = true;
     uint16_t  lTotalDataLength = 0;

     // Walk through each buffer in the packet chain, checking the
     // buffer for the expected pattern, if requested.

     for (const PacketBuffer *lBuffer = aBuffer; lBuffer != NULL; lBuffer = lBuffer->Next())
     {
         const uint16_t lDataLength = lBuffer->DataLength();

         if (aCheckBuffer)
         {
             const uint8_t *p = lBuffer->Start();

             lStatus = CheckDataBufferPattern(p, lDataLength, aPatternStartOffset, aFirstValue);
             VerifyOrExit(lStatus == true, );
         }

         lTotalDataLength += lBuffer->DataLength();
         aFirstValue += lBuffer->DataLength();
     }

     // If we are accumulating stats by packet rather than by size,
     // then increment by one (1) rather than the total buffer length.

     aStats.mReceive.mActual += ((aStatsByPacket) ? 1 : lTotalDataLength);

 exit:
     return (lStatus);

 }

 static bool HandleICMPDataReceived(PacketBuffer *aBuffer, uint16_t aHeaderLength, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
 {
     const uint16_t  lPatternStartOffset = 0;
     bool            lStatus;

     aBuffer->ConsumeHead(aHeaderLength);

     lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer, lPatternStartOffset);

     return (lStatus);
 }

 bool HandleICMPv4DataReceived(PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
 {
     const uint16_t  lICMPHeaderLength = sizeof (ICMPv4EchoHeader);
     bool            lStatus;

     lStatus = HandleICMPDataReceived(aBuffer, lICMPHeaderLength, aStats, aStatsByPacket, aCheckBuffer);

     return (lStatus);
 }

 bool HandleICMPv6DataReceived(PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
 {
     const uint16_t  lICMPHeaderLength = sizeof (ICMPv6EchoHeader);
     bool            lStatus;

     lStatus = HandleICMPDataReceived(aBuffer, lICMPHeaderLength, aStats, aStatsByPacket, aCheckBuffer);

     return (lStatus);
 }

 bool HandleDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer, uint8_t aFirstValue)
 {
     const uint16_t  lPatternStartOffset = 0;
     bool            lStatus;

     lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer, lPatternStartOffset, aFirstValue);

     return (lStatus);
 }


 bool HandleDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
 {
     const uint8_t   lFirstValue = 0;
     const uint16_t  lPatternStartOffset = 0;
     bool            lStatus;

     lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer, lPatternStartOffset, lFirstValue);

     return (lStatus);
 }

 bool HandleUDPDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
 {
     bool            lStatus;

     lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer);

     return (lStatus);
 }

 bool HandleTCPDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
 {
     bool            lStatus;

     lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer);

     return (lStatus);
 }

 // Timer Callback Handler

 void HandleSendTimerComplete(System::Layer *aSystemLayer, void *aAppState, System::Error aError)
 {
     FAIL_ERROR(aError, "Send timer completed with error");

     gSendIntervalExpired = true;

     DriveSend();
 }

 // Raw Endpoint Callback Handlers

 void HandleRawMessageReceived(const IPEndPointBasis *aEndPoint, const PacketBuffer *aBuffer, const IPPacketInfo *aPacketInfo)
 {
     char  lSourceAddressBuffer[INET6_ADDRSTRLEN];
     char  lDestinationAddressBuffer[INET6_ADDRSTRLEN];

     aPacketInfo->SrcAddress.ToString(lSourceAddressBuffer, sizeof (lSourceAddressBuffer));
     aPacketInfo->DestAddress.ToString(lDestinationAddressBuffer, sizeof (lDestinationAddressBuffer));

     printf("Raw message received from %s to %s (%zu bytes)\n",
            lSourceAddressBuffer,
            lDestinationAddressBuffer,
            static_cast<size_t>(aBuffer->DataLength()));
 }

 void HandleRawReceiveError(const IPEndPointBasis *aEndPoint, const INET_ERROR &aError, const IPPacketInfo *aPacketInfo)
 {
     char     lAddressBuffer[INET6_ADDRSTRLEN];

     if (aPacketInfo != NULL)
     {
         aPacketInfo->SrcAddress.ToString(lAddressBuffer, sizeof (lAddressBuffer));
     }
     else
     {
         strcpy(lAddressBuffer, "(unknown)");
     }

     printf("IP receive error from %s %s\n", lAddressBuffer, ErrorStr(aError));
 }

 // UDP Endpoint Callback Handlers

 void HandleUDPMessageReceived(const IPEndPointBasis *aEndPoint, const PacketBuffer *aBuffer, const IPPacketInfo *aPacketInfo)
 {
     char  lSourceAddressBuffer[INET6_ADDRSTRLEN];
     char  lDestinationAddressBuffer[INET6_ADDRSTRLEN];

     aPacketInfo->SrcAddress.ToString(lSourceAddressBuffer, sizeof (lSourceAddressBuffer));
     aPacketInfo->DestAddress.ToString(lDestinationAddressBuffer, sizeof (lDestinationAddressBuffer));

     printf("UDP packet received from %s:%u to %s:%u (%zu bytes)\n",
            lSourceAddressBuffer, aPacketInfo->SrcPort,
            lDestinationAddressBuffer, aPacketInfo->DestPort,
            static_cast<size_t>(aBuffer->DataLength()));
 }

 void HandleUDPReceiveError(const IPEndPointBasis *aEndPoint, const INET_ERROR &aError, const IPPacketInfo *aPacketInfo)
 {
     char     lAddressBuffer[INET6_ADDRSTRLEN];
     uint16_t lSourcePort;

     if (aPacketInfo != NULL)
     {
         aPacketInfo->SrcAddress.ToString(lAddressBuffer, sizeof (lAddressBuffer));
         lSourcePort = aPacketInfo->SrcPort;
     }
     else
     {
         strcpy(lAddressBuffer, "(unknown)");
         lSourcePort = 0;
     }

     printf("UDP receive error from %s:%u: %s\n", lAddressBuffer, lSourcePort, ErrorStr(aError));
 }

 }; // namespace Common
	/*
	*
	* Copyright (c) 2019 Google LLC
	* All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @file
	* This file defines common preprocessor defintions, constants,
	* functions, and globals for unit and functional tests for the
	* Inet layer.
	*
	*/

	#include "TestInetLayerCommon.hpp"

	#include <stdlib.h>
	#include <string.h>

	#include <nlbyteorder.hpp>

	#include <InetLayer/InetLayer.h>

	#include <Weave/Support/CodeUtils.h>

	#include "ToolCommon.h"

	using namespace ::nl::Inet;
	using namespace ::nl::Weave::System;


	// Type Definitions

	struct ICMPEchoHeader {
	uint8_t mType;
	uint8_t mCode;
	uint16_t mChecksum;
	uint16_t mID;
	uint16_t mSequenceNumber;
	} __attribute__((packed));

	typedef struct ICMPEchoHeader ICMPv4EchoHeader;
	typedef struct ICMPEchoHeader ICMPv6EchoHeader;


	// Global Variables

	static const uint8_t kICMPv4_EchoRequest = 8;
	static const uint8_t kICMPv4_EchoReply = 0;

	static const uint8_t kICMPv6_EchoRequest = 128;
	static const uint8_t kICMPv6_EchoReply = 129;

	const uint8_t gICMPv4Types[kICMPv4_FilterTypes] =
	{
	kICMPv4_EchoRequest,
	kICMPv4_EchoReply
	};

	const uint8_t gICMPv6Types[kICMPv6_FilterTypes] =
	{
	kICMPv6_EchoRequest,
	kICMPv6_EchoReply
	};

	bool gSendIntervalExpired = true;

	uint32_t gSendIntervalMs = 1000;

	const char * gInterfaceName = NULL;

	InterfaceId gInterfaceId = INET_NULL_INTERFACEID;

	uint16_t gSendSize = 59;

	uint32_t gOptFlags = 0;


	namespace Common
	{

	bool IsReceiver(void)
	{
	return ((gOptFlags & kOptFlagListen) == kOptFlagListen);
	}

	bool IsSender(void)
	{
	return (!IsReceiver());
	}

	bool IsTesting(const TestStatus &aTestStatus)
	{
	bool lStatus;

	lStatus = (!aTestStatus.mFailed && !aTestStatus.mSucceeded);

	return (lStatus);
	}

	bool WasSuccessful(const TestStatus &aTestStatus)
	{
	bool lStatus = false;

	if (aTestStatus.mFailed)
	lStatus = false;
	else if (aTestStatus.mSucceeded)
	lStatus = true;

	return (lStatus);
	}

	static void FillDataBufferPattern(uint8_t *aBuffer, uint16_t aLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
	{
	for (uint16_t i = aPatternStartOffset; i < aLength; i++)
	{
	const uint8_t lValue = static_cast<uint8_t>(aFirstValue & 0xFF);

	aBuffer[i] = lValue;

	aFirstValue++;
	}
	}

	static bool CheckDataBufferPattern(const uint8_t *aBuffer, uint16_t aLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
	{
	bool lStatus = true;

	for (uint16_t i = aPatternStartOffset; i < aLength; i++)
	{
	const uint8_t lValue = aBuffer[i];

	VerifyOrExit(lValue == static_cast<uint8_t>(aFirstValue),
	printf("Bad data value at offset %u (0x%04x): "
	"expected 0x%02x, found 0x%02x\n",
	i, i, aFirstValue, lValue);
	lStatus = false;
	DumpMemory(aBuffer + aPatternStartOffset,
	aLength - aPatternStartOffset,
	"0x",
	16));

	aFirstValue++;
	}

	exit:
	return (lStatus);
	}

	static PacketBuffer *MakeDataBuffer(uint16_t aDesiredLength, uint16_t aPatternStartOffset, uint8_t aFirstValue)
	{
	PacketBuffer * lBuffer = NULL;

	VerifyOrExit(aPatternStartOffset <= aDesiredLength, );

	lBuffer = PacketBuffer::New();
	VerifyOrExit(lBuffer != NULL, );

	aDesiredLength = min(lBuffer->MaxDataLength(), aDesiredLength);

	FillDataBufferPattern(lBuffer->Start(), aDesiredLength, aPatternStartOffset, aFirstValue);

	lBuffer->SetDataLength(aDesiredLength);

	exit:
	return (lBuffer);
	}

	static PacketBuffer *MakeDataBuffer(uint16_t aDesiredLength, uint16_t aPatternStartOffset)
	{
	const uint8_t lFirstValue = 0;
	PacketBuffer * lBuffer = NULL;

	lBuffer = MakeDataBuffer(aDesiredLength, aPatternStartOffset, lFirstValue);
	VerifyOrExit(lBuffer != NULL, );

	exit:
	return (lBuffer);
	}

	template <typename tType>
	static PacketBuffer *MakeICMPDataBuffer(uint16_t aDesiredUserLength, uint16_t aHeaderLength, uint16_t aPatternStartOffset, uint8_t aType)
	{
	static uint16_t lSequenceNumber = 0;
	PacketBuffer * lBuffer = NULL;

	// To ensure there is enough room for the user data and the ICMP
	// header, include both the user data size and the ICMP header length.

	lBuffer = MakeDataBuffer(aDesiredUserLength + aHeaderLength, aPatternStartOffset);

	if (lBuffer != NULL)
	{
	tType lHeader = reinterpret_cast<tType >(lBuffer->Start());

	lHeader->mType = aType;
	lHeader->mCode = 0;
	lHeader->mChecksum = 0;
	lHeader->mID = rand() & UINT16_MAX;
	lHeader->mSequenceNumber = nlByteOrderSwap16HostToBig(lSequenceNumber++);
	}

	return (lBuffer);
	}

	PacketBuffer *MakeICMPv4DataBuffer(uint16_t aDesiredUserLength)
	{
	const uint16_t lICMPHeaderLength = sizeof (ICMPv4EchoHeader);
	const uint16_t lPatternStartOffset = lICMPHeaderLength;
	const uint8_t lType = gICMPv4Types[kICMP_EchoRequestIndex];
	PacketBuffer * lBuffer = NULL;

	lBuffer = MakeICMPDataBuffer<ICMPv4EchoHeader>(aDesiredUserLength, lICMPHeaderLength, lPatternStartOffset, lType);

	return (lBuffer);
	}

	PacketBuffer *MakeICMPv6DataBuffer(uint16_t aDesiredUserLength)
	{
	const uint16_t lICMPHeaderLength = sizeof (ICMPv6EchoHeader);
	const uint16_t lPatternStartOffset = lICMPHeaderLength;
	const uint8_t lType = gICMPv6Types[kICMP_EchoRequestIndex];
	PacketBuffer * lBuffer = NULL;

	lBuffer = MakeICMPDataBuffer<ICMPv6EchoHeader>(aDesiredUserLength, lICMPHeaderLength, lPatternStartOffset, lType);

	return (lBuffer);
	}

	PacketBuffer *MakeDataBuffer(uint16_t aDesiredLength, uint8_t aFirstValue)
	{
	const uint16_t lPatternStartOffset = 0;
	PacketBuffer * lBuffer = NULL;

	lBuffer = MakeDataBuffer(aDesiredLength, lPatternStartOffset, aFirstValue);

	return (lBuffer);
	}

	PacketBuffer *MakeDataBuffer(uint16_t aDesiredLength)
	{
	const uint16_t lPatternStartOffset = 0;
	PacketBuffer * lBuffer = NULL;

	lBuffer = MakeDataBuffer(aDesiredLength, lPatternStartOffset);

	return (lBuffer);
	}

	static bool HandleDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer, uint16_t aPatternStartOffset, uint8_t aFirstValue)
	{
	bool lStatus = true;
	uint16_t lTotalDataLength = 0;

	// Walk through each buffer in the packet chain, checking the
	// buffer for the expected pattern, if requested.

	for (const PacketBuffer *lBuffer = aBuffer; lBuffer != NULL; lBuffer = lBuffer->Next())
	{
	const uint16_t lDataLength = lBuffer->DataLength();

	if (aCheckBuffer)
	{
	const uint8_t *p = lBuffer->Start();

	lStatus = CheckDataBufferPattern(p, lDataLength, aPatternStartOffset, aFirstValue);
	VerifyOrExit(lStatus == true, );
	}

	lTotalDataLength += lBuffer->DataLength();
	aFirstValue += lBuffer->DataLength();
	}

	// If we are accumulating stats by packet rather than by size,
	// then increment by one (1) rather than the total buffer length.

	aStats.mReceive.mActual += ((aStatsByPacket) ? 1 : lTotalDataLength);

	exit:
	return (lStatus);

	}

	static bool HandleICMPDataReceived(PacketBuffer *aBuffer, uint16_t aHeaderLength, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
	{
	const uint16_t lPatternStartOffset = 0;
	bool lStatus;

	aBuffer->ConsumeHead(aHeaderLength);

	lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer, lPatternStartOffset);

	return (lStatus);
	}

	bool HandleICMPv4DataReceived(PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
	{
	const uint16_t lICMPHeaderLength = sizeof (ICMPv4EchoHeader);
	bool lStatus;

	lStatus = HandleICMPDataReceived(aBuffer, lICMPHeaderLength, aStats, aStatsByPacket, aCheckBuffer);

	return (lStatus);
	}

	bool HandleICMPv6DataReceived(PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
	{
	const uint16_t lICMPHeaderLength = sizeof (ICMPv6EchoHeader);
	bool lStatus;

	lStatus = HandleICMPDataReceived(aBuffer, lICMPHeaderLength, aStats, aStatsByPacket, aCheckBuffer);

	return (lStatus);
	}

	bool HandleDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer, uint8_t aFirstValue)
	{
	const uint16_t lPatternStartOffset = 0;
	bool lStatus;

	lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer, lPatternStartOffset, aFirstValue);

	return (lStatus);
	}


	bool HandleDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
	{
	const uint8_t lFirstValue = 0;
	const uint16_t lPatternStartOffset = 0;
	bool lStatus;

	lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer, lPatternStartOffset, lFirstValue);

	return (lStatus);
	}

	bool HandleUDPDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
	{
	bool lStatus;

	lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer);

	return (lStatus);
	}

	bool HandleTCPDataReceived(const PacketBuffer *aBuffer, TransferStats &aStats, bool aStatsByPacket, bool aCheckBuffer)
	{
	bool lStatus;

	lStatus = HandleDataReceived(aBuffer, aStats, aStatsByPacket, aCheckBuffer);

	return (lStatus);
	}

	// Timer Callback Handler

	void HandleSendTimerComplete(System::Layer aSystemLayer, void aAppState, System::Error aError)
	{
	FAIL_ERROR(aError, "Send timer completed with error");

	gSendIntervalExpired = true;

	DriveSend();
	}

	// Raw Endpoint Callback Handlers

	void HandleRawMessageReceived(const IPEndPointBasis aEndPoint, const PacketBuffer aBuffer, const IPPacketInfo *aPacketInfo)
	{
	char lSourceAddressBuffer[INET6_ADDRSTRLEN];
	char lDestinationAddressBuffer[INET6_ADDRSTRLEN];

	aPacketInfo->SrcAddress.ToString(lSourceAddressBuffer, sizeof (lSourceAddressBuffer));
	aPacketInfo->DestAddress.ToString(lDestinationAddressBuffer, sizeof (lDestinationAddressBuffer));

	printf("Raw message received from %s to %s (%zu bytes)\n",
	lSourceAddressBuffer,
	lDestinationAddressBuffer,
	static_cast<size_t>(aBuffer->DataLength()));
	}

	void HandleRawReceiveError(const IPEndPointBasis aEndPoint, const INET_ERROR &aError, const IPPacketInfo aPacketInfo)
	{
	char lAddressBuffer[INET6_ADDRSTRLEN];

	if (aPacketInfo != NULL)
	{
	aPacketInfo->SrcAddress.ToString(lAddressBuffer, sizeof (lAddressBuffer));
	}
	else
	{
	strcpy(lAddressBuffer, "(unknown)");
	}

	printf("IP receive error from %s %s\n", lAddressBuffer, ErrorStr(aError));
	}

	// UDP Endpoint Callback Handlers

	void HandleUDPMessageReceived(const IPEndPointBasis aEndPoint, const PacketBuffer aBuffer, const IPPacketInfo *aPacketInfo)
	{
	char lSourceAddressBuffer[INET6_ADDRSTRLEN];
	char lDestinationAddressBuffer[INET6_ADDRSTRLEN];

	aPacketInfo->SrcAddress.ToString(lSourceAddressBuffer, sizeof (lSourceAddressBuffer));
	aPacketInfo->DestAddress.ToString(lDestinationAddressBuffer, sizeof (lDestinationAddressBuffer));

	printf("UDP packet received from %s:%u to %s:%u (%zu bytes)\n",
	lSourceAddressBuffer, aPacketInfo->SrcPort,
	lDestinationAddressBuffer, aPacketInfo->DestPort,
	static_cast<size_t>(aBuffer->DataLength()));
	}

	void HandleUDPReceiveError(const IPEndPointBasis aEndPoint, const INET_ERROR &aError, const IPPacketInfo aPacketInfo)
	{
	char lAddressBuffer[INET6_ADDRSTRLEN];
	uint16_t lSourcePort;

	if (aPacketInfo != NULL)
	{
	aPacketInfo->SrcAddress.ToString(lAddressBuffer, sizeof (lAddressBuffer));
	lSourcePort = aPacketInfo->SrcPort;
	}
	else
	{
	strcpy(lAddressBuffer, "(unknown)");
	lSourcePort = 0;
	}

	printf("UDP receive error from %s:%u: %s\n", lAddressBuffer, lSourcePort, ErrorStr(aError));
	}

	}; // namespace Common