void BadaMutexManager::unlockMutex(OSystem::MutexRef mutex) { Mutex *m = (Mutex*)mutex; m->Release(); }
bool Rehash() { #ifdef WIN32 char * config_file = "ascent-logonserver.conf"; #else char * config_file = (char*)CONFDIR "/ascent-logonserver.conf"; #endif if(!Config.MainConfig.SetSource(config_file)) { printf("Config file could not be rehashed.\n"); return false; } m_encryptedPasswords = Config.MainConfig.GetBoolDefault("LogonServer", "UseEncryptedPasswords", false); // re-set the allowed server IP's string ips = Config.MainConfig.GetStringDefault("LogonServer", "AllowedIPs", ""); string ipsmod = Config.MainConfig.GetStringDefault("LogonServer", "AllowedModIPs", ""); vector<string> vips = StrSplit(ips, " "); vector<string> vipsmod = StrSplit(ips, " "); m_allowedIpLock.Acquire(); m_allowedIps.clear(); m_allowedModIps.clear(); vector<string>::iterator itr; for(itr = vips.begin(); itr != vips.end(); ++itr) { string::size_type i = itr->find("/"); if( i == string::npos ) { printf("IP: %s could not be parsed. Ignoring\n", itr->c_str()); continue; } string stmp = itr->substr(0, i); string smask = itr->substr(i+1); unsigned int ipraw = MakeIP(stmp.c_str()); unsigned int ipmask = atoi(smask.c_str()); if( ipraw == 0 || ipmask == 0 ) { printf("IP: %s could not be parsed. Ignoring\n", itr->c_str()); continue; } AllowedIP tmp; tmp.Bytes = ipmask; tmp.IP = ipraw; m_allowedIps.push_back(tmp); } for(itr = vipsmod.begin(); itr != vipsmod.end(); ++itr) { string::size_type i = itr->find("/"); if( i == string::npos ) { printf("IP: %s could not be parsed. Ignoring\n", itr->c_str()); continue; } string stmp = itr->substr(0, i); string smask = itr->substr(i+1); unsigned int ipraw = MakeIP(stmp.c_str()); unsigned int ipmask = atoi(smask.c_str()); if( ipraw == 0 || ipmask == 0 ) { printf("IP: %s could not be parsed. Ignoring\n", itr->c_str()); continue; } AllowedIP tmp; tmp.Bytes = ipmask; tmp.IP = ipraw; m_allowedModIps.push_back(tmp); } if( InformationCore::getSingletonPtr() != NULL ) sInfoCore.CheckServers(); m_allowedIpLock.Release(); return true; }
void BadaMutexManager::lockMutex(OSystem::MutexRef mutex) { Mutex *m = (Mutex*)mutex; m->Acquire(); }
int main(int argc, char **argv) { std::string LocSocket = "/tmp/ipdupdetect"; std::unique_ptr<PIDFile> PidFile; std::string LocPidFile = ""; const char *opts = "hdp:"; int longindex = 0; int c = 0; int debug = 0; struct option loptions[] { {"help", 0, 0, 'h'}, {"pid", 1, 0, 'p'}, {"debug", 0, 0, 'd'}, {0, 0, 0, 0} }; while( (c = getopt_long(argc, argv, opts, loptions, &longindex)) >= 0) { switch(c) { case 'd': debug = 1; break; case 'h': print_help(stdout, argv[0]); exit(EXIT_SUCCESS); break; case 'p': LocPidFile = optarg; break; default: break; } } //Add Logging if (isatty(fileno(stdout)) == 1) { std::shared_ptr<ILogger> tmp = std::make_shared<LogStdoutColor>(); LogManager::Add(tmp); } else { std::shared_ptr<ILogger> tmp = std::make_shared<LogStdout>(); LogManager::Add(tmp); } if (debug) { LogManager::SetLevel(LOGGER_DEBUG); } else { LogManager::SetLevel(LOGGER_INFO); } if (LocPidFile != "") { PidFile.reset(new PIDFile(LocPidFile)); if (PidFile->Create() == false) { LogCritical("Cannot Create PID file '%s'", LocPidFile.c_str()); exit(EXIT_FAILURE); } LogInfo("Created PID file '%s'", LocPidFile.c_str()); } SigHandler SHandler; SignalHandler Signals = SignalHandler(&SHandler); Signals.Block(); do { ServerManager *SrvManager = NULL; MonitorManager MManager; Service *Srv = new Service(&MManager); //Bind instance of MonitorManager to the ServiceProxy struct timespec timeout = {60, 0}; //Timeout to reprocess interface list ScopedLock lock(&ExitLock); SHandler.SetMonitorManager(&MManager); //Bind MonitorManager to signal handler proxy ServerUnixPolled Unix(LocSocket); //Create a suitable socket SrvManager = new ServerManager(Srv); //Create a new server instance SrvManager->ServerAdd(&Unix); //Bind our Service proxy to the socket instance Signals.UnBlock(); while(DoExit == false) { MManager.Scan(); MManager.Purge(); ExitLock.Wait(&timeout); } lock.Unlock(); //Required to prevent hang in signals SrvManager->ServerRemove(&Unix); delete Srv; delete SrvManager; Signals.Block(); SHandler.SetMonitorManager(NULL); Signals.UnBlock(); } while(0); return 0; }
void ThreadCondition::wait(Mutex& mutex) { m_condition.timedWait(mutex.impl(), INFINITE); }
bool KRT2Device::DataReceived(const void *_data, size_t length, struct NMEAInfo &info) { assert(_data != nullptr); assert(length > 0); const uint8_t *data = (const uint8_t *)_data; const uint8_t *end = data + length; do { // Append new data to the buffer, as much as fits in there auto range = rx_buf.Write(); if (rx_buf.IsFull()) { // Overflow: reset buffer to recover quickly rx_buf.Clear(); expected_msg_length = 0; continue; } size_t nbytes = std::min(range.size, size_t(end - data)); memcpy(range.data, data, nbytes); data += nbytes; rx_buf.Append(nbytes); for (;;) { // Read data from buffer to handle the messages range = rx_buf.Read(); if (range.IsEmpty()) break; if (range.size < expected_msg_length) break; expected_msg_length = ExpectedMsgLength(range.data, range.size); if (range.size >= expected_msg_length) { switch (*(const uint8_t *) range.data) { case ACK: case NAK: // Received a response to a normal command (STX) response_mutex.Lock(); response = *(const uint8_t *) range.data; // Signal the response to the TX thread rx_cond.signal(); response_mutex.Unlock(); break; default: // Received a command from the radio -> ignore it break; } // Message handled -> remove message rx_buf.Consume(expected_msg_length); expected_msg_length = 0; // Received something from the radio -> the connection is alive info.alive.Update(info.clock); } } } while (data < end); return true; }
int main(int argc, char* argv[]) { Component a, b, c; // Force components to use JTCP... //a.AddService(new JTCPClient()); //b.AddService(new JTCPClient()); //c.AddService(new JTCPClient()); // Try load settings files. // These files determine your UDP network // settings, what Services to turn on/off // or any Service specific settings. See the // example file for settings file format. if(a.LoadSettings("settings/services.xml") == false || b.LoadSettings("settings/services.xml") == false || c.LoadSettings("settings/services.xml") == false) { // Working directory probably not set (or not running from output directory), so // use default values. a.DiscoveryService()->SetSubsystemIdentification(Subsystem::Vehicle, "Simulation"); b.DiscoveryService()->SetSubsystemIdentification(Subsystem::Vehicle, "Simulation"); c.DiscoveryService()->SetSubsystemIdentification(Subsystem::Vehicle, "Simulation"); } // Use a callback to know when heartbeat messages were receive CallbackTest callback; a.TransportService()->RegisterCallback(EVENT, &callback); // Initialize a component with any ID. std::cout << "Initializing Component A..."; if(a.Initialize(Address(60001, 1, 1)) == false) { std::cout << "Failed to Initialize Component A.\n"; return 0; } std::cout << "Success!\n"; std::cout << "Initializing Component B..."; // Initialize a component with a given ID. if(b.Initialize(Address(60002, 1, 1)) == false) { std::cout << "Failed to Initialize Component B.\n"; return 0; } std::cout << "Success!\n"; std::cout << "Initializing Component C..."; // Initialize a component with a given ID. if(c.Initialize(Address(60003, 1, 1)) == false) { std::cout << "Failed to Initialize Component C.\n"; return 0; } std::cout << "Success!\n"; // Enable Debug Messages for testing. //a.TransportService()->EnableDebugMessages(true); //b.TransportService()->EnableDebugMessages(true); //a.LivenessService()->EnableDebugMessages(true); //a.EventsService()->EnableDebugMessages(true); //b.EventsService()->EnableDebugMessages(true); //a.TransportService()->EnableLogging(true); // Allow time for connections to establish before trying // to send a query. CxUtils::SleepMs(1000); // Example inline message query - Get subsystem ID of component B QueryIdentification queryIdent(b.GetComponentID(), a.GetComponentID()); queryIdent.SetQueryType(QueryIdentification::SubsystemIdentification); ReportIdentification reportIdent; if(a.Send(&queryIdent, &reportIdent, 1000)) { reportIdent.Print(); } Time::Stamp startTimeMs = Time::GetUtcTimeMs(); while(CxUtils::GetChar() != 27) { static bool createdEvent = false; if(!createdEvent && !a.EventsService()->HaveSubscription(REPORT_HEARTBEAT_PULSE, b.GetComponentID())) { // Request Heartbeat Events from component b. QueryHeartbeatPulse query; createdEvent = a.EventsService()->RequestPeriodicEvent(b.GetComponentID(), &query, 10, 1); } gPrintLock.Lock(); //a.DiscoveryService()->PrintSystemConfiguration(); //b.DiscoveryService()->PrintSystemConfiguration(); c.DiscoveryService()->PrintSystemConfiguration(); gPrintLock.Unlock(); // Testing Discovery Service. This is for testing purposes only. // What should happen is that after a timeout period A will no longer // see Component b until it is re-initialized. Upon re-discovery, a should // automatically re-create the Report Heartbeat Pulse event. static bool didShutdown = false; //if(!didShutdown && b.IsInitialized() && Time::GetUtcTimeMs() - startTimeMs > 5000) //{ // std::cout << "Testing Loss of Component...\n"; // b.Shutdown(); // didShutdown = true; //} //if(!b.IsInitialized() && Time::GetUtcTimeMs() - startTimeMs > 15000) //{ // std::cout << "Testing Discovery of Component...\n"; // b.DiscoveryService()->SetSubsystemIdentification(Subsystem::Vehicle, // "Simulation"); // b.Initialize(Address(60000, 1, 2)); //} CxUtils::SleepMs(1000); } // Shutdown the components. a.Shutdown(); b.Shutdown(); return 0; }
void Lock() { mutex.Lock(); }
void Unlock() { mutex.Unlock(); }
bool Condition::wait(Mutex& mutex) { return SDL_CondWait(p.get(), mutex.raw_ptr()) == 0; }
void gSetLogFile(FILE *wFile) { gLogLock.lock(); gLoggingFile = wFile; gLogLock.unlock(); }
void DroneController::popAllCommands() { m_mutex.lock(); while(!m_commandStack.empty()) m_commandStack.pop(); m_mutex.unlock(); }
void DroneController::popCommand() { m_mutex.lock(); if(!m_commandStack.empty()) m_commandStack.pop(); m_mutex.unlock(); }
void DroneController::clearPosition() { m_mutex.lock(); m_velIntegrator.clear(); m_mutex.unlock(); }
void DroneController::stop() { m_mutex.lock(); m_stop = true; m_mutex.unlock(); }
void ClientLauncher::speed_tests() { // volatile to avoid some potential compiler optimisations volatile static s16 temp16; volatile static f32 tempf; static v3f tempv3f1; static v3f tempv3f2; static std::string tempstring; static std::string tempstring2; tempv3f1 = v3f(); tempv3f2 = v3f(); tempstring = std::string(); tempstring2 = std::string(); { infostream << "The following test should take around 20ms." << std::endl; TimeTaker timer("Testing std::string speed"); const u32 jj = 10000; for (u32 j = 0; j < jj; j++) { tempstring = ""; tempstring2 = ""; const u32 ii = 10; for (u32 i = 0; i < ii; i++) { tempstring2 += "asd"; } for (u32 i = 0; i < ii+1; i++) { tempstring += "asd"; if (tempstring == tempstring2) break; } } } infostream << "All of the following tests should take around 100ms each." << std::endl; { TimeTaker timer("Testing floating-point conversion speed"); tempf = 0.001; for (u32 i = 0; i < 4000000; i++) { temp16 += tempf; tempf += 0.001; } } { TimeTaker timer("Testing floating-point vector speed"); tempv3f1 = v3f(1, 2, 3); tempv3f2 = v3f(4, 5, 6); for (u32 i = 0; i < 10000000; i++) { tempf += tempv3f1.dotProduct(tempv3f2); tempv3f2 += v3f(7, 8, 9); } } { TimeTaker timer("Testing std::map speed"); std::map<v2s16, f32> map1; tempf = -324; const s16 ii = 300; for (s16 y = 0; y < ii; y++) { for (s16 x = 0; x < ii; x++) { map1[v2s16(x, y)] = tempf; tempf += 1; } } for (s16 y = ii - 1; y >= 0; y--) { for (s16 x = 0; x < ii; x++) { tempf = map1[v2s16(x, y)]; } } } { infostream << "Around 5000/ms should do well here." << std::endl; TimeTaker timer("Testing mutex speed"); Mutex m; u32 n = 0; u32 i = 0; do { n += 10000; for (; i < n; i++) { m.lock(); m.unlock(); } } // Do at least 10ms while(timer.getTimerTime() < 10); u32 dtime = timer.stop(); u32 per_ms = n / dtime; infostream << "Done. " << dtime << "ms, " << per_ms << "/ms" << std::endl; } }