//-------------------------------------------------------------------------------
//
// Procedure: GetTablePtr64 - Find ACPI table in XSDT with input signature.
//
//-------------------------------------------------------------------------------
static ACPI_TABLE_HEADER *GetTablePtr64(ACPI_TABLE_XSDT * xsdt, U32 signature)
{
U32 index;
U32 num_tables;
int method;
// Compute number of table pointers included in XSDT
num_tables = get_num_tables64(xsdt);
getIntForKey(kAcpiMethod, &method, DEFAULT_BOOT_CONFIG);
switch (method) {
case 0x2:
{
for (index = 0; index < num_tables; index++)
{
U64 ptr = xsdt->TableOffsetEntry[index];
if (!ptr) continue;
if ((*(U32 *) ((ACPI_TABLE_HEADER *) (unsigned long)ptr)->Signature == signature) &&
(GetChecksum(((ACPI_TABLE_HEADER *) (unsigned long)ptr), ((ACPI_TABLE_HEADER *) (unsigned long)ptr)->Length) == 0))
{
return (((ACPI_TABLE_HEADER *) (unsigned long)ptr));
}
}
break;
}
case 0x1:
default:
{
ACPI_TABLE_HEADER *table = (ACPI_TABLE_HEADER *) xsdt->TableOffsetEntry;
for (index = 0; index < num_tables; index++)
{
if (!table) continue;
if (((U32) (table->Signature) == signature) &&
(GetChecksum(table, table->Length) == 0))
{
return (table);
}
// Move array pointer to next 64-bit pointer
table = (ACPI_TABLE_HEADER *) ((U32) table + sizeof(U64));
}
break;
}
}
return (0);
}
//-------------------------------------------------------------------------------
//
// Procedure: GetRsdtPointer - Scans given segment for RSDT pointer
//
// Description: Scans for root system description table pointer signature
// ('RSD PTR ') , verifies checksum, and returns pointer to
// RSDT table if found.
//
//-------------------------------------------------------------------------------
static U32 GetRsdtPointer(void *mem_addr, U32 mem_size, ACPI_TABLES * acpi_tables)
{
U8 *current = mem_addr;
U8 *end = current + mem_size;
// Quick sanity check for a valid start address
if (current == 0ul)
return (0ul);
for (; current < end; current += 16)
{
if (!current) continue;
if (*(volatile U64 *)current == NAMESEG64("RSD PTR "))
{
if (GetChecksum(current, ACPI_RSDP_REV0_SIZE) == 0)
{
// RSD pointer structure checksum okay, lookup the RSDT pointer.
acpi_tables->RsdPointer = (ACPI_TABLE_RSDP *)current;
acpi_tables->RsdtPointer = (ACPI_TABLE_RSDT *) acpi_tables->RsdPointer->RsdtPhysicalAddress;
if ((acpi_tables->RsdPointer != (void*)0ul) && (acpi_tables->RsdtPointer != (void*)0ul))
return (1ul);
else
return (0ul);
}
}
}
return (0);
}
std::string naMD5Checksum::GetChecksumAsString_s()
{
uint8_t aChecksum[16];
char szText[32+1];
GetChecksum( aChecksum );
for( int i=0; i < 16; i++ ) {
sprintf( szText + (i*2), "%02X", aChecksum[i] );
}
return szText;
}
void LeyboldGraphixThree::SendCommand(std::string& command) const
{
command += " ";
char crc = GetChecksum(command);
command += crc;
command += EOT;
// std::cout << command.length() << " |" << command.c_str() << "|";
comHandler_->SendCommand(command.c_str());
}
e_KnxTelegramValidity KnxTelegram::GetValidity(void) const
{
if ((_controlField & CONTROL_FIELD_PATTERN_MASK) != CONTROL_FIELD_VALID_PATTERN) return KNX_TELEGRAM_INVALID_CONTROL_FIELD;
if ((_controlField & CONTROL_FIELD_FRAME_FORMAT_MASK) != CONTROL_FIELD_STANDARD_FRAME_FORMAT) return KNX_TELEGRAM_UNSUPPORTED_FRAME_FORMAT;
if (!GetPayloadLength()) return KNX_TELEGRAM_INCORRECT_PAYLOAD_LENGTH ;
if ((_commandH & COMMAND_FIELD_PATTERN_MASK) != COMMAND_FIELD_VALID_PATTERN) return KNX_TELEGRAM_INVALID_COMMAND_FIELD;
if ( GetChecksum() != CalculateChecksum()) return KNX_TELEGRAM_INCORRECT_CHECKSUM ;
byte cmd=GetCommand();
if ( (cmd!=KNX_COMMAND_VALUE_READ) && (cmd!=KNX_COMMAND_VALUE_RESPONSE)
&& (cmd!=KNX_COMMAND_VALUE_WRITE) && (cmd!=KNX_COMMAND_MEMORY_WRITE)) return KNX_TELEGRAM_UNKNOWN_COMMAND;
return KNX_TELEGRAM_VALID;
};
//-------------------------------------------------------------------------------
//
// Procedure: GetXsdtPointer
//
//-------------------------------------------------------------------------------
static U32 GetXsdtPointer(ACPI_TABLES * acpi_tables)
{
if ((GetChecksum(acpi_tables->RsdPointer, sizeof(ACPI_TABLE_RSDP)) == 0) &&
(acpi_tables->RsdPointer->Revision == 2) &&
(acpi_tables->RsdPointer->Length == sizeof(ACPI_TABLE_RSDP))) {
// RSD pointer structure checksum okay, lookup the XSDT pointer.
acpi_tables->XsdtPointer = (ACPI_TABLE_XSDT *) (U32) acpi_tables->RsdPointer->XsdtPhysicalAddress;
return (1ul);
}
return (0ul);
}
bool FileMonitor::Changed()
{
double elapsed = m_time.elapsed();
if(elapsed > FILEMONITOR_CHECK_INTERVAL)
{
m_time.restart();
int currentChecksum = GetChecksum();
if(m_checksum != currentChecksum)
{
m_checksum = currentChecksum;
return true;
}
}
return false;
}
void CommandSender::SendToRobot(Robot& p,unsigned char RobotID)
{
SetData(p);
GetChecksum();
buffer.Reset(RobotID,action);
// buffer.Display();
buffer.AddByte(vxh);
buffer.AddByte(vxl);
buffer.AddByte(vyh);
buffer.AddByte(vyl);
buffer.AddByte(vth);
buffer.AddByte(vtl);
buffer.AddByte(CheckSum);
buffer.AddByte(0xff-CheckSum);
// buffer.Display();
// buffer.AddEndPart();
// buffer.Display();
buffer.Send();
}
//-------------------------------------------------------------------------------
//
// Procedure: GetTablePtr - Find ACPI table in RSDT with input signature.
//
//-------------------------------------------------------------------------------
static ACPI_TABLE_HEADER *GetTablePtr(ACPI_TABLE_RSDT * rsdt, U32 signature)
{
U32 index;
U32 num_tables;
ACPI_TABLE_HEADER **table_array = (ACPI_TABLE_HEADER **) rsdt->TableOffsetEntry;
// Compute number of table pointers included in RSDT
num_tables = get_num_tables(rsdt);
for (index = 0; index < num_tables; index++)
{
if (!table_array[index]) continue;
if ((*(U32 *) (table_array[index]->Signature) == signature) &&
(GetChecksum(table_array[index], table_array[index]->Length) == 0))
{
return (table_array[index]);
}
}
return (0);
}
void FileMonitor::Monitor(const std::string& fileName)
{
m_fileName = fileName;
m_checksum = GetChecksum();
m_time.restart();
}
//-------------------------------------------------------------------------------
//
// Procedure: FindAcpiTables - Collects addresses for RSDP, RSDT, FADT, & DSDT.
//
// Description: Finds the differentiated system description table pointer
// by scanning and checking ACPI tables. This function will
// get and store the following ACPI Table Pointers:
// 1) RSD Pointer in RsdPointer Variable
// 2) RSDT Pointer in RsdtPointer Variable (RSDP->RSDT)
// 3) XSDT Pointer in XsdtPointer Variable (RSDP->XSDT)
// 4) FACP Pointer in FacpPointer Variable (RSDP->RSDT->FACP)
// 5) FACP(64) Pointer in FacpPointer64 Variable (RSDP->XSDT->FACP)
// 6) DSDT Pointer in DsdtPointer Variable (RSDP->RSDT->FACP->DSDT)
// 7) DSDT(64) Pointer in DsdtPointer64 Variable (RSDP->XSDT->FACP->XDSDT)
// 8) FACS Pointer in FacsPointer Variable (RSDP->RSDT->FACP->FACS)
// 9) FACS(64) Pointer in FacsPointer64 Variable (RSDP->XSDT->FACP->XFACS)
// A) MADT Pointer in FacsPointer Variable (RSDP->RSDT->APIC)
// B) MADT(64) Pointer in MadtPointer64 Variable (RSDP->XSDT->APIC)
//
//-------------------------------------------------------------------------------
U32 FindAcpiTables(ACPI_TABLES * acpi_tables)
{
U32 success = 0ul;
// Perform init of ACPI table pointers
{
void *null = 0ul;
acpi_tables->DsdtPointer = null;
acpi_tables->DsdtPointer64 = null;
acpi_tables->FacpPointer = null;
acpi_tables->FacsPointer = null;
acpi_tables->FacsPointer64 = null;
acpi_tables->RsdPointer = null;
acpi_tables->RsdtPointer = null;
acpi_tables->MadtPointer = null;
acpi_tables->MadtPointer64 = null;
acpi_tables->XsdtPointer = null;
acpi_tables->FacpPointer64 = null;
}
// Find the RSDT pointer by scanning EBDA/E000/F000 segments.
// Init memory address as EBDA and scan 1KB region
success = GetRsdtPointer((void *)(((U32) * (U16 *) 0x40E) << 4), 0x400, acpi_tables);
// Init memory address as E000 segment and scan 64KB region
if (!success)
success = GetRsdtPointer((void *)0x0E0000, 0x10000, acpi_tables);
// Init memory address as F000 segment and scan 64KB region
if (!success)
success = GetRsdtPointer((void *)0x0F0000, 0x10000, acpi_tables);
if (!success || (acpi_tables->RsdtPointer == 0ul))
return (0ul);
success = GetXsdtPointer(acpi_tables);
// Find FACP table pointer which is one of table pointers in the RDST
acpi_tables->FacpPointer = (ACPI_TABLE_FADT *)
GetTablePtr(acpi_tables->RsdtPointer, NAMESEG("FACP"));
if (acpi_tables->FacpPointer == 0ul)
return (0ul);
// Find the DSDT which is included in the FACP table
acpi_tables->DsdtPointer = (ACPI_TABLE_DSDT *) acpi_tables->FacpPointer->Dsdt;
if ((acpi_tables->DsdtPointer == 0ul) || (*(U32 *) (acpi_tables->DsdtPointer->Header.Signature) != NAMESEG("DSDT")) ||
(GetChecksum(acpi_tables->DsdtPointer, acpi_tables->DsdtPointer->Header.Length) != 0))
return (0ul);
// Find the FACS which is included in the FACP table
acpi_tables->FacsPointer = (ACPI_TABLE_FACS *) acpi_tables->FacpPointer->Facs;
if ((acpi_tables->FacsPointer == 0ul) || (*(U32 *) (acpi_tables->FacsPointer->Signature) != NAMESEG("FACS")))
return (0ul);
// Find the MADT table which is one of the table pointers in the RSDT
acpi_tables->MadtPointer = (ACPI_TABLE_MADT *) GetTablePtr(acpi_tables->RsdtPointer, NAMESEG("APIC"));
if (acpi_tables->MadtPointer == 0ul)
return (0ul);
do {
if (!success || (acpi_tables->XsdtPointer == 0ul))
break;
// Find FACP(64) table pointer which is one of table pointers in the XDST
acpi_tables->FacpPointer64 = (ACPI_TABLE_FADT *)
GetTablePtr64(acpi_tables->XsdtPointer, NAMESEG("FACP"));
if (acpi_tables->FacpPointer64 == 0ul)
break;
// Find the XDSDT which is included in the FACP(64) table
ACPI_TABLE_DSDT *DsdtPointer64 = (ACPI_TABLE_DSDT *)((U32)acpi_tables->FacpPointer64->XDsdt);
if (DsdtPointer64 == 0ul)
break;
if ((*(U32*) (DsdtPointer64->Header.Signature) == NAMESEG("DSDT")) &&
(GetChecksum(DsdtPointer64, DsdtPointer64->Header.Length) == 0))
acpi_tables->DsdtPointer64 = (ACPI_TABLE_DSDT *) DsdtPointer64;
// Find the XFACS which is included in the FACP(64) table
ACPI_TABLE_FACS *FacsPointer64 = (ACPI_TABLE_FACS *)((U32)acpi_tables->FacpPointer64->XFacs);
if (FacsPointer64 == 0ul)
break;
if (*(U32*) (FacsPointer64->Signature) == NAMESEG("FACS"))
acpi_tables->FacsPointer64 = (ACPI_TABLE_FACS *) FacsPointer64;
// Find the MADT(64) table which is one of the table pointers in the XSDT
acpi_tables->MadtPointer64 = (ACPI_TABLE_MADT *) GetTablePtr64(acpi_tables->XsdtPointer, NAMESEG("APIC"));
} while (0);
return (1ul);
}
//Network Layer(Internet Protocol/IP) process
bool __fastcall CaptureNetworkLayer(const char *Buffer, const size_t Length, const uint16_t Protocol)
{
//Initialization
PDNS_SERVER_DATA PacketSource = nullptr;
//IPv6
if (Protocol == PPP_IPV6 || Protocol == OSI_L2_IPV6)
{
auto IPv6_Header = (pipv6_hdr)Buffer;
//Validate IPv6 header length.
if (ntohs(IPv6_Header->PayloadLength) > Length - sizeof(ipv6_hdr))
return false;
//Mark source of packet.
if (memcmp(&IPv6_Header->Source, &Parameter.DNSTarget.IPv6.AddressData.IPv6.sin6_addr, sizeof(in6_addr)) == EXIT_SUCCESS)
{
PacketSource = &Parameter.DNSTarget.IPv6;
}
else if (memcmp(&IPv6_Header->Source, &Parameter.DNSTarget.Alternate_IPv6.AddressData.IPv6.sin6_addr, sizeof(in6_addr)) == EXIT_SUCCESS)
{
PacketSource = &Parameter.DNSTarget.Alternate_IPv6;
}
else if (Parameter.DNSTarget.IPv6_Multi != nullptr)
{
for (auto &DNSServerDataIter:*Parameter.DNSTarget.IPv6_Multi)
{
if (memcmp(&IPv6_Header->Source, &DNSServerDataIter.AddressData.IPv6.sin6_addr, sizeof(in6_addr)) == EXIT_SUCCESS)
{
PacketSource = &DNSServerDataIter;
break;
}
}
if (PacketSource == nullptr)
return false;
}
else {
return false;
}
//Get Hop Limits from IPv6 DNS server.
//ICMPv6 Protocol
if (Parameter.ICMP_Speed > 0 && IPv6_Header->NextHeader == IPPROTO_ICMPV6 && ntohs(IPv6_Header->PayloadLength) >= sizeof(icmpv6_hdr))
{
//Validate ICMPv6 checksum.
if (GetChecksum_ICMPv6((PUINT8)Buffer, ntohs(IPv6_Header->PayloadLength), IPv6_Header->Destination, IPv6_Header->Source) != CHECKSUM_SUCCESS)
return false;
//ICMPv6 check
if (CaptureCheck_ICMP(Buffer + sizeof(ipv6_hdr), ntohs(IPv6_Header->PayloadLength), AF_INET6))
PacketSource->HopLimitData.HopLimit = IPv6_Header->HopLimit;
return true;
}
//TCP Protocol
if (Parameter.HeaderCheck_TCP && IPv6_Header->NextHeader == IPPROTO_TCP && ntohs(IPv6_Header->PayloadLength) >= sizeof(tcp_hdr))
{
//Validate TCP checksum.
if (GetChecksum_TCPUDP((PUINT8)Buffer, ntohs(IPv6_Header->PayloadLength), AF_INET6, IPPROTO_TCP) != CHECKSUM_SUCCESS)
return false;
//TCP check
if (CaptureCheck_TCP(Buffer + sizeof(ipv6_hdr)))
PacketSource->HopLimitData.HopLimit = IPv6_Header->HopLimit;
return true;
}
//UDP Protocol
if (IPv6_Header->NextHeader == IPPROTO_UDP && ntohs(IPv6_Header->PayloadLength) >= sizeof(udp_hdr) + DNS_PACKET_MINSIZE)
{
//Validate UDP checksum.
if (GetChecksum_TCPUDP((PUINT8)Buffer, ntohs(IPv6_Header->PayloadLength), AF_INET6, IPPROTO_UDP) != CHECKSUM_SUCCESS)
return false;
//Port check
auto UDP_Header = (pudp_hdr)(Buffer + sizeof(ipv6_hdr));
if (UDP_Header->SrcPort == PacketSource->AddressData.IPv6.sin6_port)
{
//Domain Test and DNS Options check and get Hop Limit from Domain Test.
auto IsMarkHopLimit = false;
if (CheckResponseData(Buffer + sizeof(ipv6_hdr) + sizeof(udp_hdr), ntohs(IPv6_Header->PayloadLength) - sizeof(udp_hdr), false, &IsMarkHopLimit) < (SSIZE_T)DNS_PACKET_MINSIZE)
return false;
if (IsMarkHopLimit)
PacketSource->HopLimitData.HopLimit = IPv6_Header->HopLimit;
//DNSCurve encryption packet check
#if defined(ENABLE_LIBSODIUM)
if (Parameter.DNSCurve &&
//Main(IPv6)
(DNSCurveParameter.DNSCurveTarget.IPv6.AddressData.Storage.ss_family > 0 && DNSCurveParameter.DNSCurveTarget.IPv6.ReceiveMagicNumber != nullptr &&
memcmp(Buffer + sizeof(ipv6_hdr) + sizeof(udp_hdr), DNSCurveParameter.DNSCurveTarget.IPv6.ReceiveMagicNumber, DNSCURVE_MAGIC_QUERY_LEN) == EXIT_SUCCESS ||
//Alternate(IPv6)
DNSCurveParameter.DNSCurveTarget.Alternate_IPv6.AddressData.Storage.ss_family > 0 && DNSCurveParameter.DNSCurveTarget.Alternate_IPv6.ReceiveMagicNumber != nullptr &&
memcmp(Buffer + sizeof(ipv6_hdr) + sizeof(udp_hdr), DNSCurveParameter.DNSCurveTarget.Alternate_IPv6.ReceiveMagicNumber, DNSCURVE_MAGIC_QUERY_LEN) == EXIT_SUCCESS))
return false;
#endif
//Hop Limit must not a ramdom value.
if ((size_t)IPv6_Header->HopLimit + (size_t)Parameter.HopLimitFluctuation > (size_t)PacketSource->HopLimitData.HopLimit &&
(size_t)IPv6_Header->HopLimit < (size_t)PacketSource->HopLimitData.HopLimit + (size_t)Parameter.HopLimitFluctuation)
{
MatchPortToSend(Buffer + sizeof(ipv6_hdr) + sizeof(udp_hdr), ntohs(IPv6_Header->PayloadLength) - sizeof(udp_hdr), AF_INET6, UDP_Header->DstPort);
return true;
}
}
}
}
//IPv4
else {
auto IPv4_Header = (pipv4_hdr)Buffer;
//Validate IPv4 header.
if (ntohs(IPv4_Header->Length) <= IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES || ntohs(IPv4_Header->Length) > Length ||
GetChecksum((PUINT16)Buffer, sizeof(ipv4_hdr)) != CHECKSUM_SUCCESS) //Validate IPv4 header checksum.
return false;
//Mark source of packet.
if (IPv4_Header->Source.s_addr == Parameter.DNSTarget.IPv4.AddressData.IPv4.sin_addr.s_addr)
{
PacketSource = &Parameter.DNSTarget.IPv4;
}
else if (IPv4_Header->Source.s_addr == Parameter.DNSTarget.Alternate_IPv4.AddressData.IPv4.sin_addr.s_addr)
{
PacketSource = &Parameter.DNSTarget.Alternate_IPv4;
}
else if (Parameter.DNSTarget.IPv4_Multi != nullptr)
{
for (auto &DNSServerDataIter:*Parameter.DNSTarget.IPv4_Multi)
{
if (IPv4_Header->Source.s_addr == DNSServerDataIter.AddressData.IPv4.sin_addr.s_addr)
{
PacketSource = &DNSServerDataIter;
break;
}
}
if (PacketSource == nullptr)
return false;
}
else {
return false;
}
//IPv4 options check
if (Parameter.HeaderCheck_IPv4)
{
//No standard header length and header ID check
if (IPv4_Header->IHL > IPV4_STANDARD_IHL || IPv4_Header->ID == 0)
PacketSource->HopLimitData.TTL = IPv4_Header->TTL;
//TOS and Flags should not be set.
if (IPv4_Header->TOS > 0 || IPv4_Header->Flags > 0)
return false;
}
//Get TTL from IPv4 DNS server.
//ICMP Protocol
if (Parameter.ICMP_Speed > 0 && IPv4_Header->Protocol == IPPROTO_ICMP && ntohs(IPv4_Header->Length) >= IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES + sizeof(icmp_hdr))
{
//Validate ICMP checksum.
if (GetChecksum((PUINT16)(Buffer + IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES), ntohs(IPv4_Header->Length) - IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES) != CHECKSUM_SUCCESS)
return false;
//ICMP Check
if (CaptureCheck_ICMP(Buffer + IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES, ntohs(IPv4_Header->Length) - IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES, AF_INET))
PacketSource->HopLimitData.TTL = IPv4_Header->TTL;
return true;
}
//TCP Protocol
if (Parameter.HeaderCheck_TCP && IPv4_Header->Protocol == IPPROTO_TCP && ntohs(IPv4_Header->Length) >= IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES + sizeof(tcp_hdr))
{
//Validate TCP checksum.
if (GetChecksum_TCPUDP((PUINT8)Buffer, ntohs(IPv4_Header->Length) - IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES, AF_INET, IPPROTO_TCP) != CHECKSUM_SUCCESS)
return false;
//TCP check
if (CaptureCheck_TCP(Buffer + IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES))
PacketSource->HopLimitData.TTL = IPv4_Header->TTL;
return true;
}
//UDP Protocol
if (IPv4_Header->Protocol == IPPROTO_UDP && ntohs(IPv4_Header->Length) >= IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES + sizeof(udp_hdr) + DNS_PACKET_MINSIZE)
{
//Validate UDP checksum.
if (GetChecksum_TCPUDP((PUINT8)Buffer, ntohs(IPv4_Header->Length) - IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES, AF_INET, IPPROTO_UDP) != CHECKSUM_SUCCESS)
return false;
//Port check
auto UDP_Header = (pudp_hdr)(Buffer + IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES);
if (UDP_Header->SrcPort == PacketSource->AddressData.IPv4.sin_port)
{
//Domain Test and DNS Options check and get TTL from Domain Test.
auto IsMarkHopLimit = false;
if (CheckResponseData(Buffer + IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES + sizeof(udp_hdr), ntohs(IPv4_Header->Length) - IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES - sizeof(udp_hdr), false, &IsMarkHopLimit) < (SSIZE_T)DNS_PACKET_MINSIZE)
return false;
if (IsMarkHopLimit)
PacketSource->HopLimitData.TTL = IPv4_Header->TTL;
//DNSCurve encryption packet check
#if defined(ENABLE_LIBSODIUM)
if (Parameter.DNSCurve &&
//Main(IPv4)
(DNSCurveParameter.DNSCurveTarget.IPv4.AddressData.Storage.ss_family > 0 && DNSCurveParameter.DNSCurveTarget.IPv4.ReceiveMagicNumber != nullptr &&
memcmp(Buffer + IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES + sizeof(udp_hdr), DNSCurveParameter.DNSCurveTarget.IPv4.ReceiveMagicNumber, DNSCURVE_MAGIC_QUERY_LEN) == EXIT_SUCCESS ||
//Alternate(IPv4)
DNSCurveParameter.DNSCurveTarget.Alternate_IPv4.AddressData.Storage.ss_family > 0 && DNSCurveParameter.DNSCurveTarget.Alternate_IPv4.ReceiveMagicNumber != nullptr &&
memcmp(Buffer + IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES + sizeof(udp_hdr), DNSCurveParameter.DNSCurveTarget.Alternate_IPv4.ReceiveMagicNumber, DNSCURVE_MAGIC_QUERY_LEN) == EXIT_SUCCESS))
return false;
#endif
//TTL must not a ramdom value.
if ((size_t)IPv4_Header->TTL + (size_t)Parameter.HopLimitFluctuation > (size_t)PacketSource->HopLimitData.TTL &&
(size_t)IPv4_Header->TTL < (size_t)PacketSource->HopLimitData.TTL + (size_t)Parameter.HopLimitFluctuation)
{
MatchPortToSend(Buffer + IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES + sizeof(udp_hdr), ntohs(IPv4_Header->Length) - IPv4_Header->IHL * IPv4_IHL_BYTES_TIMES - sizeof(udp_hdr), AF_INET, UDP_Header->DstPort);
return true;
}
}
}
}
return true;
}
