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; }