/**
* Handles a DHCP message.
*
* @returns true if handled, false if not.
* @param uMsgType The message type.
* @param pDhcpMsg The DHCP message.
* @param cb The size of the DHCP message.
*/
bool VBoxNetDhcp::handleDhcpMsg(uint8_t uMsgType, PCRTNETBOOTP pDhcpMsg, size_t cb)
{
if (pDhcpMsg->bp_op == RTNETBOOTP_OP_REQUEST)
{
NetworkManager *networkManager = NetworkManager::getNetworkManager();
switch (uMsgType)
{
case RTNET_DHCP_MT_DISCOVER:
return networkManager->handleDhcpReqDiscover(pDhcpMsg, cb);
case RTNET_DHCP_MT_REQUEST:
return networkManager->handleDhcpReqRequest(pDhcpMsg, cb);
case RTNET_DHCP_MT_DECLINE:
return networkManager->handleDhcpReqDecline(pDhcpMsg, cb);
case RTNET_DHCP_MT_RELEASE:
return networkManager->handleDhcpReqRelease(pDhcpMsg, cb);
case RTNET_DHCP_MT_INFORM:
debugPrint(0, true, "Should we handle this?");
break;
default:
debugPrint(0, true, "Unexpected.");
break;
}
}
return false;
}
virtual void run(void *arg)
{
Event ev;
if(isCollect)
{
EventAnswer *answ = ev.triggerAndCollect(name, buf, bufSize);
EventMessage msg(name, waitId, answ);
int msgLen;
char *msgBuf = msg.serialize(msgLen, msgManager);
msgManager->sendMessage(addr, msgBuf, msgLen);
delete []msgBuf;
delete answ;
Thread *thread = (Thread *)arg;
delete thread;
}
else
{
ev.triggerAndWait(name, buf, bufSize);
EventMessage msg(name, waitId);
int msgLen;
char *msgBuf = msg.serialize(msgLen, msgManager);
msgManager->sendMessage(addr, msgBuf, msgLen);
delete []msgBuf;
Thread *thread = (Thread *)arg;
delete thread;
}
}
void ApplicationManager::luaError(const char *error)
{
glog_e("%s", error);
if (player_ == true)
{
running_ = false;
networkManager_->printToServer(error, -1);
networkManager_->printToServer("\n", -1);
application_->deinitialize();
application_->initialize();
}
else
{
JNIEnv *env = g_getJNIEnv();
jstring jerrormsg = env->NewStringUTF(error);
jclass localRefCls = env->FindClass("com/giderosmobile/android/player/GiderosApplication");
jmethodID throwError = env->GetStaticMethodID(localRefCls, "throwLuaException", "(Ljava/lang/String;)V");
env->CallStaticVoidMethod(localRefCls, throwError, jerrormsg);
env->DeleteLocalRef(jerrormsg);
env->DeleteLocalRef(localRefCls);
//g_exit();
}
}
void Tst_connectionagent::tst_networkInstance()
{
NetworkManager *netman = NetworkManagerFactory::createInstance();
QString currentState = netman->state();
QConnectionAgent::instance();
QVERIFY(currentState == netman->state());
}
void* NetworkManager::threadConnexion(void* arguments)
{
NetworkManager * networkManager = static_cast<NetworkManager *>(arguments) ;
while ((enet_host_service (networkManager->client,&networkManager->eventClient, 10) >= 0 ) && (networkManager->endThread == false ) )
{
switch (networkManager->eventClient.type)
{
case ENET_EVENT_TYPE_CONNECT:
networkManager->callback((XSILIUM_ALL * 1000) + ID_CONNEXION);
break;
case ENET_EVENT_TYPE_RECEIVE:
{
MessagePacket * message = new MessagePacket();
std::istringstream archive_stream(std::string((char*)networkManager->eventClient.packet->data));
boost::archive::text_iarchive archive(archive_stream);
archive >> message;
networkManager->callback(message->getOpcode(),message);
break;
}
case ENET_EVENT_TYPE_DISCONNECT:
networkManager->callback((XSILIUM_ALL * 1000 ) + ID_DECONEXION);
networkManager->endThread = true;
break;
default:
break;
}
enet_packet_destroy (networkManager->eventClient.packet);
}
return NULL;
}
DWORD WINAPI NetworkManager::send(LPVOID lpParam)
{
NetworkManager* manager = (NetworkManager*)lpParam;
const NetworkDevice& device = manager->getDevice();
NetworkPacketQueue& outbox = manager->outbox;
try
{
while (device.isConnected())
{
while (!outbox.empty())
{
const NetworkPacket& packet = outbox.front();
device.send((char*)&packet, packet.size + NetworkPacket::getHeaderSize());
outbox.pop();
}
::Sleep(1);
}
}
catch (const Exception& ex)
{
Console::out << ex.what() << Console::endl;
}
return 0;
}
bool Resources::fileExists(const string &path, InstanceID instanceId, const shared_ptr<Query>& query)
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Checking file '" << path << "'");
NetworkManager* networkManager = NetworkManager::getInstance();
if (instanceId == query->getInstanceID())
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Instance id " << instanceId << " is local instance. Returning result.");
return checkFileExists(path);
}
else
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Instance id " << instanceId << " is remote instance. Requesting result.");
FileExistsResourcesCollector* collector = new FileExistsResourcesCollector();
uint64_t id = 0;
{
ScopedMutexLock lock(_lock);
id = ++_lastResourceCollectorId;
_resourcesCollectors[id] = collector;
}
shared_ptr<MessageDesc> msg = make_shared<MessageDesc>(mtResourcesFileExistsRequest);
shared_ptr<scidb_msg::ResourcesFileExistsRequest> request =
msg->getRecord<scidb_msg::ResourcesFileExistsRequest>();
msg->setQueryID(0);
request->set_resource_request_id(id);
request->set_file_path(path);
networkManager->sendMessage(instanceId, msg);
LOG4CXX_TRACE(logger, "Resources::fileExists. Waiting while instance return result for collector " << id);
try
{
Semaphore::ErrorChecker errorChecker = bind(&Query::validateQueryPtr, query);
collector->_collectorSem.enter(1, errorChecker);
}
catch (...)
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Waiting for result of collector " << id <<
" interrupter by error");
{
ScopedMutexLock lock(_lock);
delete _resourcesCollectors[id];
_resourcesCollectors.erase(id);
}
throw;
}
LOG4CXX_TRACE(logger, "Resources::fileExists. Returning result of collector " << id);
bool result;
{
ScopedMutexLock lock(_lock);
result = ((FileExistsResourcesCollector*) _resourcesCollectors[id])->_instancesMap[instanceId];
delete _resourcesCollectors[id];
_resourcesCollectors.erase(id);
}
return result;
}
}
int main()
{
Link link("L1", 10000000, 0.01, 64000);
Node node1("H1");
Node node2("H2");
NetworkManager* nm = NetworkManager::getInstance();
nm->registerLink(link);
nm->registerNode(node1);
nm->registerNode(node2);
nm->connectLink("L1", "H1", "H2");
Flow flow("F1", "H1", "H2", 20000000, TCP_RENO_t, 1);
nm->registerFlow(flow);
EventQueue* eq = EventQueue::getInstance();
eq->run();
Logger * logger = Logger::getInstance();
delete logger;
return EXIT_SUCCESS;
}
/**
* Static Callback called when network size estimate is updated.
*/
void NetworkManager::checkNseMessageCallback (void *cls, struct GNUNET_TIME_Absolute timestamp,
double estimate, double std_dev)
{
NetworkManager* networkInstance = (NetworkManager*)cls;
Q_ASSERT(networkInstance);
networkInstance->checkNseMessage(timestamp,estimate,std_dev);
}
void
NetworkManager::notifyConnectCallback (void *cls, const struct GNUNET_PeerIdentity *peer)
{
NetworkManager* networkInstance = (NetworkManager*)cls;
Q_ASSERT(networkInstance);
networkInstance->notifyConnect(peer);
}
/**
* Static Callback called when a peer get an active address
*/
void
NetworkManager::gotActiveAddressCallback (void *cls, const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Address *address)
{
NetworkManager* networkInstance = (NetworkManager*)cls;
Q_ASSERT(networkInstance);
networkInstance->gotActiveAddress(peer,address);
}
/**
* Static Callback called when we have a information about a peer.
*/
void NetworkManager::peerinfoProcessorCallback (void *cls, const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Message *hello,
const char *err_msg)
{
NetworkManager* networkInstance = (NetworkManager*)cls;
Q_ASSERT(networkInstance);
networkInstance->peerinfoProcessor(peer, hello, err_msg);
}
void testWifiReceiveStatus(const char* ipAddressLocal, const char* ipAddressRemote)
{
NetworkManager* ourNetworkManager = new NetworkManager;
ourNetworkManager->initializeNewConnection("USBSocket", ipAddressLocal, ipAddressRemote, 1024, ConnectionInitType::CONNECT, ConnectionProtocol::TCP);
NetworkChunk* chunk = new NetworkChunk;
ourNetworkManager->getData("USBSocket", chunk);
Status ourStatus(*chunk);
}
int CommandListener::WifiRemoveNetworkCmd::runCommand(SocketClient *cli,
int argc, char **argv) {
NetworkManager *nm = NetworkManager::Instance();
WifiController *wc = (WifiController *) nm->findController("WIFI");
if (wc->removeNetwork(atoi(argv[1])))
cli->sendMsg(ResponseCode::OperationFailed, "Failed to remove network", true);
else {
cli->sendMsg(ResponseCode::CommandOkay, "Network removed.", false);
}
return 0;
}
void Resources::fileExists(const string &path, map<InstanceID, bool> &instancesMap, const shared_ptr<Query> &query)
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Checking file '" << path << "'");
NetworkManager* networkManager = NetworkManager::getInstance();
FileExistsResourcesCollector* collector = new FileExistsResourcesCollector();
uint64_t id = 0;
{
ScopedMutexLock lock(_lock);
id = ++_lastResourceCollectorId;
_resourcesCollectors[id] = collector;
collector->collect(query->getInstanceID(), checkFileExists(path), false);
}
shared_ptr<MessageDesc> msg = make_shared<MessageDesc>(mtResourcesFileExistsRequest);
shared_ptr<scidb_msg::ResourcesFileExistsRequest> request =
msg->getRecord<scidb_msg::ResourcesFileExistsRequest>();
msg->setQueryID(0);
request->set_resource_request_id(id);
request->set_file_path(path);
networkManager->broadcast(msg);
LOG4CXX_TRACE(logger, "Resources::fileExists. Waiting while instances return result for collector " << id);
try
{
Semaphore::ErrorChecker errorChecker = bind(&Query::validateQueryPtr, query);
collector->_collectorSem.enter(query->getInstancesCount() - 1, errorChecker);
}
catch (...)
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Waiting for result of collector " << id <<
" interrupter by error");
{
ScopedMutexLock lock(_lock);
delete _resourcesCollectors[id];
_resourcesCollectors.erase(id);
}
throw;
}
LOG4CXX_TRACE(logger, "Resources::fileExists. Returning result of collector " << id);
{
ScopedMutexLock lock(_lock);
instancesMap = ((FileExistsResourcesCollector*) _resourcesCollectors[id])->_instancesMap;
delete _resourcesCollectors[id];
_resourcesCollectors.erase(id);
}
}
DWORD WINAPI NetworkManager::start(LPVOID lpParam)
{
HANDLE threads[2];
unsigned long exitCodes[2];
NetworkManager* manager = (NetworkManager*)lpParam;
NetworkDevice device = manager->getDevice();
while (!manager->quit)
{
// connect to server
while (!device.isConnected() && !manager->quit)
device.connect(manager->server, manager->port);
if (device.isConnected())
{
// start send and receive threads
threads[0] = ::CreateThread(0, 0, NetworkManager::send, lpParam, 0, 0);
threads[1] = ::CreateThread(0, 0, NetworkManager::receive, lpParam, 0, 0);
// monitor threads
while (device.isConnected())
{
::Sleep(100);
// check if threads are still alive
for (unsigned i = 0; i < 2; ++i)
::GetExitCodeThread(threads[i], &exitCodes[i]);
// if quit flag is set or threads have finished
if (manager->quit || exitCodes[0] != STILL_ACTIVE || exitCodes[1] != STILL_ACTIVE)
{
device.disconnect();
::WaitForMultipleObjects(2, threads, true, INFINITE);
for (unsigned i = 0; i < 2; ++i)
::CloseHandle(threads[i]);
manager->inbox.clear();
manager->onDisconnect();
manager->outbox.clear();
}
}
}
}
return 0;
}
int CommandListener::WifiCreateNetworkCmd::runCommand(SocketClient *cli,
int argc, char **argv) {
NetworkManager *nm = NetworkManager::Instance();
WifiController *wc = (WifiController *) nm->findController("WIFI");
WifiNetwork *wn;
if (!(wn = wc->createNetwork()))
cli->sendMsg(ResponseCode::OperationFailed, "Failed to create network", true);
else {
char tmp[128];
sprintf(tmp, "Created network id %d.", wn->getNetworkId());
cli->sendMsg(ResponseCode::CommandOkay, tmp, false);
}
return 0;
}
void NetworkManager::ATSstatusChangeCallback (void *cls,
const struct GNUNET_HELLO_Address *address,
int address_active,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
const struct GNUNET_ATS_Information *ats,
uint32_t ats_count)
{
NetworkManager* networkInstance = (NetworkManager*)cls;
Q_ASSERT(networkInstance);
networkInstance->peerATSstatusChange(address,address_active, bandwidth_in, bandwidth_out, ats,ats_count);
}
void ServerCore::Tick(void)
{
conscreen.CheckUserInput();
nm.Tick();
gametime.tickcount++;
curtime = time(0);
if (gametime.tickcount == gametime.ticksperminute)
{
gametime.tickcount = 0;
this->IncrementGameTime();
this->UpdateCaption();
}
if(curtime - lastcheck >= 30000)
{
lastcheck = curtime;
nm.CheckClients();
}
if (!lan)
{
if (curtime - lastmasterservercheck >= 3600000)
{
lastmasterservercheck = curtime;
if (!msm.RegisterServer(port, hostname, gamemodename, L"World", maxplayers, password))
{
Log::Warning(L"Unable to register server.");
}
}
}
long curmtime = msec_time();
for(int i = 0; i < MAX_TIMERS; i++)
{
if(scripttimers[i].timeout > 0)
{
if(curmtime >= scripttimers[i].time)
{
if(!vmm.CallSomeCallback(scripttimers[i].callback, scripttimers[i].param))
{
KillTimer(i);
}
else
scripttimers[i].time = curmtime + scripttimers[i].timeout;
}
}
}
Sleep(sleepcount);
}
void testWifiSendCommandNoMessage(const char* ipAddressLocal, const char* ipAddressRemote)
{
NetworkManager* ourNetworkManager = new NetworkManager;
ourNetworkManager->initializeNewConnection("USBSocket", ipAddressLocal, ipAddressRemote, 1024, ConnectionInitType::CONNECT, ConnectionProtocol::TCP);
//make and fill command with data
Command *ourCommand = new Command;
ourCommand->setCommandType(CommandType::DRIVE_BACKWARD);
//turn command into NetworkChunk
NetworkChunk* ourNetworkChunk = new NetworkChunk;
*ourNetworkChunk = ourCommand->toNetworkChunk();
//send NetworkChunk
ourNetworkManager->sendData("USBSocket", ourNetworkChunk);
}
int NetworkManager::outcomeMsgCallback (void *cls,
const struct GNUNET_PeerIdentity *
other,
const struct GNUNET_MessageHeader *
message)
{
NetworkManager* networkInstance = (NetworkManager*)cls;
Q_ASSERT(networkInstance);
networkInstance->outcomeMsg(other,message);
return GNUNET_OK;
}
void loop() {
getSensorData();
screenPrinting();
if(networkManager.isConnected())
{
unsigned long currentMillis = millis();
if(currentMillis > prievous + updateFeedInterval) {
networkManager.updateFeed(temperature, 0, pressure, lightLevel);
prievous = currentMillis;
}
}
delay(500);
}
bool ClientCore::Load(void)
{
concore.SetOutputFunction(Log::Info);
concore.RegisterStandardLibrary();
concore.AddConCmd(L"connect", ConCmdConnect, L"Connect to specified server.", 0);
concore.AddConCmd(L"exit", ConCmdQuit, L"Exit the engine.", 0);
#if defined (FMP_CLIENT)
concore.AddConCmd(L"addarmor", ConCmdAddarmor);
concore.AddConCmd(L"getarmor", ConCmdGetarmor);
concore.AddConCmd(L"gethealth", ConCmdGethealth);
concore.AddConCmd(L"give", ConCmdGive, L"Give weapon to player. Arguments: <weapon_index>");
concore.AddConCmd(L"hurtme", ConCmdHurtme, L"Hurts the player. Arguments: <health to lose>");
#endif
namecvar = concore.AddConVar(L"name", L"unnamed", L"Current user name.", 0);
namecvar->HookChange(ConVarHookName);
concore.AddConCmd(L"quit", ConCmdQuit, L"Exit the engine.", 0);
nm.Load();
#if defined (FMP_CLIENT)
concore.SetExecPath(L"FMP/cfg/");
inputstate = InputStateGui;
#elif defined (FMP_CONSOLE_CLIENT)
concore.SetExecPath(L"cfg/");
conscreen.SetCaption(L"FOUR-MP");
#endif
gamestate = GameStateOffline;
concore.InterpretLine(L"exec autoexec.cfg");
return true;
}
void ClientCore::Tick(void)
{
nm.Tick();
#if defined (FMP_CONSOLE_CLIENT)
conscreen.CheckUserInput();
Sleep(100);
#endif
}
int RxEndEvent::handleEvent()
{
rx_link->popPacket(rx_packet);
rx_node->receivePacket(rx_packet);
#ifdef CHECK_DROP
std::cout << "receive ack " << rx_packet->packet_seq_id\
<<std::endl;
#endif//DEBUG
NetworkManager* nm = NetworkManager::getInstance();
Flow* rx_flow = nm->getFlow(rx_packet->packet_flow_id);
rx_flow->receiveAckAndGenRx(rx_packet);
delete rx_packet;
return 1;
}
void Tst_connectionagent::tst_onConnectionRequest()
{
NetworkManager *netman = NetworkManagerFactory::createInstance();
QString currentState = netman->state();
if (currentState == "online") {
NetworkService *service = netman->defaultRoute();
service->requestDisconnect();
// service->requestConnect();
}
QSignalSpy spy(&QConnectionAgent::instance(), SIGNAL(connectionRequest()));
QConnectionAgent::instance().onConnectionRequest();
if (currentState == "online")
QCOMPARE(spy.count(),0);
else
QCOMPARE(spy.count(),0);
}
void testWifiSendStatus(const char* ipAddressLocal, const char* ipAddressRemote)
{
NetworkManager* ourNetworkManager = new NetworkManager;
ourNetworkManager->initializeNewConnection("USBSocket", ipAddressLocal, ipAddressRemote, 1024, ConnectionInitType::CONNECT, ConnectionProtocol::TCP);
//make and fill status with data
Status *ourStatus = new Status;
ourStatus->setStatusType(StatusType::NOT_CHARGING);
char message[100] = "YES!";
ourStatus->setStatusData(message);
//turn status into NetworkChunk
NetworkChunk* ourNetworkChunk = new NetworkChunk;
*ourNetworkChunk = ourStatus->toNetworkChunk();
//send NetworkChunk
ourNetworkManager->sendData("USBSocket", ourNetworkChunk);
}
void testWifiSendText(const char* ipAddressLocal, const char* ipAddressRemote)
{
NetworkManager* ourNetworkManager = new NetworkManager;
ourNetworkManager->initializeNewConnection("USBSocket", ipAddressLocal, ipAddressRemote, 1024, ConnectionInitType::CONNECT, ConnectionProtocol::TCP);
//make and fill text with data
Text *ourTextMessage = new Text;
ourTextMessage->setLength(10);
char message[100] = "YESSSSS!!!";
ourTextMessage->setTextMessage(message);
//turn command into NetworkChunk
NetworkChunk* ourNetworkChunk = new NetworkChunk;
*ourNetworkChunk = ourTextMessage->toNetworkChunk();
//send NetworkChunk
ourNetworkManager->sendData("USBSocket", ourNetworkChunk);
}
void LoginState::initialisationNetwork()
{
NetworkManager * networkManager = NetworkManager::getInstance();
if (!networkManager->isConnected())
{
int messageErreur = networkManager->connexionToHost("85.25.251.97",60000);
if( messageErreur == 1)
{
XsiliumFramework::getInstance()->getLog()->logMessage("erreur de connexion : Le serveur est plein desoler ");
auth->setEvent("0","Le serveur est plein desoler");
}
if( messageErreur == 2)
{
XsiliumFramework::getInstance()->getLog()->logMessage("erreur de connexion : Impossible de se connecter au serveur");
auth->setEvent("0","Impossible de se connecter au serveur");
}
}
}
bool App::start()
{
mRoot = new Ogre::Root("plugins_d.cfg", "ogre.cfg", "Ogre.log");
Ogre::ConfigFile configFile;
configFile.load("resources_d.cfg");
Ogre::ConfigFile::SectionIterator seci = configFile.getSectionIterator();
Ogre::String secName, typeName, archName;
while (seci.hasMoreElements())
{
secName = seci.peekNextKey();
Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
Ogre::ConfigFile::SettingsMultiMap::iterator i;
for (i = settings->begin(); i != settings->end(); ++i)
{
typeName = i->first;
archName = i->second;
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
archName, typeName, secName);
}
}
if (!(mRoot->restoreConfig() || mRoot->showConfigDialog()))
{
return false;
}
mWindow = mRoot->initialise(true, "ZappyGraph");
Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
Game* game = new Game();
NetworkManager *net = new NetworkManager(game);
Menu *menuManager = new Menu(net);
game->init(mRoot, mWindow, menuManager, net);
game->createMenu();
while (true)
{
net->update();
Ogre::WindowEventUtilities::messagePump();
if (mWindow->isClosed())
return false;
if (!mRoot->renderOneFrame())
return false;
}
return true;
}
