void MessageQueue::ClearMessages()
{
if ( debug )
{
LOG( "%p:ClearMessages()", this );
}
for ( const char * msg = GetNextMessage(); msg != NULL; msg = GetNextMessage() )
{
LOG( "%p:ClearMessages: discarding %s", this, msg );
free( (void *)msg );
}
}
unsigned int BufferedTransformation::TransferMessagesTo2(BufferedTransformation &target, unsigned int &messageCount, const std::string &channel, bool blocking)
{
if (AttachedTransformation())
return AttachedTransformation()->TransferMessagesTo2(target, messageCount, channel, blocking);
else
{
unsigned int maxMessages = messageCount;
for (messageCount=0; messageCount < maxMessages && AnyMessages(); messageCount++)
{
unsigned int blockedBytes;
unsigned long transferredBytes;
while (AnyRetrievable())
{
transferredBytes = ULONG_MAX;
blockedBytes = TransferTo2(target, transferredBytes, channel, blocking);
if (blockedBytes > 0)
return blockedBytes;
}
if (target.ChannelMessageEnd(channel, GetAutoSignalPropagation(), blocking))
return 1;
bool result = GetNextMessage();
assert(result);
}
return 0;
}
}
bool wxGUIEventLoop::Dispatch()
{
MSG msg;
if ( !GetNextMessage(&msg) )
return false;
#if wxUSE_THREADS
wxASSERT_MSG( wxThread::IsMain(),
wxT("only the main thread can process Windows messages") );
static bool s_hadGuiLock = true;
static wxMsgList s_aSavedMessages;
// if a secondary thread owning the mutex is doing GUI calls, save all
// messages for later processing - we can't process them right now because
// it will lead to recursive library calls (and we're not reentrant)
if ( !wxGuiOwnedByMainThread() )
{
s_hadGuiLock = false;
// leave out WM_COMMAND messages: too dangerous, sometimes
// the message will be processed twice
if ( !wxIsWaitingForThread() || msg.message != WM_COMMAND )
{
MSG* pMsg = new MSG(msg);
s_aSavedMessages.Append(pMsg);
}
return true;
}
else
{
// have we just regained the GUI lock? if so, post all of the saved
// messages
//
// FIXME of course, it's not _exactly_ the same as processing the
// messages normally - expect some things to break...
if ( !s_hadGuiLock )
{
s_hadGuiLock = true;
wxMsgList::compatibility_iterator node = s_aSavedMessages.GetFirst();
while (node)
{
MSG* pMsg = node->GetData();
s_aSavedMessages.Erase(node);
ProcessMessage(pMsg);
delete pMsg;
node = s_aSavedMessages.GetFirst();
}
}
}
#endif // wxUSE_THREADS
ProcessMessage(&msg);
return true;
}
void Client::SendPackets()
{
msguse.Synchronize();
FillBuckets( messages );
messages.clear();
msguse.Release();
bool notdone = true;
unsigned num = GetMaxPackSend();
while ( notdone && --num )
{
unsigned char Buffer[MaxPacketSize];
unsigned offset = sizeof( UDPHeader );
while ( notdone = GetNextMessage( *reinterpret_cast<MessagePacket *>( Buffer + offset ) ) &&
( offset += sizeof( MessagePacket ) ) < MaxPacketSize );
unsigned Size = offset - sizeof( UDPHeader );
UDPHeader Header = { CW, GetId(), seqnum, lastseqnum, Size, MissedPackets };
packetsent.push_back( Tick( seqnum++, Clock() ) );
memcpy( Buffer, &Header, sizeof Header );
currentdatasent += offset;
int n = sendto( sock, ( char * )Buffer, offset, 0, ( sockaddr * )&serversin, sizeof( sockaddr_in ) );
Check( n );
}
}
/** Function to manage TMC data transmission and reception to and from the host. */
void TMC_Task(void)
{
/* Device must be connected and configured for the task to run */
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
TMC_MessageHeader_t MessageHeader;
uint8_t MessagePayload[128];
/* Try to read in a TMC message from the interface, process if one is available */
if (ReadTMCHeader(&MessageHeader))
{
/* Indicate busy */
LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
switch (MessageHeader.MessageID)
{
case TMC_MESSAGEID_DEV_DEP_MSG_OUT:
LastTransferLength = 0;
while (Endpoint_Read_Stream_LE(MessagePayload, MIN(MessageHeader.TransferSize, sizeof(MessagePayload)), &LastTransferLength) ==
ENDPOINT_RWSTREAM_IncompleteTransfer)
{
if (IsTMCBulkOUTReset)
break;
}
Endpoint_ClearOUT();
ProcessSentMessage(MessagePayload, LastTransferLength);
break;
case TMC_MESSAGEID_DEV_DEP_MSG_IN:
Endpoint_ClearOUT();
MessageHeader.TransferSize = GetNextMessage(MessagePayload);
MessageHeader.MessageIDSpecific.DeviceOUT.LastMessageTransaction = true;
WriteTMCHeader(&MessageHeader);
LastTransferLength = 0;
while (Endpoint_Write_Stream_LE(MessagePayload, MessageHeader.TransferSize, &LastTransferLength) ==
ENDPOINT_RWSTREAM_IncompleteTransfer)
{
if (IsTMCBulkINReset)
break;
}
Endpoint_ClearIN();
break;
default:
Endpoint_StallTransaction();
break;
}
LEDs_SetAllLEDs(LEDMASK_USB_READY);
}
/* All pending data has been processed - reset the data abort flags */
IsTMCBulkINReset = false;
IsTMCBulkOUTReset = false;
}
status_t
ServerLink::FlushWithReply(int32& code)
{
status_t status = Flush(B_INFINITE_TIMEOUT, true);
if (status < B_OK)
return status;
return GetNextMessage(code);
}
bool wxConsoleEventLoop::Dispatch()
{
MSG msg;
if ( !GetNextMessage(&msg) )
return false;
ProcessMessage(&msg);
return !m_shouldExit;
}
// ----------------------------------------------------------------------------
// Handle leave in the RunL()
// ----------------------------------------------------------------------------
//
EXPORT_C TInt CMPXMessageMonitor::RunError(TInt aError)
{
MPX_DEBUG3("-->CMPXMessageMonitor::RunError 0x%08x, error %d", this, aError);
if (KErrCancel!=aError && KErrServerTerminated!=aError)
{
GetNextMessage();
}
MPX_DEBUG3("<--CMPXMessageMonitor::RunError 0x%08x, error %d", this, aError);
return KErrNone;
}
void FSClient::Maintain()
{
//send a heart beat to the server
if(GetTickCount() - serverHeartBeatTimer > HEART_BEAT_WAIT)
{
net->Send(istring("heartbeat|"), serverhConn);
serverHeartBeatTimer = GetTickCount();
}
Networking::Message m = GetNextMessage();
if(m.GetSize() != 0)
HandleFileSaveMessage(m);
}
void MessageQueue::ClearMessages()
{
if ( debug )
{
LOG( "%p:ClearMessages()", this );
}
for ( ; ; )
{
const char * msg = GetNextMessage();
if ( !msg ) {
break;
}
LOG( "%p:ClearMessages: discarding %s", this, msg );
free( (void *)msg );
}
}
MessageQueue::~MessageQueue()
{
// Free any messages remaining on the queue.
for ( ; ; )
{
const char * msg = GetNextMessage();
if ( !msg ) {
break;
}
LOG( "%p:~MessageQueue: still on queue: %s", this, msg );
free( (void *)msg );
}
// Free the queue itself.
delete[] messages;
pthread_mutex_destroy( &mutex );
pthread_cond_destroy( &wake );
}
//Tx thread function
void *AgentTxThread(void *arg)
{
int errorReply = 0;
int checksum;
uint8_t msgSequence[MAX_AGENT_CONNECTIONS];
for (int i=0; i<MAX_AGENT_CONNECTIONS; i++) msgSequence[i] = 0;
//loop
while (1)
{
//wait for next message
psMessage_t *txMessage = GetNextMessage(&agentQueue);
for (int i=0; i<MAX_AGENT_CONNECTIONS; i++)
{
if (connected[i])
{
pthread_mutex_lock(&agentMtx);
int socket = txSocket[i];
//send STX
writeToSocket( socket, STX_CHAR, &checksum, &errorReply);
checksum = 0; //checksum starts from here
//send header
writeToSocket( socket, txMessage->header.length, &checksum, &errorReply);
writeToSocket( socket, ~txMessage->header.length, &checksum, &errorReply);
writeToSocket( socket, msgSequence[i]++, &checksum, &errorReply);
writeToSocket( socket, txMessage->header.source, &checksum, &errorReply);
writeToSocket( socket, txMessage->header.messageType, &checksum, &errorReply);
//send payload
uint8_t *buffer = (uint8_t *) &txMessage->packet;
uint8_t size = txMessage->header.length;
if (size > sizeof(psMessage_t) - SIZEOF_HEADER)
{
size = txMessage->header.length = sizeof(psMessage_t) - SIZEOF_HEADER;
}
while (size) {
writeToSocket( socket, *buffer, &checksum, &errorReply);
buffer++;
size--;
}
//write checksum
writeToSocket( socket, (checksum & 0xff), &checksum, &errorReply);
if (errorReply != 0)
{
ERRORPRINT("agent: Tx send error: %s\n", strerror(errno));
AGENTsendErrors;
close(socket);
txSocket[i] = -1;
connected[i] = false;
}
else
{
DEBUGPRINT("agent: %s message sent\n", psLongMsgNames[txMessage->header.messageType]);
AGENTmessagesSent++;
if (psDefaultTopics[txMessage->header.messageType] == LOG_TOPIC)
{
switch (txMessage->logPayload.severity)
{
case SYSLOG_INFO:
agentInfo--;
break;
case SYSLOG_WARNING:
agentWarning--;
break;
case SYSLOG_ERROR:
agentError--;
default:
break;
}
}
}
pthread_mutex_unlock(&agentMtx);
}
}
DoneWithMessage(txMessage);
}
return 0;
}
void CLANConnection::Run()
{
VERIFY(AfxSocketInit());
// Socket erzeugen, falls noch nicht geschehen
int nError;
if (!CreateSocket(nError))
{
if (m_pListener)
{
m_pListener->OnSocketError(nError, this);
m_pListener->OnConnectionLost(this);
}
return;
}
CAsyncSocket socket;
ASSERT(m_hSocket != INVALID_SOCKET);
socket.Attach(m_hSocket);
// IP-Adresse und tatsächlichen Port ermitteln
SOCKADDR_IN sockaddr;
memset(&sockaddr, 0, sizeof(sockaddr));
int nSockAddrLen = sizeof(SOCKADDR_IN);
if (!socket.GetSockName((SOCKADDR *)&sockaddr, &nSockAddrLen)) goto error;
m_nPort = ntohs(sockaddr.sin_port);
m_dwIP = ntohl(sockaddr.sin_addr.S_un.S_addr);
// main thread loop
BYTE buf[LAN_BUFSIZE];
while (!IsInterrupted())
{
// Senden
{
CReference<CLANMessage> message;
if (message = GetNextMessage())
{
// Magic Number
memcpy(buf, "BotE", 4);
// Nachricht serialisieren
CMemFile memFile(&buf[4], LAN_BUFSIZE - 4);
CArchive ar(&memFile, CArchive::store);
message->Serialize(ar);
ar.Close();
UINT nSize = memFile.GetPosition() + 4;
memFile.Detach();
// Empfänger setzen
memset(&sockaddr, 0, sizeof(sockaddr));
sockaddr.sin_family = AF_INET;
sockaddr.sin_addr.S_un.S_addr = htonl(message->GetReceiverIP());
sockaddr.sin_port = htons(message->GetReceiverPort());
// Nachricht versenden, setzt bei Fehler m_bInterrupted
if (!SendMessageTo(socket, message, buf, nSize, &sockaddr)) break;
// Broadcast-Nachricht auch an den lokalen Host senden
if (message->GetReceiverIP() == INADDR_BROADCAST)
{
sockaddr.sin_addr.S_un.S_addr = htonl(INADDR_LOOPBACK);
if (!SendMessageTo(socket, message, buf, nSize, &sockaddr))
break;
}
}
}
// Empfangen
memset(&sockaddr, 0, sizeof(sockaddr));
int nSockAddrLen = sizeof(sockaddr);
int nCount = socket.ReceiveFrom(&buf, LAN_BUFSIZE, (SOCKADDR *)&sockaddr, &nSockAddrLen);
if (nCount > 0)
{
// Magic Number prüfen
if (memcmp(&buf, "BotE", 4) != 0) continue;
// Nachricht deserialisieren
CMemFile memFile(&buf[4], nCount - 4);
CArchive ar(&memFile, CArchive::load);
CReference<CLANMessage> message(new CLANMessage());
message->Serialize(ar);
ar.Close();
memFile.Detach();
// IP und Port des Absenders
DWORD dwIP = ntohl(sockaddr.sin_addr.S_un.S_addr);
UINT nPort = ntohs(sockaddr.sin_port);
message->SetSenderIP(dwIP);
message->SetSenderPort(nPort);
// Ankunft einer Nachricht melden
if (m_pListener) m_pListener->OnMessageReceived(message, this);
}
else if (nCount == 0)
{
// "Verbindung" wurde getrennt
ASSERT(FALSE);
break;
}
else if (nCount == SOCKET_ERROR)
{
int nError = socket.GetLastError();
if (nError != WSAEWOULDBLOCK)
{
if (m_pListener) m_pListener->OnSocketError(nError, this);
// WSAECONNRESET tritt auf, wenn wir zuvor eine Nachricht an eine Adresse gesendet
// haben, an der kein Server läuft; Thread dann nicht abbrechen
if (nError != WSAECONNRESET)
{
__super::Interrupt();
break;
}
}
}
Sleep(50);
}
// verbleibende Nachrichten löschen
{
CReference<CLANMessage> message;
while (message = GetNextMessage())
{
if (m_pListener) m_pListener->OnMessageDiscarded(message, this);
}
}
// socket schließen, Thread beenden
socket.Close();
m_hSocket = INVALID_SOCKET;
if (m_bSendLost && m_pListener) m_pListener->OnConnectionLost(this);
return;
error:
if (m_pListener) m_pListener->OnSocketError(socket.GetLastError(), this);
m_hSocket = INVALID_SOCKET;
if (m_pListener) m_pListener->OnConnectionLost(this);
}
//thread to receive messages and respond
void *ResponderMessageThread(void *arg)
{
uint8_t requestor;
DEBUGPRINT("responder: thread started\n");
while (1)
{
psMessage_t *msg = GetNextMessage(&responderQueue);
//check message for response requirement
switch (msg->header.messageType)
{
case CONFIG:
if (msg->configPayload.responder == XBEE)
{
requestor = msg->configPayload.requestor;
DEBUGPRINT("responder: Send Config received\n");
configCount = 0;
#define optionmacro(name, var, minV, maxV, def) sendOptionConfig(name, var, minV, maxV, requestor);
#include "options.h"
#undef optionmacro
#define settingmacro(name, var, minV, maxV, def) sendSettingConfig(name, var, minV, maxV, requestor);
#include "settings.h"
#undef settingmacro
{
psMessage_t msg;
psInitPublish(msg, CONFIG_DONE);
msg.configPayload.requestor = requestor;
msg.configPayload.responder = XBEE;
msg.configPayload.count = configCount;
RouteMessage(&msg);
}
DEBUGPRINT("responder: Config Done\n");
}
break;
case PING_MSG:
{
if (msg->header.source != OVERMIND)
{
DEBUGPRINT("responder: APP Ping received\n");
psMessage_t msg2;
psInitPublish(msg2, PING_RESPONSE);
strcpy(msg2.responsePayload.subsystem, "BEE");
msg2.responsePayload.flags = (startFlag ? RESPONSE_FIRST_TIME : 0) | (agentOnline ? RESPONSE_AGENT_ONLINE : 0);
msg2.responsePayload.requestor = msg->requestPayload.requestor;
startFlag = 0;
RouteMessage(&msg2);
PublishConditions(true);
SendXBeeStats();
SendAgentStats();
}
}
break;
case NEW_SETTING:
DEBUGPRINT("responder: New Setting: %s = %f\n", msg->settingPayload.name, msg->settingPayload.value);
#define settingmacro(n, var, minV, maxV, def) if (strncmp(n,msg->settingPayload.name,PS_NAME_LENGTH) == 0)\
var = msg->settingPayload.value;\
sendSettingConfig(n, var, minV, maxV, 0);
#include "settings.h"
#undef settingmacro
if (strncmp("Power Level",msg->settingPayload.name,PS_NAME_LENGTH) == 0) SetPowerLevel((int) powerLevel);
break;
case SET_OPTION:
DEBUGPRINT("responder: Set Option: %s = %i\n", msg->optionPayload.name, msg->optionPayload.value);
#define optionmacro(n, var, minV, maxV, def) if (strncmp(n,msg->optionPayload.name,PS_NAME_LENGTH) == 0)\
var = msg->optionPayload.value;\
sendOptionConfig(n, var, minV, maxV, 0);
#include "options.h"
#undef optionmacro
break;
default:
//ignore anything else
break;
}
DoneWithMessage(msg);
}
return 0;
}
// ----------------------------------------------------------------------------
// 2nd phase construction:
// ----------------------------------------------------------------------------
//
void CMPXMessageMonitor::ConstructL()
{
MPX_FUNC_EX("CMPXMessageMonitor::ConstructL");
GetNextMessage();
}
