/**
* 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 called
* to make sure that timely response.
*
* @preCondition StackInit() is already called.
*
* side affect: Stack FSM is executed.
*/
void StackTask(void)
{
static WORD dataCount;
#if defined(STACK_USE_ICMP)
static BYTE data[MAX_ICMP_DATA_LEN];
static WORD ICMPId;
static WORD ICMPSeq;
#endif
IP_ADDR destIP; //Is filled with the Destination IP address contained in the IP header
union
{
BYTE MACFrameType;
BYTE IPFrameType;
ICMP_CODE ICMPCode;
} type;
BOOL lbContinue;
do
{
lbContinue = FALSE;
switch(smStack)
{
case SM_STACK_IDLE:
case SM_STACK_MAC:
//debugPutGenRomStr(2, (ROM char*)"1"); //@mxd:2:%s
//Check if the MAC RX Buffer has any data, and if it does, read the header.
//Get the next header from the NIC. The node who sent it's address will be copied to
//'remoteNode.MACAddr'.
//Header was NOT read if MACGetHeader returned FALSE
if ( !MACGetHeader(&remoteNode.MACAddr, &type.MACFrameType) )
{
//debugPutGenRomStr(2, (ROM char*)"2"); //@mxd:2:%s
//MODIFIED DHCP BEGIN
// ADDED
#if defined(STACK_USE_DHCP)
// 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(STACK_IS_DHCP_ENABLED)
{
if(!MACIsLinked())
{
AppConfig.MyIPAddr.v[0] = MY_DEFAULT_IP_ADDR_BYTE1;
AppConfig.MyIPAddr.v[1] = MY_DEFAULT_IP_ADDR_BYTE2;
AppConfig.MyIPAddr.v[2] = MY_DEFAULT_IP_ADDR_BYTE3;
AppConfig.MyIPAddr.v[3] = MY_DEFAULT_IP_ADDR_BYTE4;
AppConfig.MyMask.v[0] = MY_DEFAULT_MASK_BYTE1;
AppConfig.MyMask.v[1] = MY_DEFAULT_MASK_BYTE2;
AppConfig.MyMask.v[2] = MY_DEFAULT_MASK_BYTE3;
AppConfig.MyMask.v[3] = MY_DEFAULT_MASK_BYTE4;
DHCPFlags.bits.bDHCPServerDetected = FALSE;
stackFlags.bits.bInConfigMode = TRUE;
DHCPReset();
}
// 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())
stackFlags.bits.bInConfigMode = FALSE;
}
#endif
//MODIFIED DHCP END
//MODIFIED DHCP BEGIN
// Removed
/*
#if defined(STACK_USE_DHCP)
// 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.
//Set our IP to 0.0.0.0 if all the following are TRUE:
// - DHCP is enabled
// - MAC is not linked yet (or cable is unplugged)
if (STACK_IS_DHCP_ENABLED)
{
if ( !MACIsLinked() )
{
//debugPutGenRomStr(2, (ROM char*)"3"); //@mxd:2:%s
#if (DEBUG_STACKTSK >= LOG_INFO)
//debugPutMsg(1); //@mxd:1:DHCP Enabled but MAC not linked yet - set IP to 0.0.0.0
#endif
//if (stackFlags.bits.bInConfigMode) {
//IP address must be 0.0.0.0 before DHCP has obtained a valid IP address
MY_IP_BYTE1 = 0;
MY_IP_BYTE2 = 0;
MY_IP_BYTE3 = 0;
MY_IP_BYTE4 = 0;
//}
stackFlags.bits.bInConfigMode = TRUE;
DHCPReset();
}
}
#endif
*/
//MODIFIED DHCP END
break; //case SM_STACK_IDLE: AND case SM_STACK_MAC:
}
//debugPutGenRomStr(2, (ROM char*)"4"); //@mxd:2:%s
lbContinue = TRUE;
if ( type.MACFrameType == MAC_IP ) {
smStack = SM_STACK_IP;
#if (DEBUG_STACKTSK >= LOG_DEBUG)
debugPutMsg(2); //@mxd:2:Reading MAC IP header
#endif
}
else if ( type.MACFrameType == MAC_ARP ) {
smStack = SM_STACK_ARP;
#if (DEBUG_STACKTSK >= LOG_DEBUG)
debugPutMsg(3); //@mxd:3:Reading MAC ARP header
#endif
}
else {
MACDiscardRx(); //Discard the contents of the current RX buffer
#if (DEBUG_STACKTSK >= LOG_WARN)
debugPutMsg(4); //@mxd:4:Unknown MAC header read, MAC Frame Type = 0x%x
debugPutByteHex(type.MACFrameType);
#endif
}
break; //case SM_STACK_IDLE: AND case SM_STACK_MAC:
case SM_STACK_ARP:
if ( ARPProcess() )
smStack = SM_STACK_IDLE;
//lbContinue = FALSE; //Removed in latest Microchip TCP/IP stack
break;
case SM_STACK_IP:
if ( IPGetHeader(&destIP, /* Get Destination IP Address as received in IP header */
&remoteNode,
&type.IPFrameType,
&dataCount) )
{
lbContinue = TRUE;
if ( type.IPFrameType == IP_PROT_ICMP )
{
smStack = SM_STACK_ICMP;
#if defined(STACK_USE_IP_GLEANING)
if(stackFlags.bits.bInConfigMode && STACK_IS_DHCP_ENABLED)
{
// Accoriding 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 ( destIP.Val != 0xffffffff )
{
stackFlags.bits.bInConfigMode = FALSE;
MY_IP_BYTE1 = destIP.v[0];
MY_IP_BYTE2 = destIP.v[1];
MY_IP_BYTE3 = destIP.v[2];
MY_IP_BYTE4 = destIP.v[3];
myDHCPBindCount--;
}
}
#endif
}
#if defined(STACK_USE_TCP)
else if ( type.IPFrameType == IP_PROT_TCP )
smStack = SM_STACK_TCP;
#endif
#if defined(STACK_USE_UDP)
else if ( type.IPFrameType == IP_PROT_UDP )
smStack = SM_STACK_UDP;
#endif
else // Unknown/unsupported higher level protocol
{
lbContinue = FALSE;
MACDiscardRx(); //Discard the contents of the current RX buffer
smStack = SM_STACK_IDLE;
}
}
else // Improper IP header version or checksum
{
MACDiscardRx(); //Discard the contents of the current RX buffer
smStack = SM_STACK_IDLE;
}
break; //case SM_STACK_IP:
#if defined(STACK_USE_UDP)
case SM_STACK_UDP:
if ( UDPProcess(&remoteNode, &destIP, dataCount) )
smStack = SM_STACK_IDLE;
//lbContinue = FALSE; //Removed in latest Microchip TCP/IP stack
break; //case SM_STACK_UDP:
#endif
#if defined(STACK_USE_TCP)
case SM_STACK_TCP:
if ( TCPProcess(&remoteNode, &destIP, dataCount) ) //Will return TRUE if TCPProcess finished it's task, else FALSE
smStack = SM_STACK_IDLE;
//lbContinue = FALSE; //Removed in latest Microchip TCP/IP stack
break; //case SM_STACK_TCP:
#endif
case SM_STACK_ICMP:
smStack = SM_STACK_IDLE;
#if defined(STACK_USE_ICMP)
if ( dataCount <= (MAX_ICMP_DATA_LEN+9) )
{
if ( ICMPGet(&type.ICMPCode,
data,
(BYTE*)&dataCount,
&ICMPId,
&ICMPSeq) )
{
if ( type.ICMPCode == ICMP_ECHO_REQUEST )
{
lbContinue = TRUE;
smStack = SM_STACK_ICMP_REPLY;
}
}
}
#endif
MACDiscardRx(); //Discard the contents of the current RX buffer
break; //case SM_STACK_ICMP:
#if defined(STACK_USE_ICMP)
case SM_STACK_ICMP_REPLY:
if ( ICMPIsTxReady() )
{
ICMPPut(&remoteNode,
ICMP_ECHO_REPLY,
data,
(BYTE)dataCount,
ICMPId,
ICMPSeq);
smStack = SM_STACK_IDLE;
}
break; //case SM_STACK_ICMP_REPLY:
#endif
} //switch(smStack)
FAST_USER_PROCESS();
} while(lbContinue);
#if defined(STACK_USE_TCP)
// Perform timed TCP FSM.
TCPTick();
#endif
//MODIFIED DHCP BEGIN
// Removed this
//#if defined(STACK_USE_DHCP)
/*
* 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())
// stackFlags.bits.bInConfigMode = FALSE;
//#endif
//debugPutGenRomStr(2, (ROM char*)"MACTask"); //@mxd:2:%s
//Perform routine MAC tasks
MACTask();
}
/*********************************************************************
* 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 MRF24WB0M
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);
}
// 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 // STACK_USE_DHCP_CLIENT
#endif
#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;
#endif
// 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;
}
}
}
/**
* 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 called
* to make sure that timely response.
*
* @preCondition StackInit() is already called.
*
* side affect: Stack FSM is executed.
*/
void StackTask(void)
{
static NODE_INFO remoteNode;
static WORD dataCount;
#if defined(STACK_USE_ICMP)
static BYTE data[MAX_ICMP_DATA_LEN];
static WORD ICMPId;
static WORD ICMPSeq;
#endif
IP_ADDR destIP; //Is filled with the Destination IP address contained in the IP header
union
{
BYTE MACFrameType;
BYTE IPFrameType;
ICMP_CODE ICMPCode;
} type;
BOOL lbContinue;
lbContinue = TRUE;
while( lbContinue )
{
lbContinue = FALSE;
switch(smStack)
{
case SM_STACK_IDLE:
case SM_STACK_MAC:
//Check if the MAC RX Buffer has any data, and if it does, read the header.
//Get the next header from the NIC. The node who sent it's address will be copied to
//'remoteNode.MACAddr'.
if ( !MACRxbufGetHdr(&remoteNode.MACAddr, &type.MACFrameType) )
{
//Header was NOT read if MACRxbufGetHdr returned FALSE
#if defined(STACK_USE_DHCP)
//If DHCP is enabled AND MAC is not linked yet, set our IP to 0
if (STACK_IS_DHCP_ENABLED)
{
if ( !MACIsLinked() )
{
#if (DEBUG_STACKTSK >= LOG_INFO)
debugPutMsg(1); //@mxd:1:DHCP Enabled but MAC not linked yet - set IP to 0.0.0.0
#endif
//IP address must be 0.0.0.0 before DHCP has obtained a valid IP address
MY_IP_BYTE1 = 0;
MY_IP_BYTE2 = 0;
MY_IP_BYTE3 = 0;
MY_IP_BYTE4 = 0;
stackFlags.bits.bInConfigMode = TRUE;
DHCPReset();
}
}
#endif
break;
}
lbContinue = TRUE;
if ( type.MACFrameType == MAC_IP ) {
smStack = SM_STACK_IP;
#if (DEBUG_STACKTSK >= LOG_DEBUG)
debugPutMsg(2); //@mxd:2:Reading MAC IP header
#endif
}
else if ( type.MACFrameType == MAC_ARP ) {
smStack = SM_STACK_ARP;
#if (DEBUG_STACKTSK >= LOG_DEBUG)
debugPutMsg(3); //@mxd:3:Reading MAC ARP header
#endif
}
else {
MACRxbufDiscard();
#if (DEBUG_STACKTSK >= LOG_WARN)
debugPutMsg(4); //@mxd:4:Unknown MAC header read, MAC Frame Type = 0x%x
debugPutByteHex(type.MACFrameType);
#endif
}
break;
case SM_STACK_ARP:
lbContinue = FALSE;
if ( ARPProcess() )
smStack = SM_STACK_IDLE;
break;
case SM_STACK_IP:
if ( IPGetHeader(&destIP, /* Get Destination IP Address as received in IP header */
&remoteNode,
&type.IPFrameType,
&dataCount) )
{
lbContinue = TRUE;
if ( type.IPFrameType == IP_PROT_ICMP )
{
smStack = SM_STACK_ICMP;
#if defined(STACK_USE_IP_GLEANING)
if ( stackFlags.bits.bInConfigMode )
{
/*
* Accoriding 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 ( destIP.Val != 0xffffffff )
{
stackFlags.bits.bInConfigMode = FALSE;
MY_IP_BYTE1 = destIP.v[0];
MY_IP_BYTE2 = destIP.v[1];
MY_IP_BYTE3 = destIP.v[2];
MY_IP_BYTE4 = destIP.v[3];
#if defined(STACK_USE_DHCP)
/*
* If DHCP and IP gleaning is enabled at the
* same time, we must ensuer that once we have
* IP address through IP gleaning, we abort
* any pending DHCP requests and do not renew
* any new DHCP configuration.
*/
DHCPAbort();
#endif
}
}
#endif
}
#if defined(STACK_USE_TCP)
else if ( type.IPFrameType == IP_PROT_TCP )
smStack = SM_STACK_TCP;
#endif
#if defined(STACK_USE_UDP)
else if ( type.IPFrameType == IP_PROT_UDP )
smStack = SM_STACK_UDP;
#endif
else
{
lbContinue = FALSE;
MACRxbufDiscard();
smStack = SM_STACK_IDLE;
}
}
else
{
MACRxbufDiscard();
smStack = SM_STACK_IDLE;
}
break;
#if defined(STACK_USE_UDP)
case SM_STACK_UDP:
//tempLocalIP.v[0] = MY_IP_BYTE1;
//tempLocalIP.v[1] = MY_IP_BYTE2;
//tempLocalIP.v[2] = MY_IP_BYTE3;
//tempLocalIP.v[3] = MY_IP_BYTE4;
if ( UDPProcess(&remoteNode, &destIP, dataCount) )
smStack = SM_STACK_IDLE;
lbContinue = FALSE;
break;
#endif
#if defined(STACK_USE_TCP)
case SM_STACK_TCP:
//tempLocalIP.v[0] = MY_IP_BYTE1;
//tempLocalIP.v[1] = MY_IP_BYTE2;
//tempLocalIP.v[2] = MY_IP_BYTE3;
//tempLocalIP.v[3] = MY_IP_BYTE4;
//Will return TRUE if TCPProcess finished it's task, else FALSE
if ( TCPProcess(&remoteNode, &destIP, dataCount) )
smStack = SM_STACK_IDLE;
lbContinue = FALSE;
break;
#endif
case SM_STACK_ICMP:
smStack = SM_STACK_IDLE;
#if defined(STACK_USE_ICMP)
if ( dataCount <= (MAX_ICMP_DATA_LEN+9) )
{
if ( ICMPGet(&type.ICMPCode,
data,
(BYTE*)&dataCount,
&ICMPId,
&ICMPSeq) )
{
if ( type.ICMPCode == ICMP_ECHO_REQUEST )
{
lbContinue = TRUE;
smStack = SM_STACK_ICMP_REPLY;
}
else
{
smStack = SM_STACK_IDLE;
}
}
else
{
smStack = SM_STACK_IDLE;
}
}
#endif
MACRxbufDiscard();
break;
#if defined(STACK_USE_ICMP)
case SM_STACK_ICMP_REPLY:
if ( ICMPIsTxReady() )
{
ICMPPut(&remoteNode,
ICMP_ECHO_REPLY,
data,
(BYTE)dataCount,
ICMPId,
ICMPSeq);
smStack = SM_STACK_IDLE;
}
break;
#endif
}
}
#if defined(STACK_USE_TCP)
// Perform timed TCP FSM.
TCPTick();
#endif
#if defined(STACK_USE_DHCP)
/*
* 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() )
stackFlags.bits.bInConfigMode = FALSE;
#endif
//Perform routine MAC tasks
MACTask();
}
/******************************************************************************
* 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)
{
static WORD dataCount;
IP_ADDR tempLocalIP;
BOOL lbContinue;
#if defined(STACK_USE_ICMP)
static BYTE data[MAX_ICMP_DATA_LEN];
static WORD ICMPId, ICMPSeq;
#endif
union
{
BYTE MACFrameType;
BYTE IPFrameType;
ICMP_CODE ICMPCode;
} type;
do
{
lbContinue = FALSE;
switch(smStack)
{
case SM_STACK_IDLE:
case SM_STACK_MAC:
if ( !MACGetHeader(&remoteNode.MACAddr, &type.MACFrameType) )
{
#if defined(STACK_USE_DHCP)
// 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 ( !MACIsLinked() )
{
AppConfig.MyIPAddr.Val = 0x00000000ul;
AppConfig.Flags.bInConfigMode = TRUE;
DHCPReset();
}
}
#endif
break;
}
lbContinue = TRUE;
if ( type.MACFrameType == MAC_IP )
smStack = SM_STACK_IP;
else if ( type.MACFrameType == MAC_ARP )
smStack = SM_STACK_ARP;
else
MACDiscardRx();
break;
case SM_STACK_ARP:
if ( ARPProcess() )
smStack = SM_STACK_IDLE;
break;
case SM_STACK_IP:
if ( IPGetHeader(&tempLocalIP,&remoteNode,&type.IPFrameType,&dataCount) )
{
lbContinue = TRUE;
if ( type.IPFrameType == IP_PROT_ICMP )
{
smStack = SM_STACK_ICMP;
#if defined(STACK_USE_IP_GLEANING)
if(AppConfig.Flags.bInConfigMode && AppConfig.Flags.bIsDHCPEnabled)
{
/*
* Accoriding 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;
myDHCPBindCount--;
}
}
#endif
}
#if defined(STACK_USE_TCP)
else if ( type.IPFrameType == IP_PROT_TCP )
smStack = SM_STACK_TCP;
#endif
#if defined(STACK_USE_UDP)
else if ( type.IPFrameType == IP_PROT_UDP )
smStack = SM_STACK_UDP;
#endif
else // Unknown/unsupported higher level protocol
{
lbContinue = FALSE;
MACDiscardRx();
smStack = SM_STACK_IDLE;
}
}
else // Improper IP header version or checksum
{
MACDiscardRx();
smStack = SM_STACK_IDLE;
}
break;
#if defined(STACK_USE_UDP)
case SM_STACK_UDP:
if ( UDPProcess(&remoteNode, &tempLocalIP, dataCount) )
smStack = SM_STACK_IDLE;
break;
#endif
#if defined(STACK_USE_TCP)
case SM_STACK_TCP:
if ( TCPProcess(&remoteNode, &tempLocalIP, dataCount) )
smStack = SM_STACK_IDLE;
break;
#endif
case SM_STACK_ICMP:
smStack = SM_STACK_IDLE;
#if defined(STACK_USE_ICMP)
if ( dataCount <= (MAX_ICMP_DATA_LEN+8) )
{
if ( ICMPGet(&type.ICMPCode,data,(BYTE*)&dataCount,&ICMPId,&ICMPSeq) )
{
if ( type.ICMPCode == ICMP_ECHO_REQUEST )
{
lbContinue = TRUE;
smStack = SM_STACK_ICMP_REPLY;
}
}
}
#endif
MACDiscardRx();
break;
#if defined(STACK_USE_ICMP)
case SM_STACK_ICMP_REPLY:
if ( ICMPIsTxReady() )
{
ICMPPut(&remoteNode,ICMP_ECHO_REPLY,data,(BYTE)dataCount,ICMPId,ICMPSeq);
smStack = SM_STACK_IDLE;
}
break;
#endif
}
} while(lbContinue);
#if defined(STACK_USE_TCP)
TCPTick(); // Perform timed TCP FSM.
#endif
#if defined(STACK_USE_DHCP)
/*
* 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()) AppConfig.Flags.bInConfigMode = FALSE;
#endif
#if defined(STACK_USE_SNTP)
SNTPTask(); // Execute SNTP client FSM
#endif
#if defined(STACK_USE_NBNS)
NBNSTask(); // Execute NetBIOS name service task
#endif
}
int main() {
// Initialize Sockets and IP address containers
//
SOCKET serverSock, clientSock = INVALID_SOCKET;
IP_ADDR curr_ip, ip;
// Initialize buffer length variables
//
int rlen, sent, bytesSent;
// Initialize the Send/Recv buffers
//
char rbfr[10];
// Socket struct descriptor
//
struct sockaddr_in addr;
int addrlen = sizeof(struct sockaddr_in);
// System clock containers
//
unsigned int sys_clk, pb_clk;
// Initialize LED Variables:
// Setup the LEDs on the PIC32 board
// RD0, RD1 and RD2 as outputs
//
mPORTDSetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2 );
mPORTDClearBits(BIT_0 | BIT_1 | BIT_2); // Clear previous LED status.
// Setup the switches on the PIC32 board as inputs
//
mPORTDSetPinsDigitalIn(BIT_6 | BIT_7 | BIT_13); // RD6, RD7, RD13 as inputs
// Setup the system clock to use CPU frequency
//
sys_clk = GetSystemClock();
pb_clk = SYSTEMConfigWaitStatesAndPB(sys_clk);
// interrupts enabled
INTEnableSystemMultiVectoredInt();
// system clock enabled
SystemTickInit(sys_clk, TICKS_PER_SECOND);
// Initialize TCP/IP
//
TCPIPSetDefaultAddr(DEFAULT_IP_ADDR, DEFAULT_IP_MASK, DEFAULT_IP_GATEWAY,
DEFAULT_MAC_ADDR);
if (!TCPIPInit(sys_clk)) return -1;
DHCPInit();
// Port to bind socket to
//
addr.sin_port = 6653;
addr.sin_addr.S_un.S_addr = IP_ADDR_ANY;
// Initialize TCP server socket
//
if((serverSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) ==
SOCKET_ERROR) return -1;
// Ensure we bound to the socket. End Program if bind fails
//
if(bind(serverSock, (struct sockaddr*) &addr, addrlen ) ==
SOCKET_ERROR)
return -1;
// Listen to up to five clients on server socket
//
listen(serverSock, 5);
// We store our desired transfer paragraph
//
char myStr[] = "TCP/IP (Transmission Control Protocol/Internet Protocol) is "
"the basic communication language or protocol of the Internet. "
"It can also be used as a communications protocol in a private "
"network (either an intranet or an extranet). When you are set up "
"with direct access to the Internet, your computer is provided "
"with a copy of the TCP/IP program just as every other computer "
"that you may send messages to or get information from also has "
"a copy of TCP/IP. TCP/IP is a two-layer program. The higher "
"layer, Transmission Control Protocol, manages the assembling "
"of a message or file into smaller packets that are transmitted "
"over the Internet and received by a TCP layer that reassembles "
"the packets into the original message. The lower layer, "
"Internet Protocol, handles the address part of each packet so "
"that it gets to the right destination. Each gateway computer on "
"the network checks this address to see where to forward the "
"message. Even though some packets from the same message are "
"routed differently than others, they'll be reassembled at the "
"destination.\0";
// Chunk up our data
//
// Copy our string into our buffer
//
int tlen = strlen(myStr);
char tbfr1[tlen1+1];
// Loop forever
//
while(1) {
// Refresh TCIP and DHCP
//
TCPIPProcess();
DHCPTask();
// Get the machines IP address and save to variable
//
ip.Val = TCPIPGetIPAddr();
// DHCP server change IP address?
//
if(curr_ip.Val != ip.Val) curr_ip.Val = ip.Val;
// TCP Server Code
//
if(clientSock == INVALID_SOCKET) {
// Start listening for incoming connections
//
clientSock = accept(serverSock, (struct sockaddr*) &addr, &addrlen);
// Upon connection to a client blink LEDS.
//
if(clientSock != INVALID_SOCKET) {
setsockopt(clientSock, SOL_SOCKET, TCP_NODELAY,
(char*)&tlen, sizeof(int));
mPORTDSetBits(BIT_0); // LED1=1
DelayMsec(50);
mPORTDClearBits(BIT_0); // LED1=0
mPORTDSetBits(BIT_1); // LED2=1
DelayMsec(50);
mPORTDClearBits(BIT_1); // LED2=0
mPORTDSetBits(BIT_2); // LED3=1
DelayMsec(50);
mPORTDClearBits(BIT_2); // LED3=0
}
}
else {
// We are connected to a client already. We start
// by receiving the message being sent by the client
//
rlen = recvfrom(clientSock, rbfr, sizeof(rbfr), 0, NULL,
NULL);
// Check to see if socket is still alive
//
if(rlen > 0) {
// If the received message first byte is '02' it signifies
// a start of message
//
if (rbfr[0]==2) {
//mPORTDSetBits(BIT_0); // LED1=1
// Check to see if message begins with
// '0271' to see if the message is a a global reset
//
if(rbfr[1]==71) {
mPORTDSetBits(BIT_0); // LED1=1
DelayMsec(50);
mPORTDClearBits(BIT_0); // LED1=0
}
}
// If the received message starts with a second byte is
// '84' it signifies a initiate transfer
//
if(rbfr[1]==84){
mPORTDSetBits(BIT_2); // LED3=1
bytesSent = 0;
//sent = 0;
while (bytesSent < tlen){
memcpy(tbfr1, myStr+bytesSent, tlen1);
if (bytesSent > 1049){
tbfr1[tlen-bytesSent+1] = '\0';
send(clientSock, tbfr1, tlen-bytesSent+1, 0);
}
else{
tbfr1[tlen1] = '\0';
// Loop until we send the full message
//
send(clientSock, tbfr1, tlen1+1, 0);
}
bytesSent += tlen1;
DelayMsec(50);
}
mPORTDClearBits(BIT_2); // LED3=0
}
mPORTDClearBits(BIT_0); // LED1=0
}
// The client has closed the socket so we close as well
//
else if(rlen < 0) {
closesocket(clientSock);
clientSock = SOCKET_ERROR;
}
}
}
}
/*********************************************************************
* 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(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(!MACIsLinked())
{
AppConfig.MyIPAddr.Val = AppConfig.DefaultIPAddr.Val;
AppConfig.MyMask.Val = AppConfig.DefaultMask.Val;
DHCPFlags.bits.bDHCPServerDetected = FALSE;
AppConfig.Flags.bInConfigMode = TRUE;
DHCPReset();
}
// 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())
AppConfig.Flags.bInConfigMode = FALSE;
}
#endif
#if defined(STACK_USE_TCP)
// Perform all TCP time related tasks (retransmit, send acknowledge, close connection, etc)
TCPTick();
#endif
// Process as many incomming packets as we can
while(MACGetHeader(&remoteNode.MACAddr, &cFrameType))
{
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)
{
ICMPProcess(&remoteNode, dataCount);
#if defined(STACK_USE_IP_GLEANING)
if(AppConfig.Flags.bInConfigMode && AppConfig.Flags.bIsDHCPEnabled)
{
// Accoriding 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;
myDHCPBindCount--;
}
}
#endif
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)
{
UDPProcess(&remoteNode, &tempLocalIP, dataCount);
break;
}
#endif
break;
}
}
}
/*********************************************************************
* 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(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(!MACIsLinked())
{
AppConfig.MyIPAddr.Val = AppConfig.DefaultIPAddr.Val;
AppConfig.MyMask.Val = AppConfig.DefaultMask.Val;
DHCPFlags.bits.bDHCPServerDetected = FALSE;
AppConfig.Flags.bInConfigMode = TRUE;
DHCPReset();
}
// 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())
AppConfig.Flags.bInConfigMode = FALSE;
}
#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;
// 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)
{
// Accoriding 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;
myDHCPBindCount--;
}
}
#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) ||
(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;
}
}
}
