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