/*********************************************************************
* Function: void StackInit(void)
*
* PreCondition: None
*
* Input: None
*
* Output: Stack and its componets are initialized
*
* Side Effects: None
*
* Note: This function must be called before any of the
* stack or its component routines are used.
*
********************************************************************/
void StackInit(void)
{
smStack = SM_STACK_IDLE;
#if defined(STACK_USE_IP_GLEANING) || defined(STACK_USE_DHCP_CLIENT)
/*
* If DHCP or IP Gleaning is enabled,
* startup in Config Mode.
*/
AppConfig.Flags.bInConfigMode = TRUE;
#endif
// Seed the LFSRRand() function
LFSRSeedRand(GenerateRandomDWORD());
MACInit();
#if defined(WF_CS_TRIS) && defined(STACK_USE_EZ_CONFIG) && !defined(__18CXX)
WFEasyConfigInit();
#endif
ARPInit();
#if defined(STACK_USE_UDP)
UDPInit();
#endif
#if defined(STACK_USE_TCP)
TCPInit();
#endif
#if defined(STACK_USE_BERKELEY_API)
BerkeleySocketInit();
#endif
#if defined(STACK_USE_HTTP2_SERVER)
HTTPInit();
#endif
#if defined(STACK_USE_RSA)
RSAInit();
#endif
#if defined(STACK_USE_SSL)
SSLInit();
#endif
#if defined(STACK_USE_FTP_SERVER) && defined(STACK_USE_MPFS2)
FTPInit();
#endif
#if defined(STACK_USE_SNMP_SERVER)
SNMPInit();
#endif
#if defined(STACK_USE_DHCP_CLIENT)
DHCPInit(0);
if(!AppConfig.Flags.bIsDHCPEnabled)
{
DHCPDisable(0);
}
#endif
#if defined(STACK_USE_AUTO_IP)
AutoIPInit(0);
#endif
#if defined(STACK_USE_DYNAMICDNS_CLIENT)
DDNSInit();
#endif
#if defined(STACK_USE_RANDOM)
RandomInit();
#endif
}
/*********************************************************************
* 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;
}
}
}
void HTTPExecCmd(BYTE** argv, BYTE argc)
{
BYTE command;
BYTE var;
#if defined(ENABLE_REMOTE_CONFIG)
DWORD_VAL dwVal;
BYTE CurrentArg;
WORD_VAL TmpWord;
#endif
/*
* Design your pages such that they contain command code
* as a one character numerical value.
* Being a one character numerical value greatly simplifies
* the job.
*/
command = argv[0][0] - '0';
/*
* Find out the cgi file name and interpret parameters
* accordingly
*/
switch(command)
{
case CGI_CMD_DIGOUT: // ACTION=0
/*
* Identify the parameters.
* Compare it in upper case format.
*/
var = argv[1][0] - '0';
switch(var)
{
case CMD_LED1: // NAME=0
// Toggle LED.
LED1_IO ^= 1;
break;
case CMD_LED2: // NAME=1
// Toggle LED.
LED2_IO ^= 1;
break;
}
memcpypgm2ram((void*)argv[0], (ROM void*)COMMANDS_OK_PAGE, COMMANDS_OK_PAGE_LEN);
break;
#if defined(USE_LCD)
case CGI_CMD_LCDOUT: // ACTION=1
if(argc > 2u) // Text provided in argv[2]
{
// Convert %20 to spaces, and other URL transformations
UnencodeURL(argv[2]);
// Write 32 received characters or less to LCDText
if(strlen((char*)argv[2]) < 32u)
{
memset(LCDText, ' ', 32);
strcpy((char*)LCDText, (char*)argv[2]);
}
else
{
memcpy(LCDText, (void*)argv[2], 32);
}
// Write LCDText to the LCD
LCDUpdate();
}
else // No text provided
{
LCDErase();
}
memcpypgm2ram((void*)argv[0], (ROM void*)COMMANDS_OK_PAGE, COMMANDS_OK_PAGE_LEN);
break;
#endif
#if defined(ENABLE_REMOTE_CONFIG)
// Possibly useful code for remotely reconfiguring the board through
// HTTP
case CGI_CMD_RECONFIG: // ACTION=2
// Loop through all variables that we've been given
CurrentArg = 1;
while(argc > CurrentArg)
{
// Get the variable identifier (HTML "name"), and
// increment to the variable's value
TmpWord.v[1] = argv[CurrentArg][0];
TmpWord.v[0] = argv[CurrentArg++][1];
var = hexatob(TmpWord);
// Make sure the variable's value exists
if(CurrentArg >= argc)
break;
// Take action with this variable/value
switch(var)
{
case VAR_IP_ADDRESS:
case VAR_SUBNET_MASK:
case VAR_GATEWAY_ADDRESS:
{
// Convert the returned value to the 4 octect
// binary representation
if(!StringToIPAddress(argv[CurrentArg], (IP_ADDR*)&dwVal))
break;
// Reconfigure the App to use the new values
if(var == VAR_IP_ADDRESS)
{
// Cause the IP address to be rebroadcast
// through Announce.c or the RS232 port since
// we now have a new IP address
if(dwVal.Val != *(DWORD*)&AppConfig.MyIPAddr)
DHCPBindCount++;
// Set the new address
memcpy((void*)&AppConfig.MyIPAddr, (void*)&dwVal, sizeof(AppConfig.MyIPAddr));
}
else if(var == VAR_SUBNET_MASK)
memcpy((void*)&AppConfig.MyMask, (void*)&dwVal, sizeof(AppConfig.MyMask));
else if(var == VAR_GATEWAY_ADDRESS)
memcpy((void*)&AppConfig.MyGateway, (void*)&dwVal, sizeof(AppConfig.MyGateway));
}
break;
case VAR_DHCP:
if(AppConfig.Flags.bIsDHCPEnabled)
{
if(!(argv[CurrentArg][0]-'0'))
{
AppConfig.Flags.bIsDHCPEnabled = FALSE;
}
}
else
{
if(argv[CurrentArg][0]-'0')
{
AppConfig.MyIPAddr.Val = 0x00000000ul;
AppConfig.Flags.bIsDHCPEnabled = TRUE;
AppConfig.Flags.bInConfigMode = TRUE;
DHCPInit(0);
}
}
break;
}
// Advance to the next variable (if present)
CurrentArg++;
}
// Save any changes to non-volatile memory
SaveAppConfig(&AppConfig);
// Return the same CONFIG.CGI file as a result.
memcpypgm2ram((void*)argv[0],
(ROM void*)CONFIG_UPDATE_PAGE, CONFIG_UPDATE_PAGE_LEN);
break;
#endif // #if defined(ENABLE_REMOTE_CONFIG)
default:
memcpypgm2ram((void*)argv[0], (ROM void*)COMMANDS_OK_PAGE, COMMANDS_OK_PAGE_LEN);
break;
}
}
/*********************************************************************
* Function: void StackInit(void)
*
* PreCondition: None
*
* Input: None
*
* Output: Stack and its componets are initialized
*
* Side Effects: None
*
* Note: This function must be called before any of the
* stack or its component routines are used.
*
********************************************************************/
void StackInit(void)
{
smStack = SM_STACK_IDLE;
#if defined(STACK_USE_IP_GLEANING) || defined(STACK_USE_DHCP_CLIENT)
/*
* If DHCP or IP Gleaning is enabled,
* startup in Config Mode.
*/
AppConfig.Flags.bInConfigMode = TRUE;
#endif
// Seed the rand() function
srand(GenerateRandomDWORD());
MACInit();
#if defined( ZG_CS_TRIS )
#if defined(ZG_CONFIG_LINKMGRII)
ZGLibInitialize();
ZGLinkMgrInit();
#endif
#endif
ARPInit();
#if defined(STACK_USE_UDP)
UDPInit();
#endif
#if defined(STACK_USE_TCP)
TCPInit();
#endif
#if defined(STACK_USE_BERKELEY_API)
BerkeleySocketInit();
#endif
#if defined(STACK_USE_HTTP_SERVER) || defined(STACK_USE_HTTP2_SERVER)
HTTPInit();
#endif
#if defined(STACK_USE_RSA)
RSAInit();
#endif
#if defined(STACK_USE_SSL)
SSLInit();
#endif
#if defined(STACK_USE_FTP_SERVER) && defined(STACK_USE_MPFS)
FTPInit();
#endif
#if defined(STACK_USE_SNMP_SERVER)
SNMPInit();
#endif
#if defined(STACK_USE_DHCP_CLIENT)
DHCPInit(0);
if(!AppConfig.Flags.bIsDHCPEnabled)
{
DHCPDisable(0);
}
#endif
#if defined(STACK_USE_DYNAMICDNS_CLIENT)
DDNSInit();
#endif
}
/*********************************************************************
* Function: void StackInit(void)
*
* PreCondition: None
*
* Input: None
*
* Output: Stack and its componets are initialized
*
* Side Effects: None
*
* Note: This function must be called before any of the
* stack or its component routines are used.
*
********************************************************************/
void StackInit(void)
{
static BOOL once = FALSE;
smStack = SM_STACK_IDLE;
#if defined(STACK_USE_IP_GLEANING) || defined(STACK_USE_DHCP_CLIENT)
/*
* If DHCP or IP Gleaning is enabled,
* startup in Config Mode.
*/
AppConfig.Flags.bInConfigMode = TRUE;
#endif
#if defined (WF_CS_TRIS) && defined (STACK_USE_DHCP_CLIENT)
g_DhcpRenew = FALSE;
g_DhcpRetryTimer = 0;
#endif
if (!once) {
// Seed the LFSRRand() function
LFSRSeedRand(GenerateRandomDWORD());
once = TRUE;
}
MACInit();
#if defined (WF_AGGRESSIVE_PS) && defined (WF_CS_TRIS)
WFEnableAggressivePowerSave();
#endif
#if defined(WF_CS_TRIS) && defined(STACK_USE_EZ_CONFIG) && !defined(__18CXX)
WFEasyConfigInit();
#endif
ARPInit();
#if defined(STACK_USE_UDP)
UDPInit();
#endif
#if defined(STACK_USE_TCP)
TCPInit();
#endif
#if defined(STACK_USE_BERKELEY_API)
BerkeleySocketInit();
#endif
#if defined(STACK_USE_HTTP2_SERVER)
HTTPInit();
#endif
#if defined(STACK_USE_RSA)
RSAInit();
#endif
#if defined(STACK_USE_SSL)
SSLInit();
#endif
#if defined(STACK_USE_FTP_SERVER) && defined(STACK_USE_MPFS2)
FTPInit();
#endif
#if defined(STACK_USE_SNMP_SERVER)
SNMPInit();
#endif
#if defined(STACK_USE_DHCP_CLIENT)
DHCPInit(0);
if(!AppConfig.Flags.bIsDHCPEnabled)
{
DHCPDisable(0);
}
#endif
#if defined(STACK_USE_AUTO_IP)
AutoIPInit(0);
#endif
#if defined(STACK_USE_DYNAMICDNS_CLIENT)
DDNSInit();
#endif
#if defined(STACK_USE_RANDOM)
RandomInit();
#endif
#if defined(STACK_USE_CCS_SMTP)
SMTPInit();
#endif
#if defined(STACK_USE_CCS_SNTP_CLIENT)
NTPInit();
#endif
#if defined(STACK_USE_CCS_GRATUITOUS_ARP)
GratArpInit();
#endif
#if defined(STACK_USE_CCS_HTTP1_SERVER) || defined(STACK_USE_CCS_HTTP2_SERVER)
HTTPInit();
#endif
#if defined(STACK_USE_CCS_TFTP_SERVER)
TFTPSInit();
#endif
}
/*********************************************************************
* Function: void StackInit(void)
*
* PreCondition: None
*
* Input: None
*
* Output: Stack and its componets are initialized
*
* Side Effects: None
*
* Note: This function must be called before any of the
* stack or its component routines are used.
*
********************************************************************/
void StackInit(void)
{
static bool once = false;
smStack = SM_STACK_IDLE;
#if defined(STACK_USE_IP_GLEANING) || defined(STACK_USE_DHCP_CLIENT)
/*
* If DHCP or IP Gleaning is enabled,
* startup in Config Mode.
*/
AppConfig.Flags.bInConfigMode = true;
#endif
#if defined (WF_CS_TRIS) && defined (STACK_USE_DHCP_CLIENT)
g_DhcpRenew = false;
g_DhcpRetryTimer = 0;
#endif
if (!once) {
// Seed the LFSRRand() function
LFSRSeedRand(GenerateRandomDWORD());
once = true;
}
MACInit();
#if defined(WF_CS_TRIS) && defined(STACK_USE_EZ_CONFIG) && !defined(__XC8)
WFEasyConfigInit();
#endif
ARPInit();
#if defined(STACK_USE_ANNOUNCE)
AnnounceInit();
#endif
#if defined(STACK_USE_UDP)
UDPInit();
#endif
#if defined(STACK_USE_TCP)
TCPInit();
#endif
#if defined(STACK_USE_BERKELEY_API)
BerkeleySocketInit();
#endif
#if defined(STACK_USE_HTTP2_SERVER)
HTTPInit();
#endif
#if defined(STACK_USE_RSA)
RSAInit();
#endif
#if defined(STACK_USE_SSL)
SSLInit();
#endif
#if defined(STACK_USE_FTP_SERVER) && defined(STACK_USE_MPFS2)
FTPInit();
#endif
#if defined(STACK_USE_DHCP_CLIENT)
DHCPInit(0);
if(!AppConfig.Flags.bIsDHCPEnabled)
{
DHCPDisable(0);
}
#endif
#if defined(STACK_USE_AUTO_IP)
AutoIPInit(0);
#endif
#if defined(STACK_USE_DYNAMICDNS_CLIENT)
DDNSInit();
#endif
#if defined(STACK_USE_RANDOM)
RandomInit();
#endif
#if defined(STACK_USE_NBNS)
NBNSInit();
#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;
}
}
}
}
