void serialWriteThread(void) { while(UDPToSerial) { int UDPReceivedBufferLength; // Hopefully!! the stack will buffer a few datagrams. if ((UDPReceivedBufferLength = receiveUDP())) { if(serialWriteBufferIn + UDPReceivedBufferLength < BUFFER_LENGTH) { // All fits in one go. memcpy(serialWriteBuffer+serialWriteBufferIn, UDPReceivedBuffer, UDPReceivedBufferLength); } else { memcpy(serialWriteBuffer+serialWriteBufferIn, UDPReceivedBuffer, BUFFER_LENGTH-serialWriteBufferIn); memcpy(serialWriteBuffer, UDPReceivedBuffer+BUFFER_LENGTH-serialWriteBufferIn, UDPReceivedBufferLength-BUFFER_LENGTH+serialWriteBufferIn); } serialWriteBufferIn = (serialWriteBufferIn+UDPReceivedBufferLength) % BUFFER_LENGTH; } if (serialWriteBufferIn > serialWriteBufferOut) { do { // Non-wrap-round case. serialWriteBufferOut += write(STDOUT_FILENO, serialWriteBuffer+serialWriteBufferOut, serialWriteBufferIn-serialWriteBufferOut); serialWriteBufferOut %= BUFFER_LENGTH; } while(serialWriteBufferIn > serialWriteBufferOut); } else if (serialWriteBufferIn < serialWriteBufferOut) { // wrap-round case while(serialWriteBufferOut < BUFFER_LENGTH) { serialWriteBufferOut += write(STDOUT_FILENO, serialWriteBuffer+serialWriteBufferOut, BUFFER_LENGTH-serialWriteBufferOut); } serialWriteBufferOut=0; while(serialWriteBufferOut < serialWriteBufferIn) { serialWriteBufferOut += write(STDOUT_FILENO, serialWriteBuffer+serialWriteBufferOut, serialWriteBufferIn-serialWriteBufferOut); } } else usleep(1000); } }
/*------------------------------------------------------------------------------------------------------------------------------------- FUNCTION: ServerRoutine INTERFACE: void CALLBACK ServerRoutine(DWORD Error, DWORD BytesTransferred, LPWSAOVERLAPPED Overlapped, DWORD InFlags) RETURNS: void NOTES: Gets called when there is an I/O request on the socket. Checks for control information and EOF on the socket, and normal packet data. Once data is received, it is written to a file for analysis --------------------------------------------------------------------------------------------------------------------------------------*/ void CALLBACK ServerRoutine(DWORD Error, DWORD BytesTransferred, LPWSAOVERLAPPED Overlapped, DWORD InFlags) { DWORD RecvBytes = 0, Index; DWORD Flags = 0; WSAEVENT EventArray[1] = { 0 }; WSAEVENT acceptEvent; // Reference the WSAOVERLAPPED structure as a SOCKET_INFORMATION structure LPSOCKET_INFORMATION SI = (LPSOCKET_INFORMATION)Overlapped; initSockInfo(SI, SI->Buffer, DATA_BUFSIZE); if (Error != 0) { int i = WSAGetLastError(); formatMessage("I/O operation failed"); } if (checkControlFormat(SI)) { formatMessage("Initial Packet Received"); sscanf(SI->DataBuf.buf, "%*s %d %d", &fileInfo->sizeOfPackets, &fileInfo->numberOfPackets); QueryPerformanceFrequency(&fileInfo->frequency); QueryPerformanceCounter(&fileInfo->startTimeStamp); } if (checkEOFFormat(SI)) { formatMessage("Final Packet Received"); exitThread = true; QueryPerformanceCounter(&fileInfo->endTimeStamp); fileInfo->protocol = protocol; return; } initSockInfo(SI, SI->Buffer, fileInfo->sizeOfPackets); //UDP if (protocol == UDP) { if ((acceptEvent = WSACreateEvent()) == WSA_INVALID_EVENT) { formatMessage("WSACreateEvent() failed"); ExitThread(1); } Index = WSAWaitForMultipleEvents(1, EventArray, FALSE, 2000, TRUE); if (Index == WSA_WAIT_TIMEOUT) { formatMessage("Timeout in UDP Server"); exitThread = true; return; } receiveUDP(SI, serverUDP, BytesTransferred, Flags); } if (protocol == TCP) receiveTCP(SI, RecvBytes, Flags); //Gather data logCommStats(SI, fileInfo, BytesTransferred); fwrite(SI->DataBuf.buf, sizeof(char), SI->DataBuf.len, serverFP); }
/*------------------------------------------------------------------------------------------------------------------------------------- FUNCTION: UDPWorkerThread INTERFACE: DWORD WINAPI UDPWorkerThread(LPVOID lpParameter) RETURNS: DWORD NOTES: Waits on the socket until there is data receieved. Once data is deteceted on the socket, the completion routine is called to handle the I/O on the socket. --------------------------------------------------------------------------------------------------------------------------------------*/ DWORD WINAPI UDPWorkerThread(LPVOID lpParameter) { DWORD Flags = 0; LPSOCKET_INFORMATION SocketInfo; WSAEVENT EventArray[1]; DWORD Index; DWORD RecvBytes = 0; WSAEVENT UDPEvent; // Create a socket information structure to associate with the accepted socket. if ((SocketInfo = (LPSOCKET_INFORMATION)GlobalAlloc(GPTR, sizeof(SOCKET_INFORMATION))) == NULL) { formatMessage("GlobalAlloc() failed"); return FALSE; } if ((UDPEvent = WSACreateEvent()) == WSA_INVALID_EVENT) { formatMessage("WSACreateEvent() failed"); ExitThread(1); } // Save the accept event in the event array. EventArray[0] = UDPEvent; // Fill in the details of our accepted socket. SocketInfo->Socket = sd; initSockInfo(SocketInfo, SocketInfo->Buffer, DATA_BUFSIZE); receiveUDP(SocketInfo, serverUDP, RecvBytes, Flags); while (TRUE) { Index = WSAWaitForMultipleEvents(1, EventArray, FALSE, WSA_INFINITE, TRUE); if (Index == WSA_WAIT_FAILED) { formatMessage("WSAWaitForMultipleEvents failed"); return FALSE; } if (Index != WAIT_IO_COMPLETION) { // An accept() call event is ready - break the wait loop //break; } if (Index == WAIT_IO_COMPLETION && exitThread == true) { formatMessage("Server Terminating"); exitThread = false; closesocket(SocketInfo->Socket); logDataFile(fileInfo); free(fileInfo); fclose(serverFP); WSACleanup(); return TRUE; } } }
/*------------------------------------------------------------------------------------------------------------------ -- FUNCTION: ServerRoutine -- DATE: 14/04/16 -- REVISIONS: (V1.0) -- DESIGNER: Martin Minkov -- PROGRAMMER: Martin Minkov -- INTERFACE: void CALLBACK ServerRoutine(DWORD Error, DWORD BytesTransferred, LPWSAOVERLAPPED Overlapped, DWORD InFlags) -- -- -- RETURNS: VOID -- NOTES: The completion routine used for UDP receiving. Constantly pushes valid data received into the circ buff so it can be used to play audio later. ----------------------------------------------------------------------------------------------------------------------*/ void CALLBACK ServerRoutine(DWORD Error, DWORD BytesTransferred, LPWSAOVERLAPPED Overlapped, DWORD InFlags) { DWORD RecvBytes = 0, Index; DWORD Flags = 0; WSAEVENT EventArray[1] = { 0 }; WSAEVENT acceptEvent; // Reference the WSAOVERLAPPED structure as a SOCKET_INFORMATION structure LPSOCKET_INFORMATION SOCKINFO = (LPSOCKET_INFORMATION)Overlapped; initSockInfo(SOCKINFO, SOCKINFO->Buffer, SOCKINFO->server); if (Error != 0) { qDebug() << "I/O operation failed with value" + Error; printf("%d", Error); fflush(stdout); GlobalFree(SOCKINFO); SetEvent(streamStop); return; } if ((acceptEvent = WSACreateEvent()) == WSA_INVALID_EVENT) { qDebug() <<"WSACreateEvent() failed"; GlobalFree(SOCKINFO); return; } Index = WSAWaitForMultipleEvents(1, EventArray, FALSE, 10000000, TRUE); if (Index == WSA_WAIT_TIMEOUT) { qDebug() <<"Timeout in UDP Server"; GlobalFree(SOCKINFO); return; } receiveUDP(SOCKINFO, streamServer, BytesTransferred, Flags); cData.push(SOCKINFO->Buffer, 60000); }
int main (int argc, char* argv[]){ int n; int udp = 1; if (argc == 2){ udp = 0; } if(udp){ printf("UDP\n"); n=receiveUDP(); if(n!=0){ printf("receiveUDP error %d\n", n); } } else{ printf("TCP\n"); n=receiveTCP(); if(n!=0){ printf("receiveTCP error %d\n", n); } } return 0; }
void Membership::listeningThread() { //char buffer[BUFFER_MAX]; struct Message msg; std::string sender; srand (time(NULL)); logFile<< std::endl <<"listeningThread: thread begins"<<std::endl; while (!killListeningThread) { if (members.empty()) { //In case the node decided to leave continue; } int byte_count = receiveUDP(sockfd, (char*)&msg, sizeof(msg), sender); logFile << "listeningThread: Receive message from: " << sender.c_str() << " "; logFile << "type: " << msg.type << "ttl: " << (int)msg.TTL << std::endl; if (byte_count != sizeof(msg)) { logFile << "ERROR listeningThread: size receiving incorrect: Message dropped" << std::endl; continue; } switch (msg.type) { case MSG_PING: pingMsg(msg, sender); break; case MSG_ACK: ackMsg(msg, sender); break; case MSG_PIGGY: piggyMsg(msg, sender); break; case MSG_PIGGY_PING: piggyPingMsg(msg, sender); break; case MSG_PIGGY_ACK: piggyAckMsg(msg, sender); break; case MSG_FAIL: failMsg(msg, sender); break; case MSG_JOIN: joinMsg(msg, sender); break; case MSG_LEAVE: leaveMsg(msg, sender); break; case MSG_ELECTION: electionMsg(msg, sender); break; case MSG_BULLY: bullyMsg(msg, sender); break; case MSG_NEWLEADER: newLeaderMsg(msg, sender); break; default: logFile<<"ERROR: listeningThread: received msg does not belong to a type"<<std::endl; } } }