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