int CLocalSearch::ExecuteSharedFiles(int nMaximum)
{
CQuickLock oLock( Library.m_pSection );
CPtrList* pFiles = Library.Search( m_pSearch, nMaximum );
if ( pFiles == NULL ) return 0;
int nHits = pFiles->GetCount();
while ( pFiles->GetCount() )
{
int nInThisPacket = min( pFiles->GetCount(), (int)Settings.Gnutella.HitsPerPacket );
CreatePacket( nInThisPacket );
int nHitB = 0;
for ( int nHitA = 0 ; nHitA < nInThisPacket ; nHitA++ )
{
CLibraryFile* pFile = (CLibraryFile*)pFiles->RemoveHead();
if ( AddHit( pFile, nHitB ) ) nHitB ++;
}
WriteTrailer();
if ( nHitB > 0 ) DispatchPacket(); else DestroyPacket();
}
delete pFiles;
return nHits;
}
Server::~Server()
{
std::map<in_addr_t, std::vector<Packet *> >::iterator iterPackets;
unsigned int i;
for (iterPackets = m_mapPackets.begin(); iterPackets != m_mapPackets.end(); ++iterPackets)
{
for (i = 0; i < iterPackets->second.size(); i++)
DestroyPacket(iterPackets->second[i]);
}
}
void McuMessageHandler::SendBody(StruMcuPacket *packet, unsigned short id)
{
if((m_handshake == false) && (id != MCU_PACKET_HANDSHAKE))
{
LogUtility::Log(LOG_LEVEL_WARN, "McuMessageHandler::SendBody not handshake yet");
DestroyPacket(packet);
return;
}
McuPacket &content = packet->packet;
if(content.size() > MCU_MAX_CONTENT_SIZE)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::SendBody too large");
DestroyPacket(packet);
return;
}
PacketHead(packet, (unsigned short)id);
PacketCheckSumFlag(packet);
PushQueue(packet);
}
void CarModel::TransmitPacket(const Packet * packet)
{
std::vector<CarModel *> vecCars;
std::map<in_addr_t, InfrastructureNodeModel *> * pNodeRegistry;
std::map<in_addr_t, InfrastructureNodeModel *>::iterator iterNode;
unsigned int iBytesPerSec = GetTXRate();
struct timeval tTransmit = iBytesPerSec > 0 ? MakeTime((double)packet->GetLength() / iBytesPerSec) : timeval0;
unsigned int i;
Packet * pNewPacket = packet->clone();
// transmit message to all local cars, as well as to infrastructure nodes
g_pCarRegistry->acquireLock();
g_pCarRegistry->GetLocalCars(vecCars);
for (i = 0; i < vecCars.size(); i++) {
if (vecCars[i]->GetIPAddress() == packet->m_ID.srcID.ipCar || vecCars[i]->GetIPAddress() == m_ipCar)
continue;
pNewPacket->m_ipRX = vecCars[i]->GetIPAddress();
pNewPacket->m_tRX = pNewPacket->m_tTX + tTransmit;
pNewPacket->m_iRSSI = PACKET_RSSI_UNAVAILABLE;
pNewPacket->m_iSNR = PACKET_SNR_UNAVAILABLE;
vecCars[i]->ReceivePacket(pNewPacket);
}
g_pCarRegistry->releaseLock();
if (m_pCommModel != NULL && m_pCommModel->IsGateway())
{
pNodeRegistry = g_pInfrastructureNodeRegistry->acquireLock();
for (iterNode = pNodeRegistry->begin(); iterNode != pNodeRegistry->end(); ++iterNode)
{
if (iterNode->second != NULL)
{
pNewPacket->m_ipRX = iterNode->first;
pNewPacket->m_tRX = pNewPacket->m_tTX + tTransmit;
pNewPacket->m_iRSSI = PACKET_RSSI_UNAVAILABLE;
pNewPacket->m_iSNR = PACKET_SNR_UNAVAILABLE;
iterNode->second->ReceivePacket(pNewPacket);
}
}
g_pInfrastructureNodeRegistry->releaseLock();
}
// transmit message to all remaining network cars
pNewPacket->m_ipRX = 0;
pNewPacket->m_tRX = timeval0;
pNewPacket->m_iRSSI = PACKET_RSSI_UNAVAILABLE;
pNewPacket->m_iSNR = PACKET_SNR_UNAVAILABLE;
SendPacketToAll(pNewPacket);
AddHybridPacket((Packet*)packet);
DestroyPacket(pNewPacket);
}
void McuMessageHandler::ClearQueue()
{
pthread_mutex_lock(&m_queueMutex);
for(McuPacketFifo::iterator it = m_waitingQueue.begin(); it != m_waitingQueue.end(); it ++)
{
StruMcuPacket *packet = *it;
DestroyPacket(packet);
}
m_waitingQueue.clear();
pthread_mutex_unlock(&m_queueMutex);
}
void SendPacketToAll(const Packet * packet)
{
std::map<in_addr_t, Client *>::iterator iterConnection;
std::map<in_addr_t, Packet *>::iterator iterMapSendPackets;
unsigned char * pBuffer;
int iLength = 0;
//TODO: ignore calls if not connected to any clients
if(time(NULL) >= lastUpdateTime+1) //if it's time to send the packets
{
g_mutexClients.lock();
//loop over the map
for(iterMapSendPackets = mapSendPackets.begin(); iterMapSendPackets != mapSendPackets.end(); iterMapSendPackets++)
{
dbgprint("*");
pBuffer = iterMapSendPackets->second->ToBytes(iLength);
if (pBuffer == NULL)
{
g_mutexClients.unlock();
return;
}
for (iterConnection = g_mapClients.begin(); iterConnection != g_mapClients.end(); ++iterConnection)
{
if (iterConnection->first == iterMapSendPackets->second->m_ID.srcID.ipCar)
continue;
// change header for each client
*((in_addr_t *)(pBuffer + PACKET_IPRX_OFFSET)) = iterConnection->first;
if (iterConnection->second != NULL && iterConnection->second->Select())
iterConnection->second->Write(pBuffer, iLength);
}
free(pBuffer);
DestroyPacket(iterMapSendPackets->second);
}
g_mutexClients.unlock();
lastUpdateTime = time(NULL);
mapSendPackets.clear();
}
else //not time to send yet
{
dbgprint("-");
//add packets to map. be sure to clone
mapSendPackets[packet->m_ipTX] = packet->clone();
}
}
int McuMessageHandler::PopQueue(int id, int seq, unsigned long *data, unsigned long *data2)
{
int ret = 0;
pthread_mutex_lock(&m_queueMutex);
if(m_waitingQueue.size() <= 0)
{
LogUtility::Log(LOG_LEVEL_ERROR, "McuMessageHandler::PopQueue waiting queue empty.");
pthread_mutex_unlock(&m_queueMutex);
return -1;
}
StruMcuPacket *packet = *(m_waitingQueue.begin());
if((packet->id == id) && (packet->seq == seq))
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::PopQueue correct resp.");
if(data)
{
*data = packet->data;
}
if(data2)
{
*data2 = packet->data2;
}
m_waitingQueue.pop_front();
DestroyPacket(packet);
StopTimer(m_retryTimer);
if(m_waitingQueue.size() > 0)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::PopQueue send queue");
SendQueue();
}
}
else
{
LogUtility::Log(LOG_LEVEL_ERROR, "McuMessageHandler::PopQueue incorrect resp(%d, %04x).", packet->seq, packet->id);
ret = -1;
}
pthread_mutex_unlock(&m_queueMutex);
return ret;
}
int McuMessageHandler::PushQueue(StruMcuPacket *packet)
{
pthread_mutex_lock(&m_queueMutex);
if(m_waitingQueue.size() >= MCU_MAX_WAITING_QUEUE)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::PushQueue full");
pthread_mutex_unlock(&m_queueMutex);
DestroyPacket(packet);
return -1;
}
m_waitingQueue.push_back(packet);
if(m_waitingQueue.size() == 1)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::PushQueue empty");
SendQueue();
}
pthread_mutex_unlock(&m_queueMutex);
return 0;
}
//队列发送，分为音频队列和视频队列发送
static int SendDataToAvQueue(AvManager *Manager,void *data)
{
if(!Manager || !data)
return QUEUE_ERROR;
int type = GetPacketAttr(data);
MediaPacket *mpkt = (MediaPacket*)data;
if(Manager->masterClkByAV == NONE && type != NONE)
{
Manager->masterClkByAV = type;
switch(type)
{
case AUDIO:
printf("Auido first!\n");
break;
case VIDEO:
printf("Video first\n");
break;
}
}
if(mpkt->size > 0)
{
if(Manager->playAudio && type == AUDIO)
{
PutDataToTail(Manager->MediaAudio,mpkt);
}
else if(Manager->playVideo && type == VIDEO)
{
PutDataToTail(Manager->MediaVideo,mpkt);
}
else
DestroyPacket(mpkt);
}
return QUEUE_ERROR;
}
void McuMessageHandler::HandleRetryTimer(void *)
{
pthread_mutex_lock(&m_queueMutex);
if(m_waitingQueue.size() <= 0)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::HandleRetryTimer empty");
pthread_mutex_unlock(&m_queueMutex);
return ;
}
StruMcuPacket *packet = *(m_waitingQueue.begin());
if(packet->retry > MCU_MAX_RETRY_TIMES)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::HandleRetryTimer %d reach limit", packet->id);
m_waitingQueue.pop_front();
if((packet->id == MCU_POS_GET_PASSENGER) || (packet->id == MCU_POS_GET_DEAL))
{
int index = packet->data2;
m_passengerRecord[index].state = STATE_TIMER;
StartTimer(m_passengerRecord[index].posPassengerRecordTimer);
}
DestroyPacket(packet);
if(m_waitingQueue.size() > 0)
{
LogUtility::Log(LOG_LEVEL_DEBUG, "McuMessageHandler::HandleRetryTimer proceed to next message");
SendQueue();
}
}
else
{
SendPacket(packet);
packet->retry ++;
StartTimer(m_retryTimer);
}
pthread_mutex_unlock(&m_queueMutex);
}
int CarModel::ProcessEvent(SimEvent & event)
{
if (Model::ProcessEvent(event))
return 1;
switch (event.GetEventID())
{
case EVENT_CARMODEL_UPDATE:
{
if (m_pPhysModel != NULL)
m_pPhysModel->DoUpdate(event.GetTimestamp());
if (m_pLinkModel != NULL)
m_pLinkModel->DoUpdate(event.GetTimestamp());
if (m_pCommModel != NULL)
m_pCommModel->DoUpdate(event.GetTimestamp());
std::map<in_addr_t, SafetyPacket>::iterator iterCarMessage = m_mapKnownVehicles.begin();
while (iterCarMessage != m_mapKnownVehicles.end())
{
if (iterCarMessage->second.m_tTime + MakeTime(NETWORK_TIMEOUT_SECS, NETWORK_TIMEOUT_USECS) < event.GetTimestamp()) {
std::map<in_addr_t, SafetyPacket>::iterator iterCarMessageTemp = iterCarMessage;
++iterCarMessage;
m_mapKnownVehicles.erase(iterCarMessageTemp);
} else
++iterCarMessage;
}
if (IsActive())
{
std::vector<CarModel *> vecNeighbors;
g_pCarRegistry->GetCommunicatingCarsInRange(this, vecNeighbors);
m_msgNeighbors.tMessage = m_tTimestamp;
m_msgNeighbors.iNeighbors = vecNeighbors.size();
m_msgNeighbors.iCollisionCount = m_pPhysModel != NULL ? (m_pPhysModel->GetCollisionCount() - m_msgNeighbors.iAccumulatedCollisions) : 0;
m_msgNeighbors.iAccumulatedCollisions += m_msgNeighbors.iCollisionCount;
m_msgNeighbors.iMessages = m_pPhysModel != NULL ? (m_pPhysModel->GetMessageCount() - m_msgNeighbors.iAccumulatedMessages) : 0;
m_msgNeighbors.iAccumulatedMessages += m_msgNeighbors.iMessages;
#ifdef MULTILANETEST
m_msgNeighbors.iLane = m_iLane;
#endif
if (m_msgNeighbors.iCollisionCount > 0 || m_msgNeighbors.iMessages > 0 || m_msgNeighbors.iNeighbors > 0)
g_pLogger->WriteMessage(LOGFILE_NEIGHBORS, &m_msgNeighbors);
}
event.SetTimestamp(event.GetTimestamp() + m_tDelay);
g_pSimulator->m_EventQueue.AddEvent(event);
break;
}
case EVENT_CARMODEL_RXMESSAGEBEGIN:
{
Packet * pPacket = (Packet *)event.GetEventData();
bool bValid = (pPacket != NULL);
if (bValid && m_pCommModel != NULL && pPacket->m_ePacketType == ptSafety)
m_pCommModel->AddMessageToHistory(*(SafetyPacket *)pPacket);
if (bValid && m_pPhysModel != NULL)
bValid = m_pPhysModel->BeginProcessPacket(pPacket);
if (bValid && m_pLinkModel != NULL)
bValid = m_pLinkModel->BeginProcessPacket(pPacket);
if (bValid)
g_pSimulator->m_EventQueue.AddEvent(SimEvent(pPacket->m_tRX, EVENT_PRIORITY_HIGHEST, QString::null, m_strModelName, EVENT_CARMODEL_RXMESSAGEEND, pPacket, DestroyPacket));
else
DestroyPacket(pPacket);
break;
}
case EVENT_CARMODEL_RXMESSAGEEND:
{
std::map<in_addr_t, SafetyPacket>::iterator iterCarMessage;
std::map<PacketSequence, Event1Message>::iterator iterEvent1Message;
Packet * pPacket = (Packet *)event.GetEventData();
// process messages in the order that they were received
bool bValid = pPacket != NULL && m_pPhysModel != NULL && m_pPhysModel->EndProcessPacket(pPacket);
if (bValid)
bValid = m_pLinkModel != NULL && m_pLinkModel->EndProcessPacket(pPacket);
if (bValid)
{
switch (pPacket->m_ePacketType)
{
case ptGeneric:
{
Packet * pMsg = (Packet *)pPacket;
// received message successfully
//g_pLogger->LogInfo(QString("%1> ***Generic Packet\n").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar)));
g_pLogger->WriteMessage(LOGFILE_MESSAGES, pMsg);
g_pSimulator->m_mutexEvent1Log.lock();
if ((iterEvent1Message = g_pSimulator->m_mapEvent1Log.find(pMsg->m_ID.srcID)) != g_pSimulator->m_mapEvent1Log.end())
iterEvent1Message->second.iCars++;
g_pSimulator->m_mutexEvent1Log.unlock();
break;
}
case ptSafety:
{
SafetyPacket * pMsg = (SafetyPacket *)pPacket;
// received message successfully
g_pLogger->LogInfo(QString("%1> ***Safety: %2\n").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar)).arg((const char *)pMsg->m_pData));
if((const char *)pMsg->m_pData != NULL)
m_pMessageList->addMessage(QString("<SafetyPacket from %1 received by %2> %3").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar)).arg(IPAddressToString(pMsg->m_ipRX)).arg((const char *)pMsg->m_pData));
if (m_pCommModel)
m_pCommModel->AddMessageToRebroadcastQueue(*pMsg);
g_pLogger->WriteMessage(LOGFILE_MESSAGES, pMsg);
g_pSimulator->m_mutexEvent1Log.lock();
if ((iterEvent1Message = g_pSimulator->m_mapEvent1Log.find(pMsg->m_ID.srcID)) != g_pSimulator->m_mapEvent1Log.end())
iterEvent1Message->second.iCars++;
g_pSimulator->m_mutexEvent1Log.unlock();
break;
}
default:
break;
}
m_pLinkModel->AddReceivedPacket(pPacket);
}
DestroyPacket(pPacket);
break;
}
default:
break;
}
return 0;
}
//刷新显示线程
void *RenderAudio(void *arg)
{
if(!arg)
return NULL;
AvManager *manager = (AvManager*)arg;
MediaPacket spkt;
long avsize = 0;
int ret = 0;
//只有在没有停止信号下，才能不断地读取数据
for(;manager->avState != STOP;)
{
//如果是暂停且没有快进时，才可以不断等待
if(manager->avState == PAUSE && !manager->avSeek)
{
usSleep(DEFAULT_AV_WAIT);
continue;
}
ret = RecvDataFromAvQueue(manager->MediaAudio,&spkt);
if(ret < 0)
{
usSleep(DEFAULT_AV_WAIT);
continue;
}
if(manager->avSeek && !IsHardWareAccel())
{
FlushBuffers(AUDIO);
DestroyPacket(&spkt);
continue;
}
if(manager->audioDelay)
{
usSleep(manager->audioDelay);
manager->audioDelay = 0;
}
if(spkt.data && spkt.size > 0)
{
void *abuf = DecodeAudioStream(&spkt,&avsize);
//播放音乐
if(abuf && avsize > 0)
{
PlayWave(abuf,avsize);
//声音时间戳部分
manager->audioClock = (double)avsize/(double)manager->audioBasePara;
if(spkt.pts != AV_NOPTS_VALUE)
manager->playerClock = AVTimeToSecond(spkt.pts,manager->audioTimeBase) + manager->audioClock;
else
manager->playerClock += manager->audioClock;
manager->last_audio_pts = manager->playerClock;
}
}
else
FreeAlloc(spkt.data);
}
return NULL;
}
int CarModel::ProcessEvent(SimEvent & event)
{
if (Model::ProcessEvent(event))
return 1;
switch (event.GetEventID())
{
case EVENT_CARMODEL_UPDATE:
{
if (m_pPhysModel != NULL)
m_pPhysModel->DoUpdate(event.GetTimestamp());
if (m_pLinkModel != NULL)
m_pLinkModel->DoUpdate(event.GetTimestamp());
if (m_pCommModel != NULL)
m_pCommModel->DoUpdate(event.GetTimestamp());
std::map<in_addr_t, SafetyPacket>::iterator iterCarMessage = m_mapKnownVehicles.begin();
while (iterCarMessage != m_mapKnownVehicles.end())
{
if (iterCarMessage->second.m_tTime + MakeTime(NETWORK_TIMEOUT_SECS, NETWORK_TIMEOUT_USECS) < event.GetTimestamp()) {
std::map<in_addr_t, SafetyPacket>::iterator iterCarMessageTemp = iterCarMessage;
++iterCarMessage;
m_mapKnownVehicles.erase(iterCarMessageTemp);
} else
++iterCarMessage;
}
if (IsActive())
{
std::vector<CarModel *> vecNeighbors;
g_pCarRegistry->GetCommunicatingCarsInRange(this, vecNeighbors);
m_msgNeighbors.tMessage = m_tTimestamp;
m_msgNeighbors.iNeighbors = vecNeighbors.size();
m_msgNeighbors.iCollisionCount = m_pPhysModel != NULL ? (m_pPhysModel->GetCollisionCount() - m_msgNeighbors.iAccumulatedCollisions) : 0;
m_msgNeighbors.iAccumulatedCollisions += m_msgNeighbors.iCollisionCount;
m_msgNeighbors.iMessages = m_pPhysModel != NULL ? (m_pPhysModel->GetMessageCount() - m_msgNeighbors.iAccumulatedMessages) : 0;
m_msgNeighbors.iAccumulatedMessages += m_msgNeighbors.iMessages;
#ifdef MULTILANETEST
m_msgNeighbors.iLane = m_iLane;
#endif
if (m_msgNeighbors.iCollisionCount > 0 || m_msgNeighbors.iMessages > 0 || m_msgNeighbors.iNeighbors > 0)
g_pLogger->WriteMessage(LOGFILE_NEIGHBORS, &m_msgNeighbors);
}
event.SetTimestamp(event.GetTimestamp() + m_tDelay);
g_pSimulator->m_EventQueue.AddEvent(event);
break;
}
case EVENT_CARMODEL_RXMESSAGEBEGIN:
{
Packet * pPacket = (Packet *)event.GetEventData();
bool bValid = (pPacket != NULL);
if (bValid && m_pCommModel != NULL && pPacket->m_ePacketType == ptSafety)
m_pCommModel->AddMessageToHistory(*(SafetyPacket *)pPacket);
if (bValid && m_pPhysModel != NULL)
bValid = m_pPhysModel->BeginProcessPacket(pPacket);
if (bValid && m_pLinkModel != NULL)
bValid = m_pLinkModel->BeginProcessPacket(pPacket);
if (bValid)
g_pSimulator->m_EventQueue.AddEvent(SimEvent(pPacket->m_tRX, EVENT_PRIORITY_HIGHEST, QString::null, m_strModelName, EVENT_CARMODEL_RXMESSAGEEND, pPacket, DestroyPacket));
else
DestroyPacket(pPacket);
break;
}
case EVENT_CARMODEL_RXMESSAGEEND:
{
std::map<in_addr_t, SafetyPacket>::iterator iterCarMessage;
std::map<PacketSequence, Event1Message>::iterator iterEvent1Message;
Packet * pPacket = (Packet *)event.GetEventData();
// process messages in the order that they were received
bool bValid = pPacket != NULL && m_pPhysModel != NULL && m_pPhysModel->EndProcessPacket(pPacket);
if (bValid)
bValid = m_pLinkModel != NULL && m_pLinkModel->EndProcessPacket(pPacket);
if (bValid)
{
switch (pPacket->m_ePacketType)
{
case ptGeneric:
{
Packet * pMsg = (Packet *)pPacket;
// received message successfully
//g_pLogger->LogInfo(QString("%1> ***Generic Packet\n").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar)));
g_pLogger->WriteMessage(LOGFILE_MESSAGES, pMsg);
g_pSimulator->m_mutexEvent1Log.lock();
if ((iterEvent1Message = g_pSimulator->m_mapEvent1Log.find(pMsg->m_ID.srcID)) != g_pSimulator->m_mapEvent1Log.end())
iterEvent1Message->second.iCars++;
g_pSimulator->m_mutexEvent1Log.unlock();
break;
}
case ptSafety:
{
SafetyPacket * pMsg = (SafetyPacket *)pPacket;
//printf("m_iLane = %u m_iHeading = %d", m_iLane, m_iHeading);
// received message successfully
if((sin( pMsg->m_iHeading * 3.14/18000) * sin( m_iHeading * 3.14/18000) + cos( pMsg->m_iHeading *3.14/18000)* cos( m_iHeading *3.14/18000) >= 0) && (( m_ptPosition.m_iLong - pMsg->m_ptPosition.m_iLong ) * sin( pMsg->m_iHeading * 3.14/18000) + (m_ptPosition.m_iLat - pMsg->m_ptPosition.m_iLat) * cos( pMsg->m_iHeading *3.14/18000) > 0))
break;
if (!QString((const char*)pMsg->m_pData).contains (QString("@%1 ").arg(IPAddressToString(pMsg->m_ipRX)))){
if((const char *)pMsg->m_pData != NULL){
time_t timer = time(NULL);
printf("%s ", ctime(&timer));
g_pLogger->LogInfo(QString("[From %1 Receiv %2: %3]\n").arg(IPAddressToString(pMsg->m_ID.srcID.ipCar)).arg(IPAddressToString(pMsg->m_ipRX)).arg((const char *)pMsg->m_pData).ascii());
QString temp = QString("%1@%2 ").arg((const char *)pMsg->m_pData).arg(IPAddressToString(pMsg->m_ipRX));
free(pMsg->m_pData);
unsigned char * temp_c_string = (unsigned char *)calloc (temp.length()+1, sizeof(unsigned char));
const char * const_c_string = temp.ascii();
for (int i = 0 ; i < temp.length(); i++) temp_c_string[i]=const_c_string[i];
temp_c_string[temp.length()] = '\0';
pMsg->m_pData = temp_c_string;
pMsg->m_iDataLength = sizeof(unsigned char)*(temp.length()+1);
}
if (m_pCommModel)
m_pCommModel->AddMessageToRebroadcastQueue(*pMsg);
g_pLogger->WriteMessage(LOGFILE_MESSAGES, pMsg);
g_pSimulator->m_mutexEvent1Log.lock();
if ((iterEvent1Message = g_pSimulator->m_mapEvent1Log.find(pMsg->m_ID.srcID)) != g_pSimulator->m_mapEvent1Log.end())
iterEvent1Message->second.iCars++;
g_pSimulator->m_mutexEvent1Log.unlock();
}
break;
}
default:
break;
}
m_pLinkModel->AddReceivedPacket(pPacket);
}
DestroyPacket(pPacket);
break;
}
default:
break;
}
return 0;
}
void Server::run()
{
Packet * pPacket = NULL, * pNewPacket = NULL;
unsigned char * pNewMessage;
int iNewMessageLength = 0;
in_addr_t ipTX;
std::map<in_addr_t, in_addr_t> mapNewCars;
struct timeval tWait = MakeTime(SERVER_WAIT_SECS, SERVER_WAIT_USECS);
std::map<in_addr_t, std::vector<Packet *> >::iterator iterPackets;
std::map<in_addr_t, Buffer>::iterator iterBuffer;
std::map<in_addr_t, CarModel *> * pCarRegistry;
std::map<in_addr_t, InfrastructureNodeModel *> * pNodeRegistry;
std::map<in_addr_t, CarModel *>::iterator iterCarReceiver;
std::map<in_addr_t, InfrastructureNodeModel *>::iterator iterNode;
struct timeval tRX;
char iRSSI, iSNR;
fd_set rfds;
std::list<ReadBuffer> listRead;
std::list<ReadBuffer>::iterator iterRead;
while (!m_bCancelled)
{
// get any waiting messages
m_mutexConnections.lock();
if (FillFDs(&rfds) && Select(&rfds, tWait))
{
Read(&rfds, listRead);
for (iterRead = listRead.begin(); iterRead != listRead.end(); ++iterRead)
{
ipTX = ntohl(iterRead->sFrom.sin_addr.s_addr);
// if new message is not null, add it to the current buffer
if (iterRead->pData != NULL)
m_mapBuffers[ipTX] += Buffer(iterRead->pData, iterRead->iLength);
}
listRead.clear();
}
m_mutexConnections.unlock();
// process non-empty buffers into messages
for (iterBuffer = m_mapBuffers.begin(); iterBuffer != m_mapBuffers.end(); ++iterBuffer)
{
if (iterBuffer->second.m_iLength > 0)
{
//printf("processing buffer..........\n");
//fflush(stdout);
unsigned char * pNew = NULL;
pCarRegistry = g_pCarRegistry->acquireLock();
pNodeRegistry = g_pInfrastructureNodeRegistry->acquireLock();
m_mutexBuffers.lock();
pNewMessage = iterBuffer->second.m_pData;
iNewMessageLength = (signed)iterBuffer->second.m_iLength;
tRX = GetCurrentTime();
iRSSI = rssi();
iSNR = snr();
while (iNewMessageLength >= (signed)PACKET_MINIMUM_LENGTH && (pPacket = CreatePacket(*(const PacketType *)pNewMessage)) != NULL) {
//printf("got packet...\n");
if (!pPacket->FromBytes(pNewMessage, iNewMessageLength))
{
//printf("failed...\n");
DestroyPacket(pPacket);
iNewMessageLength = 0;
break;
}
//if(((SafetyPacket*)pPacket)->m_ePacketType == ptSafety)
// printf("data: %s\n", ((SafetyPacket*)pPacket)->m_pData);
//if(((Packet*)pPacket)->m_ePacketType == ptGeneric)
// printf("long: %ld\n", ((Packet*)pPacket)->m_ptTXPosition.m_iLong);
// add it to the proper message buffer
pPacket->m_tRX = tRX;
pPacket->m_iRSSI = iRSSI;
pPacket->m_iSNR = iSNR;
pNewPacket = pPacket->clone();
for (iterCarReceiver = pCarRegistry->begin(); iterCarReceiver != pCarRegistry->end(); ++iterCarReceiver)
{
if (iterCarReceiver->second != NULL && iterCarReceiver->second->GetOwnerIPAddress() == CARMODEL_IPOWNER_LOCAL && iterCarReceiver->first != pPacket->m_ipTX) {
pNewPacket->m_ipRX = iterCarReceiver->first;
iterCarReceiver->second->ReceivePacket(pNewPacket);
}
}
for (iterNode = pNodeRegistry->begin(); iterNode != pNodeRegistry->end(); ++iterNode)
{
if (iterNode->second != NULL && iterNode->first != pPacket->m_ipTX)
{
pNewPacket->m_ipRX = iterNode->first;
iterNode->second->ReceivePacket(pNewPacket);
}
}
DestroyPacket(pNewPacket);
iterCarReceiver = pCarRegistry->find(pPacket->m_ID.srcID.ipCar);
iterNode = pNodeRegistry->find(pPacket->m_ID.srcID.ipCar);
if ((iterCarReceiver == pCarRegistry->end() || iterCarReceiver->second == NULL || iterCarReceiver->second->GetOwnerIPAddress() != CARMODEL_IPOWNER_LOCAL) && (iterNode == pNodeRegistry->end() || iterNode->second == NULL))
{
//printf("processing..................................\n");
mapNewCars[pPacket->m_ID.srcID.ipCar] = iterBuffer->first;
iterPackets = m_mapPackets.find(pPacket->m_ID.srcID.ipCar);
if (iterPackets == m_mapPackets.end())
iterPackets = m_mapPackets.insert(std::pair<in_addr_t, std::vector<Packet *> >(pPacket->m_ID.srcID.ipCar, std::vector<Packet *>())).first;
iterPackets->second.push_back(pPacket);
push_heap(iterPackets->second.begin(), iterPackets->second.end(), ComparePacketPtrs);
}
else
DestroyPacket(pPacket);
}
m_mutexBuffers.unlock();
g_pInfrastructureNodeRegistry->releaseLock();
g_pCarRegistry->releaseLock();
if (iNewMessageLength > 0)
pNew = (unsigned char *)memcpy(malloc(iNewMessageLength), pNewMessage, iNewMessageLength);
iterBuffer->second = Buffer(pNew, iNewMessageLength);
}
}
//add new network car to list
if (!mapNewCars.empty()) {
g_pSimulator->m_ModelMgr.AddNetworkCars(mapNewCars);
mapNewCars.clear();
}
//sleep(1);
}
}
