void WFTestUdpServer_Process(void)
{
unsigned char pcString[30];
int rc;
WORD i,count;
struct mCast_testing_context_t *mCast_Context = &mCast_testing_context_1;
if(socket_1 == INVALID_UDP_SOCKET)
{
mCast_Context->StateMachine = MDNS_RESPONDER_INIT;
}
switch(mCast_Context->StateMachine)
{
case MDNS_RESPONDER_INIT:
printf("Opening mCast socket_1 \r\n");
socket_1 = TCPIP_UDP_ServerOpen(IP_ADDRESS_TYPE_IPV4, port_1, 0);
socket_2 = TCPIP_UDP_ServerOpen(IP_ADDRESS_TYPE_IPV4, port_2, 0);
if(socket_1 == INVALID_UDP_SOCKET)
{
printf("Can't open mCast UDP-Socket \r\n");
return;
}
else
mCast_Context->StateMachine = MDNS_RESPONDER_LISTEN ;
/* Called from TCPIP_MDNS_Initialize. So return immediately */
break;
case MDNS_RESPONDER_LISTEN:
{
char buf_t[10];
count = TCPIP_UDP_GetIsReady(socket_1);
if(count == 0)return;
printf("[Get MCAST package at <");
while(count > 0)
{
int num = count > 30? 30:count;
count -= num;
rc = TCPIP_UDP_ArrayGet(socket_1, pcString, num);
for(i=0;i<rc;i++)
{
sprintf(buf_t,"%02x ",pcString[i]);
printf(buf_t);
}
}
printf(" ]\r\n\r\n");
break;
}
default:
break;
}
return;
}
void APP_Tasks( void )
{
static IPV4_ADDR dwLastIP[2] = { {-1}, {-1} };
IPV4_ADDR ipAddr;
int i;
switch(appData.state)
{
case APP_TCPIP_WAIT_FOR_IP:
// if the IP address of an interface has changed
// display the new value on the system console
nNets = TCPIP_STACK_NumberOfNetworksGet();
for (i = 0; i < nNets; i++)
{
netH = TCPIP_STACK_IndexToNet(i);
ipAddr.Val = TCPIP_STACK_NetAddress(netH);
if(dwLastIP[i].Val != ipAddr.Val)
{
dwLastIP[i].Val = ipAddr.Val;
SYS_CONSOLE_MESSAGE(TCPIP_STACK_NetNameGet(netH));
SYS_CONSOLE_MESSAGE(" IP Address: ");
SYS_CONSOLE_PRINT("%d.%d.%d.%d \r\n", ipAddr.v[0], ipAddr.v[1], ipAddr.v[2], ipAddr.v[3]);
if (ipAddr.v[0] != 0 && ipAddr.v[0] != 169) // Wait for a Valid IP
{
appData.state = APP_TCPIP_OPENING_SERVER;
}
}
}
break;
case APP_TCPIP_OPENING_SERVER:
{
SYS_CONSOLE_PRINT("Waiting for Client Connection on port: %d\r\n", SERVER_PORT);
appData.socket = TCPIP_UDP_ServerOpen(IP_ADDRESS_TYPE_IPV4, SERVER_PORT, 0);
if (appData.socket == INVALID_SOCKET)
{
SYS_CONSOLE_MESSAGE("Couldn't open server socket\r\n");
break;
}
appData.state = APP_TCPIP_WAIT_FOR_CONNECTION;
}
break;
case APP_TCPIP_WAIT_FOR_CONNECTION:
{
if (!TCPIP_UDP_IsConnected(appData.socket))
{
return;
}
else
{
// We got a connection
appData.state = APP_TCPIP_SERVING_CONNECTION;
SYS_CONSOLE_MESSAGE("Received a connection\r\n");
}
}
break;
case APP_TCPIP_SERVING_CONNECTION:
{
if (!TCPIP_UDP_IsConnected(appData.socket))
{
appData.state = APP_TCPIP_CLOSING_CONNECTION;
SYS_CONSOLE_MESSAGE("Connection was closed\r\n");
break;
}
int16_t wMaxGet, wMaxPut, wCurrentChunk;
uint16_t w, w2;
uint8_t AppBuffer[32];
// Figure out how many bytes have been received and how many we can transmit.
wMaxGet = TCPIP_UDP_GetIsReady(appData.socket); // Get UDP RX FIFO byte count
wMaxPut = UDPIsPutReady(appData.socket);
//SYS_CONSOLE_PRINT("\t%d bytes are available.\r\n", wMaxGet);
if (wMaxGet == 0)
{
break;
}
if (wMaxPut < wMaxGet)
{
wMaxGet = wMaxPut;
}
// Process all bytes that we can
// This is implemented as a loop, processing up to sizeof(AppBuffer) bytes at a time.
// This limits memory usage while maximizing performance. Single byte Gets and Puts are a lot slower than multibyte GetArrays and PutArrays.
wCurrentChunk = sizeof(AppBuffer);
for(w = 0; w < wMaxGet; w += sizeof(AppBuffer))
{
// Make sure the last chunk, which will likely be smaller than sizeof(AppBuffer), is treated correctly.
if(w + sizeof(AppBuffer) > wMaxGet)
wCurrentChunk = wMaxGet - w;
// Transfer the data out of the TCP RX FIFO and into our local processing buffer.
TCPIP_UDP_ArrayGet(appData.socket, AppBuffer, wCurrentChunk);
SYS_CONSOLE_PRINT("\tReceived a message of '%s'\r\n", AppBuffer);
// Perform the "ToUpper" operation on each data byte
for(w2 = 0; w2 < wCurrentChunk; w2++)
{
i = AppBuffer[w2];
if(i >= 'a' && i <= 'z')
{
i -= ('a' - 'A');
AppBuffer[w2] = i;
}
else if(i == '\e') //escape
{
SYS_CONSOLE_MESSAGE("Connection was closed\r\n");
}
}
SYS_CONSOLE_PRINT("\tSending a messages '%s'\r\n", AppBuffer);
// Transfer the data out of our local processing buffer and into the TCP TX FIFO.
TCPIP_UDP_ArrayPut(appData.socket, AppBuffer, wCurrentChunk);
TCPIP_UDP_Flush(appData.socket);
appData.state = APP_TCPIP_CLOSING_CONNECTION;
}
}
break;
case APP_TCPIP_CLOSING_CONNECTION:
{
// Close the socket connection.
TCPIP_UDP_Close(appData.socket);
appData.state = APP_TCPIP_OPENING_SERVER;
}
break;
default:
break;
}
}
/*********************************************************************
* Function: bool TCPIP_ANNOUNCE_Task(void)
*
* Summary: Announce callback task.
*
* PreCondition: Stack is initialized()
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: Recurring task used to listen for Discovery
* messages on the specified TCPIP_ANNOUNCE_PORT. These
* messages can be sent using the TCP/IP
* Discoverer tool. If one is received, this
* function will transmit a reply.
*
* Note: A UDP socket must be available before this
* function is called. It is freed at the end of
* the function. UDP_MAX_SOCKETS may need to be
* increased if other modules use UDP sockets.
********************************************************************/
bool TCPIP_ANNOUNCE_Task(TCPIP_NET_IF * pNetIf)
{
uint8_t i;
int netIx;
UDP_SOCKET s;
if(!pNetIf)
{
return false;
}
else
{
netIx = TCPIP_STACK_NetIxGet(pNetIf);
}
s = announceDcpt.skt;
switch(announceDcpt.sm)
{
case DISCOVERY_HOME:
// Open a UDP socket for inbound and outbound transmission
// Allow receive on any interface
s = TCPIP_UDP_ServerOpen(IP_ADDRESS_TYPE_IPV4, TCPIP_ANNOUNCE_PORT, 0);
if(s == INVALID_UDP_SOCKET)
{
return false;
}
if(!TCPIP_UDP_RemoteBind(s, IP_ADDRESS_TYPE_IPV4, TCPIP_ANNOUNCE_PORT, 0))
{
TCPIP_UDP_Close(s);
break;
}
if(!TCPIP_UDP_OptionsSet(s, UDP_OPTION_STRICT_PORT, (void*)true))
{
TCPIP_UDP_Close(s);
break;
}
announceDcpt.skt = s;
announceDcpt.sm++;
break;
case DISCOVERY_LISTEN:
// Do nothing if no data is waiting
if(!TCPIP_UDP_GetIsReady(s))
return false;
// See if this is a discovery query or reply
TCPIP_UDP_Get(s, &i);
TCPIP_UDP_Discard(s);
if(i != 'D')
return false;
// We received a discovery request, reply when we can
announceDcpt.sm++;
// No break needed. If we get down here, we are now ready for the DISCOVERY_REQUEST_RECEIVED state
case DISCOVERY_REQUEST_RECEIVED:
ANNOUNCE_Notify (pNetIf, DHCP_EVENT_BOUND, NULL); // fake a legitimate DHCP event
// Listen for other discovery requests
announceDcpt.sm = DISCOVERY_LISTEN;
break;
case DISCOVERY_DISABLED:
break;
}
return true;
}
