/*********************************************************************
* Function: BOOL ICMPGet(ICMP_CODE *code,
* BYTE *data,
* BYTE *len,
* WORD *id,
* WORD *seq)
*
* PreCondition: MAC buffer contains ICMP type packet.
*
* Input: code - Buffer to hold ICMP code value
* data - Buffer to hold ICMP data
* len - Buffer to hold ICMP data length
* id - Buffer to hold ICMP id
* seq - Buffer to hold ICMP seq
*
* Output: TRUE if valid ICMP packet was received
* FALSE otherwise.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
BOOL ICMPGet(ICMP_CODE *code,
BYTE *data,
BYTE *len,
WORD *id,
WORD *seq)
{
ICMP_PACKET packet;
WORD checksums[2];
WORD CalcChecksum;
WORD ReceivedChecksum;
MACGetArray((BYTE*)&packet, ICMP_HEADER_SIZE);
ReceivedChecksum = packet.Checksum;
packet.Checksum = 0;
checksums[0] = ~CalcIPChecksum((BYTE*)&packet, ICMP_HEADER_SIZE);
*len -= ICMP_HEADER_SIZE;
MACGetArray(data, *len);
checksums[1] = ~CalcIPChecksum(data, *len);
CalcChecksum = CalcIPChecksum((BYTE*)checksums, 2 * sizeof(WORD));
SwapICMPPacket(&packet);
*code = packet.Type;
*id = packet.Identifier;
*seq = packet.SequenceNumber;
return ( CalcChecksum == ReceivedChecksum );
}
/**
* Gets the next ICMP packet
*
* @preCondition MAC buffer contains ICMP type packet.
*
* @param code Buffer to hold ICMP code value
* @param data Buffer to hold ICMP data
* @param len Buffer to hold ICMP data length
* @param id Buffer to hold ICMP id
* @param seq Buffer to hold ICMP seq
*
* @return TRUE if valid ICMP packet was received <br>
* FALSE otherwise
*/
BOOL ICMPGet(ICMP_CODE *code,
BYTE *data,
BYTE *len,
WORD *id,
WORD *seq)
{
ICMP_PACKET packet;
WORD CalcChecksum;
WORD ReceivedChecksum;
#if defined(NON_MCHP_MAC)
WORD checksums[2];
#endif
//Read ICMP Header. The data is read from the current MAC RX Buffer
MACGetArray((BYTE*)&packet, ICMP_HEADER_SIZE);
#if !defined(NON_MCHP_MAC)
// Calculate the checksum using the Microchip MAC's DMA module
// The checksum data includes the precomputed checksum in the
// header, so a valid packet will always have a checksum of
// 0x0000 if the packet is not disturbed.
ReceivedChecksum = 0x0000;
CalcChecksum = MACCalcRxChecksum(0+sizeof(IP_HEADER), *len);
#endif
// Obtain the ICMP data payload
*len -= ICMP_HEADER_SIZE;
MACGetArray(data, *len); //Read ICMP Data. The data is read from the current MAC RX Buffer
#if defined(NON_MCHP_MAC)
// Calculte the checksum in local memory without hardware help
ReceivedChecksum = packet.Checksum;
packet.Checksum = 0;
checksums[0] = ~CalcIPChecksum((BYTE*)&packet, ICMP_HEADER_SIZE);
checksums[1] = ~CalcIPChecksum(data, *len);
CalcChecksum = CalcIPChecksum((BYTE*)checksums, 2 * sizeof(WORD));
#endif
SwapICMPPacket(&packet);
*code = packet.Type;
*id = packet.Identifier;
*seq = packet.SequenceNumber;
return ( CalcChecksum == ReceivedChecksum );
}
/*********************************************************************
* Function: BOOL UDPProcess(NODE_INFO* remoteNode,
* WORD len)
*
* PreCondition: UDPInit() is already called AND
* UDP segment is ready in MAC buffer
*
* Input: remoteNode - Remote node info
* len - Total length of UDP semgent.
*
* Output: TRUE if this function has completed its task
* FALSE otherwise
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
BOOL UDPProcess(NODE_INFO *remoteNode, WORD len)
{
UDP_HEADER h;
UDP_SOCKET s;
/*
* Retrieve UDP header.
*/
MACGetArray((BYTE*)&h, sizeof(h));
h.SourcePort = swaps(h.SourcePort);
h.DestinationPort = swaps(h.DestinationPort);
h.Length = swaps(h.Length) - sizeof(UDP_HEADER);;
h.Checksum = swaps(h.Checksum);
s = FindMatchingSocket(&h, remoteNode);
if ( s == INVALID_UDP_SOCKET )
{
/*
* If there is no matching socket, There is no one to handle
* this data. Discard it.
*/
MACDiscardRx();
}
else
{
UDPSocketInfo[s].RxCount = h.Length;
UDPSocketInfo[s].Flags.bFirstRead = TRUE;
}
return TRUE;
}
/**
* Read the requested number of bytes from the active UDP socket into
* the given buffer.
*
* Note: This function fetches data from an active UDP socket as set by
* UDPIsGetReady() call.
*
* @preCondition UDPInit() is already called AND
* UDPIsGetReady(s) == TRUE
*
* @param[in] buffer Buffer to hold received data.
* @param count Buffer length
*
* @return Number of bytes loaded into buffer.
*/
WORD UDPGetArray(BYTE *buffer, WORD count)
{
WORD bytesRead;
if ( UDPSocketInfo[activeUDPSocket].RxCount == 0 )
return 0;
// If if this very first read to packet, set MAC Rx Pointer to
// beginig of UDP data area.
if ( UDPSocketInfo[activeUDPSocket].Flags.bFirstRead )
{
UDPSocketInfo[activeUDPSocket].Flags.bFirstRead = FALSE;
UDPSetRxBuffer(0);
}
//If more bytes requested then are left in the receive buffer, adjust count
if (count > UDPSocketInfo[activeUDPSocket].RxCount) {
count = UDPSocketInfo[activeUDPSocket].RxCount;
}
//Read the requested amount of data from the current MAC receive buffer
bytesRead = MACGetArray(buffer, count);
UDPSocketInfo[activeUDPSocket].RxCount -= bytesRead;
if ( UDPSocketInfo[activeUDPSocket].RxCount == 0 )
{
MACDiscardRx(); //Discard the contents of the current RX buffer
}
return count;
}
/******************************************************************************
* Function: BOOL MACGetHeader(MAC_ADDR *remote, BYTE* type)
*
* PreCondition: None
*
* Input: *remote: Location to store the Source MAC address of the
* received frame.
* *type: Location of a BYTE to store the constant
* MAC_UNKNOWN, ETHER_IP, or ETHER_ARP, representing
* the contents of the Ethernet type field.
*
* Output: TRUE: If a packet was waiting in the RX buffer. The
* remote, and type values are updated.
* FALSE: If a packet was not pending. remote and type are
* not changed.
*
* Side Effects: Last packet is discarded if MACDiscardRx() hasn't already
* been called.
*
* Overview: None
*
* Note: None
*****************************************************************************/
BOOL MACGetHeader(MAC_ADDR *remote, BYTE* type) {
ENC_PREAMBLE header;
// Test if at least one packet has been received and is waiting
if (EPKTCNT == 0u) {
return FALSE;
}
// Flag that we have received a packet so that we don't swap the RX polarity
// anymore.
flags.bits.bRXPolarityValid = 1;
// Make absolutely certain that any previous packet was discarded
if (flags.bits.bWasDiscarded == 0u) {
MACDiscardRx();
return FALSE;
}
// Save the location of this packet
CurrentPacketLocation.Val = NextPacketLocation.Val;
// Set the read pointer to the beginning of the next unprocessed packet
ERDPT = CurrentPacketLocation.Val;
// Obtain the MAC header from the Ethernet buffer
MACGetArray((BYTE*) & header, sizeof (header));
// The EtherType field, like most items transmitted on the Ethernet medium
// are in big endian.
header.Type.Val = swaps(header.Type.Val);
// Do a sanity check. There might be a bug in code someplace if this
// Reset() ever happens. Check for potential errors in array/pointer writing code.
if (header.NextPacketPointer > RXSTOP || ((BYTE_VAL*) (&header.NextPacketPointer))->bits.b0 ||
header.StatusVector.bits.Zero ||
header.StatusVector.bits.CRCError ||
header.StatusVector.bits.ByteCount > 1518u ||
!header.StatusVector.bits.ReceiveOk) {
Reset();
}
// Save the location where the hardware will write the next packet to
NextPacketLocation.Val = header.NextPacketPointer;
// Return the Ethernet frame's Source MAC address field to the caller
// This parameter is useful for replying to requests without requiring an
// ARP cycle.
memcpy((void*) remote->v, (void*) header.SourceMACAddr.v, sizeof (*remote));
// Return a simplified version of the EtherType field to the caller
*type = MAC_UNKNOWN;
if ((header.Type.v[1] == 0x08u) &&
((header.Type.v[0] == ETHER_IP) || (header.Type.v[0] == ETHER_ARP))) {
*type = header.Type.v[0];
}
// Mark this packet as discardable
flags.bits.bWasDiscarded = 0;
return TRUE;
}
/******************************************************************************
* Function: WORD CalcIPBufferChecksum(WORD len)
*
* PreCondition: Read buffer pointer set to starting of checksum data
*
* Input: len: Total number of bytes to calculate the checksum over.
* The first byte included in the checksum is the byte
* pointed to by ERDPT, which is updated by calls to
* MACSetReadPtr(), MACGet(), MACGetArray(),
* MACGetHeader(), etc.
*
* Output: 16-bit checksum as defined by RFC 793
*
* Side Effects: None
*
* Overview: This function performs a checksum calculation in the MAC
* buffer itself
*
* Note: This function works either in the RX buffer area or the TX
* buffer area. No validation is done on the len parameter.
*****************************************************************************/
WORD CalcIPBufferChecksum(WORD len) {
WORD Start;
DWORD_VAL Checksum = {0x00000000ul};
WORD ChunkLen;
BYTE DataBuffer[20]; // Must be an even size
WORD *DataPtr;
// Save the read pointer starting address
Start = ERDPT;
while (len) {
// Obtain a chunk of data (less SPI overhead compared
// to requesting one byte at a time)
ChunkLen = len > sizeof (DataBuffer) ? sizeof (DataBuffer) : len;
MACGetArray(DataBuffer, ChunkLen);
len -= ChunkLen;
// Take care of a last odd numbered data byte
if (((WORD_VAL*) & ChunkLen)->bits.b0) {
DataBuffer[ChunkLen] = 0x00;
ChunkLen++;
}
// Calculate the checksum over this chunk
DataPtr = (WORD*) & DataBuffer[0];
while (ChunkLen) {
Checksum.Val += *DataPtr++;
ChunkLen -= 2;
}
}
// Restore old read pointer location
ERDPT = Start;
// Do an end-around carry (one's complement arrithmatic)
Checksum.Val = (DWORD) Checksum.w[0] + (DWORD) Checksum.w[1];
// Do another end-around carry in case if the prior add
// caused a carry out
Checksum.w[0] += Checksum.w[1];
// Return the resulting checksum
return ~Checksum.w[0];
}
/*****************************************************************************
Function:
WORD UDPGetArray(BYTE *cData, WORD wDataLen)
Summary:
Reads an array of bytes from the currently active socket.
Description:
This function reads an array of bytes from the currently active UDP socket,
while decrementing the remaining bytes available. UDPIsGetReady should be
used before calling this function to specify the currently active socket.
Precondition:
UDPIsGetReady() was previously called to specify the current socket.
Parameters:
cData - The buffer to receive the bytes being read. If NULL, the bytes are
simply discarded without being written anywhere (effectively skips
over the bytes in the RX buffer, although if you need to skip a lot
of data, seeking using the UDPSetRxBuffer() will be more efficient).
wDateLen - Number of bytes to be read from the socket.
Returns:
The number of bytes successfully read from the UDP buffer. If this
value is less than wDataLen, then the buffer was emptied and no more
data is available.
***************************************************************************/
WORD UDPGetArray(BYTE *cData, WORD wDataLen)
{
WORD wBytesAvailable;
// Make sure that there is data to return
if((wGetOffset >= UDPRxCount) || (SocketWithRxData != activeUDPSocket))
return 0;
// Make sure we don't try to read more data than exists
wBytesAvailable = UDPRxCount - wGetOffset;
if(wBytesAvailable < wDataLen)
wDataLen = wBytesAvailable;
wDataLen = MACGetArray(cData, wDataLen);
wGetOffset += wDataLen;
return wDataLen;
}
/*********************************************************************
* Function: BOOL ARPGet(NODE_INFO* remote, BYTE* opCode)
*
* PreCondition: ARP packet is ready in MAC buffer.
*
* Input: remote - Remote node info
* opCode - Buffer to hold ARP op code.
*
* Output: TRUE if a valid ARP packet was received.
* FALSE otherwise.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
int1 ARPGet(NODE_INFO *remote, int8 *opCode)
{
ARP_PACKET packet;
//MACGetArray((int8*)&packet, sizeof(packet));
MACGetArray(&packet, sizeof(ARP_PACKET));
MACDiscardRx();
SwapARPPacket(&packet);
debug_arp("\r\nARP: HW:%LX PR:%LX ML:%U PL:%U O:%LX TI:%U.%U.%U.%U FI:%U.%U.%U.%U",
packet.HardwareType, packet.Protocol, packet.MACAddrLen, packet.ProtocolLen,
packet.Operation, packet.TargetIPAddr.v[0],packet.TargetIPAddr.v[1],
packet.TargetIPAddr.v[2],packet.TargetIPAddr.v[3],
packet.SenderIPAddr.v[0],packet.SenderIPAddr.v[1],packet.SenderIPAddr.v[2],packet.SenderIPAddr.v[3]);
if ( packet.HardwareType != HW_ETHERNET ||
packet.MACAddrLen != sizeof(MAC_ADDR) ||
packet.ProtocolLen != sizeof(IP_ADDR) )
return FALSE;
if ( packet.Operation == ARP_OPERATION_RESP )
*opCode = ARP_REPLY;
else if ( packet.Operation == ARP_OPERATION_REQ )
*opCode = ARP_REQUEST;
else
{
*opCode = ARP_UNKNOWN;
return FALSE;
}
if(packet.TargetIPAddr.Val == AppConfig.MyIPAddr.Val)
{
remote->MACAddr = packet.SenderMACAddr;
remote->IPAddr = packet.SenderIPAddr;
return TRUE;
}
else
return FALSE;
}
/*********************************************************************
* Function: static void HTTPLoadConn(BYTE connID)
*
* PreCondition: None
*
* Input: connID the connection ID to load
*
* Output: curHTTP has a new connection loaded
*
* Side Effects: None
*
* Overview: Loads the current HTTP connection out of Ethernet
* buffer RAM and into local RAM for processing.
*
* Note: None
********************************************************************/
static void HTTPLoadConn(BYTE connID)
{
WORD oldPtr;
// Return if already loaded
if(connID == curHTTPID)
return;
// Save the old one
oldPtr = MACSetWritePtr(BASE_HTTPB_ADDR + curHTTPID*sizeof(HTTP_CONN));
MACPutArray((BYTE*)&curHTTP, sizeof(HTTP_CONN));
MACSetWritePtr(oldPtr);
// Load the new one
oldPtr = MACSetReadPtr(BASE_HTTPB_ADDR + connID*sizeof(HTTP_CONN));
MACGetArray((BYTE*)&curHTTP, sizeof(HTTP_CONN));
MACSetReadPtr(oldPtr);
// Remember which one is loaded
curHTTPID = connID;
}
/*********************************************************************
* Function: BOOL ARPGet(NODE_INFO* remote, BYTE* opCode)
*
* PreCondition: ARP packet is ready in MAC buffer.
*
* Input: remote - Remote node info
* opCode - Buffer to hold ARP op code.
*
* Output: TRUE if a valid ARP packet was received.
* FALSE otherwise.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
BOOL ARPGet(NODE_INFO *remote, BYTE *opCode)
{
ARP_PACKET packet;
MACGetArray((BYTE*)&packet, sizeof(packet));
MACDiscardRx();
SwapARPPacket(&packet);
if ( packet.HardwareType != HW_ETHERNET ||
packet.MACAddrLen != sizeof(MAC_ADDR) ||
packet.ProtocolLen != sizeof(IP_ADDR) )
{
return FALSE;
}
if ( packet.Operation == ARP_OPERATION_RESP )
{
*opCode = ARP_REPLY;
}
else if ( packet.Operation == ARP_OPERATION_REQ )
*opCode = ARP_REQUEST;
else
{
*opCode = ARP_UNKNOWN;
return FALSE;
}
if(packet.TargetIPAddr.Val == AppConfig.MyIPAddr.Val)
{
remote->MACAddr = packet.SenderMACAddr;
remote->IPAddr = packet.SenderIPAddr;
return TRUE;
}
else
return FALSE;
}
/*********************************************************************
* Function: BOOL IPGetHeader( IP_ADDR *localIP,
* NODE_INFO *remote,
* BYTE *Protocol,
* WORD *len)
*
* PreCondition: MACGetHeader() == TRUE
*
* Input: localIP - Local node IP Address as received
* in current IP header.
* If this information is not required
* caller may pass NULL value.
* remote - Remote node info
* Protocol - Current packet protocol
* len - Current packet data length
*
* Output: TRUE, if valid packet was received
* FALSE otherwise
*
* Side Effects: None
*
* Note: Only one IP message can be received.
* Caller may not transmit and receive a message
* at the same time.
*
********************************************************************/
BOOL IPGetHeader(IP_ADDR *localIP,
NODE_INFO *remote,
BYTE *protocol,
WORD *len)
{
WORD_VAL CalcChecksum;
IP_HEADER header;
#if defined(NON_MCHP_MAC)
WORD_VAL ReceivedChecksum;
WORD checksums[2];
BYTE optionsLen;
#define MAX_OPTIONS_LEN (40u) // As per RFC 791.
BYTE options[MAX_OPTIONS_LEN];
#endif
// Read IP header.
MACGetArray((BYTE*)&header, sizeof(header));
// Make sure that this is an IPv4 packet.
if((header.VersionIHL & 0xf0) != IP_VERSION)
return FALSE;
// Throw this packet away if it is a fragment.
// We don't have enough RAM for IP fragment reconstruction.
if(header.FragmentInfo & 0xFF1F)
return FALSE;
IPHeaderLen = (header.VersionIHL & 0x0f) << 2;
#if !defined(NON_MCHP_MAC)
// Validate the IP header. If it is correct, the checksum
// will come out to 0x0000 (because the header contains a
// precomputed checksum). A corrupt header will have a
// nonzero checksum.
CalcChecksum.Val = MACCalcRxChecksum(0, IPHeaderLen);
// Seek to the end of the IP header
MACSetReadPtrInRx(IPHeaderLen);
if(CalcChecksum.Val)
#else
// Calculate options length in this header, if there is any.
// IHL is in terms of numbers of 32-bit DWORDs; i.e. actual
// length is 4 times IHL.
optionsLen = IPHeaderLen - sizeof(header);
// If there is any option(s), read it so that we can include them
// in checksum calculation.
if ( optionsLen > MAX_OPTIONS_LEN )
return FALSE;
if ( optionsLen > 0u )
MACGetArray(options, optionsLen);
// Save header checksum; clear it and recalculate it ourselves.
ReceivedChecksum.Val = header.HeaderChecksum;
header.HeaderChecksum = 0;
// Calculate checksum of header including options bytes.
checksums[0] = ~CalcIPChecksum((BYTE*)&header, sizeof(header));
// Calculate Options checksum too, if they are present.
if ( optionsLen > 0u )
checksums[1] = ~CalcIPChecksum((BYTE*)options, optionsLen);
else
checksums[1] = 0;
CalcChecksum.Val = CalcIPChecksum((BYTE*)checksums,
2 * sizeof(WORD));
// Make sure that checksum is correct
if ( ReceivedChecksum.Val != CalcChecksum.Val )
#endif
{
// Bad packet. The function caller will be notified by means of the FALSE
// return value and it should discard the packet.
return FALSE;
}
// Network to host conversion.
SwapIPHeader(&header);
// If caller is intrested, return destination IP address
// as seen in this IP header.
if ( localIP )
localIP->Val = header.DestAddress.Val;
remote->IPAddr.Val = header.SourceAddress.Val;
*protocol = header.Protocol;
*len = header.TotalLength - IPHeaderLen;
return TRUE;
}
/*********************************************************************
* Function: void ICMPProcess(void)
*
* PreCondition: MAC buffer contains ICMP type packet.
*
* Input: *remote: Pointer to a NODE_INFO structure of the
* ping requester
* len: Count of how many bytes the ping header and
* payload are in this IP packet
*
* Output: Generates an echo reply, if requested
* Validates and sets ICMPFlags.bReplyValid if a
* correct ping response to one of ours is received.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
void ICMPProcess(NODE_INFO *remote, WORD len)
{
DWORD_VAL dwVal;
// Obtain the ICMP header Type, Code, and Checksum fields
MACGetArray((BYTE*)&dwVal, sizeof(dwVal));
// See if this is an ICMP echo (ping) request
if(dwVal.w[0] == 0x0008u)
{
// Validate the checksum using the Microchip MAC's DMA module
// The checksum data includes the precomputed checksum in the
// header, so a valid packet will always have a checksum of
// 0x0000 if the packet is not disturbed.
if(MACCalcRxChecksum(0+sizeof(IP_HEADER), len))
return;
// Calculate new Type, Code, and Checksum values
dwVal.v[0] = 0x00; // Type: 0 (ICMP echo/ping reply)
dwVal.v[2] += 8; // Subtract 0x0800 from the checksum
if(dwVal.v[2] < 8u)
{
dwVal.v[3]++;
if(dwVal.v[3] == 0u)
dwVal.v[2]++;
}
// Wait for TX hardware to become available (finish transmitting
// any previous packet)
while(!IPIsTxReady());
// Position the write pointer for the next IPPutHeader operation
// NOTE: do not put this before the IPIsTxReady() call for WF compatbility
MACSetWritePtr(BASE_TX_ADDR + sizeof(ETHER_HEADER));
// Create IP header in TX memory
IPPutHeader(remote, IP_PROT_ICMP, len);
// Copy ICMP response into the TX memory
MACPutArray((BYTE*)&dwVal, sizeof(dwVal));
MACMemCopyAsync(-1, -1, len-4);
while(!MACIsMemCopyDone());
// Transmit the echo reply packet
MACFlush();
}
#if defined(STACK_USE_ICMP_CLIENT)
else if(dwVal.w[0] == 0x0000u) // See if this an ICMP Echo reply to our request
{
// Get the sequence number and identifier fields
MACGetArray((BYTE*)&dwVal, sizeof(dwVal));
// See if the identifier matches the one we sent
if(dwVal.w[0] != 0xEFBE)
return;
if(dwVal.w[1] != wICMPSequenceNumber)
return;
// Validate the ICMP checksum field
IPSetRxBuffer(0);
if(CalcIPBufferChecksum(sizeof(ICMP_PACKET))) // Two bytes of payload were sent in the echo request
return;
// Flag that we received the response and stop the timer ticking
ICMPFlags.bReplyValid = 1;
ICMPTimer = TickGet() - ICMPTimer;
}
#endif
}
/*****************************************************************************
Function:
bool ARPProcess(void)
Summary:
Processes an incoming ARP packet.
Description:
Retrieves an ARP packet from the MAC buffer and determines if it is a
response to our request (in which case the ARP is resolved) or if it
is a request requiring our response (in which case we transmit one.)
Precondition:
ARP packet is ready in the MAC buffer.
Parameters:
None
Return Values:
true - All processing of this ARP packet is complete. Do not call
again until a new ARP packet is waiting in the RX buffer.
false - This function must be called again. More time is needed to
send an ARP response.
***************************************************************************/
bool ARPProcess(void)
{
ARP_PACKET packet;
static NODE_INFO Target;
#if defined(STACK_USE_AUTO_IP)
uint8_t i;
#endif
static enum
{
SM_ARP_IDLE = 0,
SM_ARP_REPLY
} smARP = SM_ARP_IDLE;
switch(smARP)
{
case SM_ARP_IDLE:
// Obtain the incoming ARP packet
MACGetArray((uint8_t*)&packet, sizeof(packet));
MACDiscardRx();
SwapARPPacket(&packet);
// Validate the ARP packet
if ( packet.HardwareType != HW_ETHERNET ||
packet.MACAddrLen != sizeof(MAC_ADDR) ||
packet.ProtocolLen != sizeof(IP_ADDR) )
{
return true;
}
#ifdef STACK_USE_ZEROCONF_LINK_LOCAL
ARPProcessRxPkt(&packet);
#endif
#ifdef STACK_USE_AUTO_IP
if (packet.SenderIPAddr.Val == AppConfig.MyIPAddr.Val)
{
AutoIPConflict(0);
return true;
}
#endif
// Handle incoming ARP responses
#ifdef STACK_CLIENT_MODE
if(packet.Operation == ARP_OPERATION_RESP)
{
/* #if defined(STACK_USE_AUTO_IP)
for (i = 0; i < NETWORK_INTERFACES; i++)
if (AutoIPConfigIsInProgress(i))
AutoIPConflict(i);
#endif*/
Cache.MACAddr = packet.SenderMACAddr;
Cache.IPAddr = packet.SenderIPAddr;
//putsUART("ARPProcess: SM_ARP_IDLE: ARP_OPERATION_RESP \r\n");
return true;
}
#endif
// Handle incoming ARP requests for our MAC address
if(packet.Operation == ARP_OPERATION_REQ)
{
if(packet.TargetIPAddr.Val != AppConfig.MyIPAddr.Val)
{
return true;
}
#ifdef STACK_USE_ZEROCONF_LINK_LOCAL
/* Fix for Loop-Back suppression:
* For ZCLL-Claim packets, host should not respond.
* Check Sender's MAC-address with own MAC-address and
* if it is matched, response will not be sent back. This
* was leading to flooding of ARP-answeres */
if(!memcmp (&packet.SenderMACAddr, &AppConfig.MyMACAddr, 6))
{
putsUART("Loopback answer suppressed \r\n");
return true;
}
#endif
#if defined(STACK_USE_AUTO_IP)
for (i = 0; i < NETWORK_INTERFACES; i++)
if (AutoIPConfigIsInProgress(i))
{
AutoIPConflict(i);
return true;
}
#endif
Target.IPAddr = packet.SenderIPAddr;
Target.MACAddr = packet.SenderMACAddr;
//putsUART("ARPProcess: SM_ARP_IDLE: ARP_OPERATION_REQ \r\n");
smARP = SM_ARP_REPLY;
}
// Do not break. If we get down here, we need to send a reply.
case SM_ARP_REPLY:
packet.Operation = ARP_OPERATION_RESP;
#if defined(STACK_USE_AUTO_IP)
if (AutoIPIsConfigured(0))
{
packet.TargetMACAddr.v[0] = 0xFF;
packet.TargetMACAddr.v[1] = 0xFF;
packet.TargetMACAddr.v[2] = 0xFF;
packet.TargetMACAddr.v[3] = 0xFF;
packet.TargetMACAddr.v[4] = 0xFF;
packet.TargetMACAddr.v[5] = 0xFF;
}
else
#endif
packet.TargetMACAddr = Target.MACAddr;
packet.TargetIPAddr = Target.IPAddr;
#ifdef STACK_USE_ZEROCONF_LINK_LOCAL
packet.SenderIPAddr = AppConfig.MyIPAddr;
#endif
//putsUART("ARPProcess: SM_ARP_REPLY \r\n");
// Send an ARP response to a previously received request
if(!ARPPut(&packet))
{
return false;
}
// Begin listening for ARP requests again
smARP = SM_ARP_IDLE;
break;
}
return true;
}
BOOL UDPProcess(NODE_INFO *remoteNode, IP_ADDR *localIP, WORD len)
{
UDP_HEADER h;
UDP_SOCKET s;
UDP_PSEUDO_HEADER pseudoHeader;
WORD_VAL checksum;
/*
* Retrieve UDP header.
*/
//MACGetArray((BYTE*)&h, sizeof(h));
MACGetArray(&h, sizeof(UDP_HEADER));
h.SourcePort = swaps(h.SourcePort);
h.DestinationPort = swaps(h.DestinationPort);
h.Length = swaps(h.Length) - sizeof(UDP_HEADER);
debug_udp("\r\nUDP PROCESS SP=%LX DP=%LX PAYLOAD=%LX ",
h.SourcePort,
h.DestinationPort,
h.Length
);
// See if we need to validate the checksum field (0x0000 is disabled)
if(h.Checksum)
{
h.Checksum = swaps(h.Checksum);
// Calculate IP pseudoheader checksum.
pseudoHeader.SourceAddress = remoteNode->IPAddr;
pseudoHeader.DestAddress.v[0] = localIP->v[0];
pseudoHeader.DestAddress.v[1] = localIP->v[1];
pseudoHeader.DestAddress.v[2] = localIP->v[2];
pseudoHeader.DestAddress.v[3] = localIP->v[3];
pseudoHeader.Zero = 0x0;
pseudoHeader.Protocol = IP_PROT_UDP;
pseudoHeader.Length = len;
SwapPseudoHeader(pseudoHeader);
checksum.Val = ~CalcIPChecksum(&pseudoHeader,
sizeof(pseudoHeader));
// Set UDP packet checksum = pseudo header checksum in MAC RAM.
IPSetRxBuffer(6);
MACPut(checksum.v[0]);
// In case if the end of the RX buffer is reached and a wraparound is needed, set the next address to prevent writing to the wrong address.
IPSetRxBuffer(7);
MACPut(checksum.v[1]);
IPSetRxBuffer(0);
// Now calculate UDP packet checksum in NIC RAM - including
// pesudo header.
checksum.Val = CalcIPBufferChecksum(len);
if ( checksum.Val != h.Checksum )
{
debug_udp("INVALID-CS ");
MACDiscardRx();
return TRUE;
}
}
s = FindMatching_UDP_Socket(&h, remoteNode, localIP);
if ( s == INVALID_UDP_SOCKET )
{
/*
* If there is no matching socket, There is no one to handle
* this data. Discard it.
*/
debug_udp("INVALID-SOCKET ");
MACDiscardRx();
}
else {
UDPSocketInfo[s].RxCount = h.Length;
UDPSocketInfo[s].Flags.bFirstRead = TRUE;
debug_udp("MATCH AS:%U ", s);
/*debug_udp("MAC-%X:%X:%X:%X:%X:%X",
remoteNode->MACAddr.v[0],
remoteNode->MACAddr.v[1],
remoteNode->MACAddr.v[2],
remoteNode->MACAddr.v[3],
remoteNode->MACAddr.v[4],
remoteNode->MACAddr.v[5]
);*/
}
return TRUE;
}
/*****************************************************************************
Function:
BOOL UDPProcess(NODE_INFO *remoteNode, IP_ADDR *localIP, WORD len)
Summary:
Handles an incoming UDP segment.
Description:
This function handles an incoming UDP segment to determine if it is
acceptable and should be handed to one of the stack applications for
processing.
Precondition:
UDPInit() has been called an a UDP segment is ready in the MAC buffer.
Parameters:
remoteNode - The remote node that sent this segment.
localIP - The destination IP address for this segment.
len - Total length of the UDP segment.
Return Values:
TRUE - A valid packet is waiting and the stack applications should be
called to handle it.
FALSE - The packet was discarded.
***************************************************************************/
BOOL UDPProcess(NODE_INFO *remoteNode, IP_ADDR *localIP, WORD len)
{
UDP_HEADER h;
UDP_SOCKET s;
PSEUDO_HEADER pseudoHeader;
DWORD_VAL checksums;
UDPRxCount = 0;
// Retrieve UDP header.
MACGetArray((BYTE*)&h, sizeof(h));
h.SourcePort = swaps(h.SourcePort);
h.DestinationPort = swaps(h.DestinationPort);
h.Length = swaps(h.Length) - sizeof(UDP_HEADER);
// See if we need to validate the checksum field (0x0000 is disabled)
if(h.Checksum)
{
// Calculate IP pseudoheader checksum.
pseudoHeader.SourceAddress = remoteNode->IPAddr;
pseudoHeader.DestAddress.Val = localIP->Val;
pseudoHeader.Zero = 0x0;
pseudoHeader.Protocol = IP_PROT_UDP;
pseudoHeader.Length = len;
SwapPseudoHeader(pseudoHeader);
checksums.w[0] = ~CalcIPChecksum((BYTE*)&pseudoHeader,
sizeof(pseudoHeader));
// Now calculate UDP packet checksum in NIC RAM -- should match pseudoHeader
IPSetRxBuffer(0);
checksums.w[1] = CalcIPBufferChecksum(len);
if(checksums.w[0] != checksums.w[1])
{
MACDiscardRx();
return FALSE;
}
}
s = FindMatchingSocket(&h, remoteNode, localIP);
if(s == INVALID_UDP_SOCKET)
{
// If there is no matching socket, There is no one to handle
// this data. Discard it.
MACDiscardRx();
return FALSE;
}
else
{
SocketWithRxData = s;
UDPRxCount = h.Length;
Flags.bFirstRead = 1;
Flags.bWasDiscarded = 0;
}
return TRUE;
}
/*********************************************************************
* Function: void StackTask(void)
*
* PreCondition: StackInit() is already called.
*
* Input: None
*
* Output: Stack FSM is executed.
*
* Side Effects: None
*
* Note: This FSM checks for new incoming packets,
* and routes it to appropriate stack components.
* It also performs timed operations.
*
* This function must be called periodically to
* ensure timely responses.
*
********************************************************************/
void StackTask(void)
{
WORD dataCount;
IP_ADDR tempLocalIP;
BYTE cFrameType;
BYTE cIPFrameType;
#if defined( WF_CS_TRIS )
// This task performs low-level MAC processing specific to the MRF24W
MACProcess();
#if defined( STACK_USE_EZ_CONFIG ) && !defined(__18CXX)
WFEasyConfigMgr();
#endif
#if defined(STACK_USE_DHCP_CLIENT)
// Normally, an application would not include DHCP module
// if it is not enabled. But in case some one wants to disable
// DHCP module at run-time, remember to not clear our IP
// address if link is removed.
if(AppConfig.Flags.bIsDHCPEnabled)
{
if(g_DhcpRenew == TRUE)
{
g_DhcpRenew = FALSE;
AppConfig.MyIPAddr.Val = AppConfig.DefaultIPAddr.Val;
AppConfig.MyMask.Val = AppConfig.DefaultMask.Val;
AppConfig.Flags.bInConfigMode = TRUE;
DHCPInit(0);
g_DhcpRetryTimer = (UINT32)TickGet();
} else {
if (g_DhcpRetryTimer && TickGet() - g_DhcpRetryTimer >= TICKS_PER_SECOND * 8) {
DHCPInit(0);
g_DhcpRetryTimer = (UINT32)TickGet();
}
}
// DHCP must be called all the time even after IP configuration is
// discovered.
// DHCP has to account lease expiration time and renew the configuration
// time.
DHCPTask();
if(DHCPIsBound(0)) {
AppConfig.Flags.bInConfigMode = FALSE;
g_DhcpRetryTimer = 0;
}
}
#endif // STACK_USE_DHCP_CLIENT
#endif // WF_CS_TRIS
#if defined(STACK_USE_DHCP_CLIENT) && !defined(WF_CS_TRIS)
// Normally, an application would not include DHCP module
// if it is not enabled. But in case some one wants to disable
// DHCP module at run-time, remember to not clear our IP
// address if link is removed.
if(AppConfig.Flags.bIsDHCPEnabled)
{
static BOOL bLastLinkState = FALSE;
BOOL bCurrentLinkState;
bCurrentLinkState = MACIsLinked();
if(bCurrentLinkState != bLastLinkState)
{
bLastLinkState = bCurrentLinkState;
if(!bCurrentLinkState)
{
AppConfig.MyIPAddr.Val = AppConfig.DefaultIPAddr.Val;
AppConfig.MyMask.Val = AppConfig.DefaultMask.Val;
AppConfig.Flags.bInConfigMode = TRUE;
DHCPInit(0);
}
}
// DHCP must be called all the time even after IP configuration is
// discovered.
// DHCP has to account lease expiration time and renew the configuration
// time.
DHCPTask();
if(DHCPIsBound(0))
AppConfig.Flags.bInConfigMode = FALSE;
}
#endif
#if defined (STACK_USE_AUTO_IP)
AutoIPTasks();
#endif
#if defined(STACK_USE_TCP)
// Perform all TCP time related tasks (retransmit, send acknowledge, close connection, etc)
TCPTick();
#endif
#if defined(STACK_USE_UDP)
UDPTask();
#endif
// Process as many incomming packets as we can
while(1)
{
//if using the random module, generate entropy
#if defined(STACK_USE_RANDOM)
RandomAdd(remoteNode.MACAddr.v[5]);
#endif
// We are about to fetch a new packet, make sure that the
// UDP module knows that any old RX data it has laying
// around will now be gone.
#if defined(STACK_USE_UDP)
UDPDiscard();
#endif
// Fetch a packet (throws old one away, if not thrown away
// yet)
if(!MACGetHeader(&remoteNode.MACAddr, &cFrameType))
break;
// When using a WiFi module, filter out all incoming packets that have
// the same source MAC address as our own MAC address. This is to
// prevent receiving and passing our own broadcast packets up to other
// layers and avoid, for example, having our own gratuitous ARPs get
// answered by ourself.
#if defined(WF_CS_TRIS)
if(memcmp((void*)&remoteNode.MACAddr, (void*)&AppConfig.MyMACAddr, 6) == 0u)
continue;
#if defined(CONFIG_WPA_ENTERPRISE)
if (cFrameType == MAC_UNKNOWN) {
static unsigned char buf[2300];
struct ieee8021xhdr *hdr = (struct ieee8021xhdr *)buf;
MACGetArray((BYTE*)hdr, sizeof(*hdr));
if (SWAP16(hdr->length) > 0)
MACGetArray((BYTE*)(hdr + 1), SWAP16(hdr->length));
l2_packet_receive(hdr, SWAP16(hdr->length) + sizeof(*hdr), &remoteNode.MACAddr);
continue;
}
#endif /* defined(CONFIG_WPA_ENTERPRISE) */
#endif /* defined(WF_CS_TRIS) */
// Dispatch the packet to the appropriate handler
switch(cFrameType)
{
case MAC_ARP:
ARPProcess();
break;
case MAC_IP:
if(!IPGetHeader(&tempLocalIP, &remoteNode, &cIPFrameType, &dataCount))
break;
#if defined(STACK_USE_ICMP_SERVER) || defined(STACK_USE_ICMP_CLIENT)
if(cIPFrameType == IP_PROT_ICMP)
{
#if defined(STACK_USE_IP_GLEANING)
if(AppConfig.Flags.bInConfigMode && AppConfig.Flags.bIsDHCPEnabled)
{
// According to "IP Gleaning" procedure,
// when we receive an ICMP packet with a valid
// IP address while we are still in configuration
// mode, accept that address as ours and conclude
// configuration mode.
if(tempLocalIP.Val != 0xffffffff)
{
AppConfig.Flags.bInConfigMode = FALSE;
AppConfig.MyIPAddr = tempLocalIP;
}
}
#endif
// Process this ICMP packet if it the destination IP address matches our address or one of the broadcast IP addressees
if( (tempLocalIP.Val == AppConfig.MyIPAddr.Val) ||
(tempLocalIP.Val == 0xFFFFFFFF) ||
#if defined(STACK_USE_ZEROCONF_LINK_LOCAL) || defined(STACK_USE_ZEROCONF_MDNS_SD)
(tempLocalIP.Val == 0xFB0000E0) ||
#endif
(tempLocalIP.Val == ((AppConfig.MyIPAddr.Val & AppConfig.MyMask.Val) | ~AppConfig.MyMask.Val)))
{
ICMPProcess(&remoteNode, dataCount);
}
break;
}
#endif
#if defined(STACK_USE_TCP)
if(cIPFrameType == IP_PROT_TCP)
{
TCPProcess(&remoteNode, &tempLocalIP, dataCount);
break;
}
#endif
#if defined(STACK_USE_UDP)
if(cIPFrameType == IP_PROT_UDP)
{
// Stop processing packets if we came upon a UDP frame with application data in it
if(UDPProcess(&remoteNode, &tempLocalIP, dataCount))
return;
}
#endif
break;
}
}
}
int1 MACGetHeader(MAC_ADDR *remote, int8* type)
{
NE_PREAMBLE header;
int8 NICWritePtr;
WORD_VAL temp;
*type = MAC_UNKNOWN;
// Reset NIC if overrun has occured.
if ( NICGet(ISR) & 0x10 )
{
#if 1
NICPut(CMDR, 0x21);
Delay(0xff);
NICPut(RBCR0, 0);
NICPut(RBCR1, 0);
NICPut(TCR, 0x02);
NICPut(CMDR, 0x20);
MACDiscardRx();
NICPut(ISR, 0xff);
NICPut(TCR, 0x00);
return FALSE;
#else
MACInit();
return FALSE;
#endif
}
NICPut(CMDR, 0x60);
NICWritePtr = NICGet(CURRP);
NICPut(CMDR, 0x20);
if ( NICWritePtr != NICReadPtr )
{
temp.v[1] = NICReadPtr;
temp.v[0] = 0;
NICSetAddr(temp.Val);
//MACGetArray((int8*)&header, sizeof(header));
debug("\r\n***************************************\r\n");
MACGetArray(&header, sizeof(NE_PREAMBLE));
debug(debug_putc,"\r\n\r\nGOT HDR = ST:%X NPP:%X LEN:%LU",
(int8)header.Status,header.NextPacketPointer,header.ReceivedBytes);
debug(debug_putc,"\r\n DEST: %X.%X.%X.%X.%X.%X SRC: %X.%X.%X.%X.%X.%X TYPE:%LX",
header.DestMACAddr.v[0],header.DestMACAddr.v[1],header.DestMACAddr.v[2],
header.DestMACAddr.v[3],header.DestMACAddr.v[4],header.DestMACAddr.v[5],
header.SourceMACAddr.v[0],header.SourceMACAddr.v[1],header.SourceMACAddr.v[2],
header.SourceMACAddr.v[3],header.SourceMACAddr.v[4],header.SourceMACAddr.v[5],
header.Type.Val);
// Validate packet length and status.
if ( header.Status.PRX && (header.ReceivedBytes >= MINFRAMEC) && (header.ReceivedBytes <= MAXFRAMEC) )
{
debug(debug_putc," VALID");
header.Type.Val = swaps(header.Type.Val);
//memcpy((char*)remote->v, (char*)header.SourceMACAddr.v, sizeof(*remote));
memcpy(&remote->v[0], &header.SourceMACAddr.v[0], sizeof(MAC_ADDR));
if ( (header.Type.v[1] == 0x08) && ((header.Type.v[0] == ETHER_IP) || (header.Type.v[0] == ETHER_ARP)) )
*type = header.Type.v[0];
}
NICCurrentRdPtr = NICReadPtr;
NICReadPtr = header.NextPacketPointer;
return TRUE;
}
return FALSE;
}
/*****************************************************************************
Function:
ARP_RESULT ARPProcess(NET_CONFIG* pIf)
Summary:
Processes an incoming ARP packet.
Description:
Retrieves an ARP packet from the MAC buffer and determines if it is a
response to our request (in which case the ARP is resolved) or if it
is a request requiring our response (in which case we transmit one.)
Precondition:
ARP packet is ready in the MAC buffer.
Parameters:
None
Return Values:
ARP_RES_OK - processing OK.
ARP_RES_error - some error occurred
***************************************************************************/
ARP_RESULT ARPProcess(NET_CONFIG* pIf)
{
ARP_PACKET packet;
MAC_ADDR *dstMAC;
OA_HASH_ENTRY *hE;
ARP_CACHE_DCPT *pArpDcpt;
int netIx;
TCPIP_MAC_HANDLE hMac;
ARP_RESULT arpReqRes;
netIx = _TCPIPStackNetIx(pIf);
pArpDcpt = arpCache + netIx;
hMac = _TCPIPStackNetToMac(pIf);
// Obtain the incoming ARP packet and process
MACGetArray(hMac, (uint8_t*)&packet, sizeof(packet));
MACDiscardRx(hMac);
SwapARPPacket(&packet);
// Validate the ARP packet
if ( packet.HardwareType != HW_ETHERNET ||
packet.MACAddrLen != sizeof(MAC_ADDR) ||
packet.ProtocolLen != sizeof(IP_ADDR) )
{
return ARP_RES_OK;
}
#ifdef TCPIP_STACK_USE_ZEROCONF_LINK_LOCAL
ARPProcessRxPkt(pIf, &packet);
#endif
arpReqRes = ARP_RES_OK;
// Handle incoming ARP packet
hE = OAHashLookUp(pArpDcpt->cacheDcpt, &packet.SenderIPAddr.Val);
if(hE != 0)
{ // we already have this sender and we should update it
_ARPUpdateEntry(pIf, (ARP_HASH_ENTRY*)hE, &packet.SenderMACAddr);
}
while(packet.TargetIPAddr.Val == pIf->MyIPAddr.Val)
{ // we are the target and we should add to cache anyway
if(hE == 0)
{ // not there yet
arpReqRes = _ARPAddCompleteEntry(pIf, &packet.SenderIPAddr, &packet.SenderMACAddr);
}
// Handle incoming ARP operation
if(packet.Operation == ARP_OPERATION_REQ)
{
// ARP packet asking for this host IP address
#ifdef TCPIP_STACK_USE_ZEROCONF_LINK_LOCAL
/* Fix for Loop-Back suppression:
* For ZCLL-Claim packets, host should not respond.
* Check Sender's MAC-address with own MAC-address and
* if it is matched, response will not be sent back. This
* was leading to flooding of ARP-answeres */
if(!memcmp (&packet.SenderMACAddr, &pIf->MyMACAddr, 6))
{
SYS_CONSOLE_MESSAGE("Loopback answer suppressed \r\n");
break;
}
#endif
#if defined(TCPIP_STACK_USE_AUTO_IP)
if ((packet.SenderIPAddr.Val == pIf->MyIPAddr.Val) || AutoIPConfigIsInProgress(pIf))
{
AutoIPConflict(pIf);
break;
}
#endif
// Need to send a reply to the requestor
#if defined(TCPIP_STACK_USE_AUTO_IP)
if (AutoIPIsConfigured(pIf))
{
dstMAC = &arpBcastAdd;
}
else
#endif
{
dstMAC = &packet.SenderMACAddr;
}
// Send an ARP response to the received request
if(!ARP_SendIfPkt(pIf, ARP_OPERATION_RESP, (uint32_t)pIf->MyIPAddr.Val, (uint32_t)packet.SenderIPAddr.Val, dstMAC))
{
arpReqRes = ARP_RES_TX_FAILED;
}
}
break;
}
return arpReqRes;
}
/**
* Performs UDP related tasks. Must continuesly be called.
*
* @preCondition UDPInit() is already called AND <br>
* UDP segment is ready in MAC buffer
*
* @param remoteNode Remote node info
* @param len Total length of UDP semgent
* @param destIP The Destination IP Address of the currently received packet
*
* @return TRUE if this function has completed its task <br>
* FALSE otherwise
*/
BOOL UDPProcess(NODE_INFO *remoteNode, IP_ADDR *destIP, WORD len)
{
UDP_HEADER h;
UDP_SOCKET s;
PSEUDO_HEADER pseudoHeader;
WORD_VAL checksum;
#if defined(UDP_SPEED_OPTIMIZE)
BYTE temp;
#endif
//Retrieve UDP header. The data is read from the current MAC RX Buffer
MACGetArray((BYTE*)&h, sizeof(h));
#if defined(UDP_SPEED_OPTIMIZE)
temp = h.SourcePort.v[0];
h.SourcePort.v[0] = h.SourcePort.v[1];
h.SourcePort.v[1] = temp;
temp = h.DestinationPort.v[0];
h.DestinationPort.v[0] = h.DestinationPort.v[1];
h.DestinationPort.v[1] = temp;
//Will an overflow occur after the subtraction?
if ((BYTE)sizeof(UDP_HEADER) > h.Length.v[1]) {
temp = h.Length.v[0] - 1;
}
else {
temp = h.Length.v[0];
}
h.Length.v[0] = h.Length.v[1] - (BYTE)sizeof(UDP_HEADER);
h.Length.v[1] = temp;
#else
h.SourcePort.Val = swaps(h.SourcePort.Val);
h.DestinationPort.Val = swaps(h.DestinationPort.Val);
h.Length.Val = swaps(h.Length.Val) - sizeof(UDP_HEADER);
#endif
// See if we need to validate the checksum field (0x0000 is disabled)
if(h.Checksum.Val)
{
#if defined(UDP_SPEED_OPTIMIZE)
temp = h.Checksum.v[0];
h.Checksum.v[0] = h.Checksum.v[1];
h.Checksum.v[1] = temp;
#else
h.Checksum.Val = swaps(h.Checksum.Val);
#endif
// Calculate IP pseudoheader checksum.
pseudoHeader.SourceAddress = remoteNode->IPAddr;
pseudoHeader.DestAddress.v[0] = destIP->v[0];
pseudoHeader.DestAddress.v[1] = destIP->v[1];
pseudoHeader.DestAddress.v[2] = destIP->v[2];
pseudoHeader.DestAddress.v[3] = destIP->v[3];
pseudoHeader.Zero = 0x0;
pseudoHeader.Protocol = IP_PROT_UDP;
pseudoHeader.Length = len;
SwapPseudoHeader(pseudoHeader);
checksum.Val = ~CalcIPChecksum((BYTE*)&pseudoHeader,
sizeof(pseudoHeader));
// Set UCP packet checksum = pseudo header checksum in MAC RAM.
IPSetRxBuffer(6);
MACPut(checksum.v[0]);
// In case if the end of the RX buffer is reached and a wraparound is needed, set the next address to prevent writing to the wrong address.
IPSetRxBuffer(7);
MACPut(checksum.v[1]);
IPSetRxBuffer(0); //Set current receive buffer access pointer to first byte of IP data = first byte of TCP header
// Now calculate UDP packet checksum in NIC RAM - including
// pesudo header.
checksum.Val = CalcIPBufferChecksum(len);
if ( checksum.Val != h.Checksum.Val )
{
MACDiscardRx(); //Discard the contents of the current RX buffer
return TRUE;
}
}
s = FindMatchingSocket(&h, remoteNode, destIP);
if ( s == INVALID_UDP_SOCKET )
{
// If there is no matching socket, There is no one to handle
// this data. Discard it.
MACDiscardRx(); //Discard the contents of the current RX buffer
}
else
{
UDPSocketInfo[s].RxCount = h.Length.Val;
UDPSocketInfo[s].Flags.bFirstRead = TRUE;
}
return TRUE;
}
