void MappingManager::close(Mapper& mapper) { if(mapper.hasRules()) { bool ret = mapper.init() && mapper.close(); mapper.uninit(); if (ret) log(STRING_F(MAPPER_REMOVING_SUCCESS, deviceString(mapper) % mapper.getName()), LogMessage::SEV_INFO); else log(STRING_F(MAPPER_REMOVING_FAILED, deviceString(mapper) % mapper.getName()), LogMessage::SEV_WARNING); } }
string MappingManager::getStatus() const { if(working.get()) { auto& mapper = *working; return STRING_F(MAPPER_CREATING_SUCCESS, deviceString(mapper) % mapper.getName()); } return STRING(MAPPER_CREATING_FAILED); }
vector<string> DeviceManager::GetDevices() { // A vector that will hold all devices vector<string> devices; // Will contain the name of the current device const char *device; // Handle to the current device int deviceHandle = -1; // Get the first device deviceHandle = bdev_enum(deviceHandle, &device); // Make sure we found a device while(deviceHandle >= 0) { // Create a new string containing the device name string deviceString(device); // Add the device to our vector devices.push_back(deviceString); // Get the next device deviceHandle = bdev_enum(deviceHandle, &device); } return devices; }
// ###################################################################### void SerialPort::connect() { // Check to see if we have a hardcoded device name. If so, then let's just // go ahead and enable that port. If printf("INFO: Looking Device Name [%s]\n", itsDevName.c_str()); if (itsDevName != "") { printf("INFO: Opening %s\n", itsDevName.c_str()); enablePort(itsDevName); } else if (itsDevName == "search") { printf("INFO: Searching for devices\n"); itsCmdDevName = ""; DIR *directory_p; struct dirent *entry_p; // Open the device directory to search for devices whose names match the // search prefix directory_p = ::opendir("/dev"); if (directory_p == NULL) printf("FATAL ERROR: Could Not Open /dev Directory!\n"); // Iterate through the directory entries while ((entry_p = ::readdir(directory_p))) { std::string entryName(entry_p->d_name); if (entryName.find(itsSearchPrefix.c_str()) != std::string::npos) { // If the directory entry name matches our // search prefix, then let's try configuring a // serial // port on that device, sending it an identity request command (0x00), // and comparing the result // with our required device description enablePort("/dev/" + entryName); unsigned char cmd[1] = {0}; write(cmd, 1); std::vector<unsigned char> deviceStringVec = readFrame(cmd[0], 255); std::string deviceString(deviceStringVec.begin(), deviceStringVec.end()); printf("INFO: %s : %s", entryName.c_str(), deviceString.c_str()); if (deviceString == itsDeviceDescription) { itsCmdDevName = "/dev/" + entryName; break; } } } (void)::closedir(directory_p); if (itsCmdDevName == "") { printf( "FATAL ERROR: Could Not Find Serial Device Matching Descriptor " "(%s)\n", itsDeviceDescription.c_str()); } } else { printf("INFO: Opening from cmd line %s\n", itsCmdDevName.c_str()); enablePort(itsCmdDevName); } }
string MappingManager::getStatus() const { if(working.get()) { auto& mapper = *working; return str(boost::format("Successfully created port mappings on the %1% device with the %2% interface") % deviceString(mapper) % mapper.getName()); } return "Failed to create port mappings"; }
std::string VideoV4lSource::deviceStr() const { gchar *device_cstr; g_object_get(G_OBJECT(source_), "device", &device_cstr, NULL); // get actual used device std::string deviceString(device_cstr); // stay safe from memory leaks g_free(device_cstr); return deviceString; }
/* ================ idCommonLocal::LaunchExternalTitle Launches an external title ( Doom 1, or 2 ) based on title index. for PS3, a device number is sent in, for the game to register as a local user by default, when title initializes. ================ */ void idCommonLocal::LaunchExternalTitle( int titleIndex, int device, const lobbyConnectInfo_t * const connectInfo ) { idStr deviceString( device ); // We want to pass in the current executable, so that the launching title knows which title to return to. // as of right now, this feature is TBD. const char * currentExecutablePath = "ImNotSureYet"; idStr launchingExecutablePath; idCmdArgs cmdArgs; cmdArgs.AppendArg( currentExecutablePath ); if ( titleIndex == LAUNCH_TITLE_DOOM ) { launchingExecutablePath.Format("%s%s", Sys_DefaultBasePath(), LAUNCH_TITLE_DOOM_EXECUTABLE ); cmdArgs.AppendArg( "d1bfg" ); } else if ( titleIndex == LAUNCH_TITLE_DOOM2 ) { launchingExecutablePath.Format("%s%s", Sys_DefaultBasePath(), LAUNCH_TITLE_DOOM2_EXECUTABLE ); cmdArgs.AppendArg( "d2bfg" ); } else { idLib::Warning("Unhandled Launch Title %d \n", titleIndex ); } cmdArgs.AppendArg( deviceString.c_str() ); // Add an argument so that the new process knows whether or not to read exitspawn data. if ( connectInfo != NULL ) { cmdArgs.AppendArg( "exitspawnInvite" ); } // Add arguments so that the new process will know which command line to invoke to relaunch this process // if necessary. const int launchDataSize = ( connectInfo == NULL ) ? 0 : sizeof( *connectInfo ); Sys_Launch( launchingExecutablePath.c_str() , cmdArgs, const_cast< lobbyConnectInfo_t * const >( connectInfo ), launchDataSize ); }
int MappingManager::run() { ScopedFunctor([this] { busy.clear(); }); // cache ports auto conn_port = ConnectionManager::getInstance()->getPort(), secure_port = ConnectionManager::getInstance()->getSecurePort(), search_port = SearchManager::getInstance()->getPort(); if(renewal) { Mapper& mapper = *working; ScopedFunctor([&mapper] { mapper.uninit(); }); if(!mapper.init()) { // can't renew; try again later. renewLater(mapper); return 0; } auto addRule = [this, &mapper](const string& port, Mapper::Protocol protocol, const string& description) { // just launch renewal requests - don't bother with possible failures. if(!port.empty()) { mapper.open(port, protocol, STRING_F(MAPPER_X_PORT_X, description % port % Mapper::protocols[protocol])); } }; addRule(conn_port, Mapper::PROTOCOL_TCP, "Transfer"); addRule(secure_port, Mapper::PROTOCOL_TCP, "Encrypted transfer"); addRule(search_port, Mapper::PROTOCOL_UDP, "Search"); renewLater(mapper); return 0; } // move the preferred mapper to the top of the stack. const auto& mapperName = SETTING(MAPPER); for(auto i = mappers.begin(); i != mappers.end(); ++i) { if(i->first == mapperName) { if(i != mappers.begin()) { auto mapper = *i; mappers.erase(i); mappers.insert(mappers.begin(), mapper); } break; } } for(auto& i: mappers) { auto setting = v6 ? SettingsManager::BIND_ADDRESS6 : SettingsManager::BIND_ADDRESS; unique_ptr<Mapper> pMapper(i.second((SettingsManager::getInstance()->isDefault(setting) ? Util::emptyString : SettingsManager::getInstance()->get(setting)), v6)); Mapper& mapper = *pMapper; ScopedFunctor([&mapper] { mapper.uninit(); }); if(!mapper.init()) { log(STRING_F(MAPPER_INIT_FAILED, mapper.getName()), LogMessage::SEV_WARNING); continue; } auto addRule = [this, &mapper](const string& port, Mapper::Protocol protocol, const string& description) -> bool { if (!port.empty() && !mapper.open(port, protocol, STRING_F(MAPPER_X_PORT_X, APPNAME % description % port % Mapper::protocols[protocol]))) { this->log(STRING_F(MAPPER_INTERFACE_FAILED, description % port % Mapper::protocols[protocol] % mapper.getName()), LogMessage::SEV_WARNING); mapper.close(); return false; } return true; }; if(!(addRule(conn_port, Mapper::PROTOCOL_TCP, STRING(TRANSFER)) && addRule(secure_port, Mapper::PROTOCOL_TCP, STRING(ENCRYPTED_TRANSFER)) && addRule(search_port, Mapper::PROTOCOL_UDP, STRING(SEARCH)))) continue; log(STRING_F(MAPPER_CREATING_SUCCESS_LONG, conn_port % secure_port % search_port % deviceString(mapper) % mapper.getName()), LogMessage::SEV_INFO); working = move(pMapper); if ((!v6 && !CONNSETTING(NO_IP_OVERRIDE)) || (v6 && !CONNSETTING(NO_IP_OVERRIDE6))) { setting = v6 ? SettingsManager::EXTERNAL_IP6 : SettingsManager::EXTERNAL_IP; string externalIP = mapper.getExternalIP(); if(!externalIP.empty()) { ConnectivityManager::getInstance()->set(setting, externalIP); } else { // no cleanup because the mappings work and hubs will likely provide the correct IP. log(STRING(MAPPER_IP_FAILED), LogMessage::SEV_WARNING); } } ConnectivityManager::getInstance()->mappingFinished(mapper.getName(), v6); renewLater(mapper); break; } if(!getOpened()) { log(STRING(MAPPER_CREATING_FAILED), LogMessage::SEV_ERROR); ConnectivityManager::getInstance()->mappingFinished(Util::emptyString, v6); } return 0; }
/* * Capture Factory constructor. * Arguments can be * - [-d | --device] <device number> : camera number * - [-f | --file] <filename> : video file name * - [-m | --mirror] : flip image horizontally * - [-g | --gray] : convert to gray level * - [-s | --size] <width>x<height>: preferred width and height * @param argList program the argument list provided as a list of * strings */ CaptureFactory::CaptureFactory(const QStringList & argList) : capture(NULL), deviceNumber(0), liveVideo(true), flippedVideo(false), grayVideo(false), skipImages(false), preferredWidth(0), preferredHeight(0), videoPath() { // C++ Like iterator // for (QStringList::const_iterator it = argList.begin(); it != argList.end(); ++it) // Java like iterator (because we use hasNext multiple times) for (QListIterator<QString> it(argList); it.hasNext(); ) { QString currentArg(it.next()); if (currentArg == "-d" || currentArg =="--device") { // Next argument should be device number integer if (it.hasNext()) { QString deviceString(it.next()); bool convertOk; deviceNumber = deviceString.toInt(&convertOk,10); if (!convertOk || deviceNumber < 0) { qWarning("Warning: Invalid device number %d",deviceNumber); deviceNumber = 0; } liveVideo = true; } else { qWarning("Warning: device tag found with no following device number"); } } else if (currentArg == "-v" || currentArg == "--video") { // Next argument should be a path name to video file or URL if (it.hasNext()) { videoPath = it.next(); liveVideo = false; } else { qWarning("file tag found with no following filename"); } } else if (currentArg == "-m" || currentArg == "--mirror") { flippedVideo = true; } else if (currentArg == "-g" || currentArg == "--gray") { grayVideo = true; } else if (currentArg == "-k" || currentArg == "--skip") { skipImages = true; } else if (currentArg == "-s" || currentArg == "--size") { if (it.hasNext()) { // search for <width>x<height> QString sizeString = it.next(); int xIndex = sizeString.indexOf(QChar('x'), 0, Qt::CaseInsensitive); if (xIndex != -1) { QString widthString = sizeString.left(xIndex); preferredWidth = widthString.toUInt(); qDebug("preferred width is %d", preferredWidth); QString heightString = sizeString.remove(0, xIndex+1); preferredHeight = heightString.toUInt(); qDebug("preferred height is %d", preferredHeight); } else { qWarning("invalid <width>x<height>"); } } else { qWarning("size not found after --size"); } } } }
int MappingManager::run() { ScopedFunctor([this] { busy.clear(); }); // cache ports auto conn_port = ConnectionManager::getInstance()->getPort(), secure_port = ConnectionManager::getInstance()->getSecurePort(), search_port = SearchManager::getInstance()->getPort(); if(renewal) { Mapper& mapper = *working; ScopedFunctor([&mapper] { mapper.uninit(); }); if(!mapper.init()) { // can't renew; try again later. renewLater(mapper); return 0; } auto addRule = [this, &mapper](const string& port, Mapper::Protocol protocol, const string& description) { // just launch renewal requests - don't bother with possible failures. if(!port.empty()) { mapper.open(port, protocol, str(boost::format("%1% %2% port (%3% %4%)") % description % port % Mapper::protocols[protocol])); } }; addRule(conn_port, Mapper::PROTOCOL_TCP, "Transfer"); addRule(secure_port, Mapper::PROTOCOL_TCP, "Encrypted transfer"); addRule(search_port, Mapper::PROTOCOL_UDP, "Search"); renewLater(mapper); return 0; } // move the preferred mapper to the top of the stack. const auto& setting = SETTING(MAPPER); for(auto i = mappers.begin(); i != mappers.end(); ++i) { if(i->first == setting) { if(i != mappers.begin()) { auto mapper = *i; mappers.erase(i); mappers.insert(mappers.begin(), mapper); } break; } } for(auto i = mappers.begin(); i != mappers.end(); ++i) { unique_ptr<Mapper> pMapper(i->second(AirUtil::getLocalIp())); Mapper& mapper = *pMapper; ScopedFunctor([&mapper] { mapper.uninit(); }); if(!mapper.init()) { log(str(boost::format("Failed to initalize the %1% interface") % mapper.getName()), LogManager::LOG_WARNING); continue; } auto addRule = [this, &mapper](const string& port, Mapper::Protocol protocol, const string& description) -> bool { if(!port.empty() && !mapper.open(port, protocol, str(boost::format("%1% %2% port (%3% %4%)") % APPNAME % description % port % Mapper::protocols[protocol]))) { this->log(str(boost::format("Failed to map the %1% port (%2% %3%) with the %4% interface") % description % port % Mapper::protocols[protocol] % mapper.getName()), LogManager::LOG_WARNING); mapper.close(); return false; } return true; }; if(!(addRule(conn_port, Mapper::PROTOCOL_TCP, "Transfer") && addRule(secure_port, Mapper::PROTOCOL_TCP, "Encrypted transfer") && addRule(search_port, Mapper::PROTOCOL_UDP, "Search"))) continue; log(str(boost::format("Successfully created port mappings (Transfers: %1%, Encrypted transfers: %2%, Search: %3%) on the %4% device with the %5% interface") % conn_port % secure_port % search_port % deviceString(mapper) % mapper.getName()), LogManager::LOG_INFO); working = move(pMapper); if(!CONNSETTING(NO_IP_OVERRIDE)) { string externalIP = mapper.getExternalIP(); if(!externalIP.empty()) { ConnectivityManager::getInstance()->set(SettingsManager::EXTERNAL_IP, externalIP); } else { // no cleanup because the mappings work and hubs will likely provide the correct IP. log("Failed to get external IP", LogManager::LOG_WARNING); } } ConnectivityManager::getInstance()->mappingFinished(mapper.getName()); renewLater(mapper); break; } if(!getOpened()) { log(str(boost::format("Failed to create port mappings")), LogManager::LOG_ERROR); ConnectivityManager::getInstance()->mappingFinished(Util::emptyString); } return 0; }
void MappingManager::close(Mapper& mapper) { if(mapper.hasRules()) { bool ret = mapper.init() && mapper.close(); mapper.uninit(); if (ret) log(str(boost::format("Successfully removed port mappings from the %1% device with the %2% interface") % deviceString(mapper) % mapper.getName()), LogManager::LOG_INFO); else log(str(boost::format("Failed to remove port mappings from the %1% device with the %2% interface") % deviceString(mapper) % mapper.getName()), LogManager::LOG_WARNING); } }
bool NeoMultiplexerPlugin::detect( QSerialIODevice *device ) { qLog(Hardware) << __PRETTY_FUNCTION__; // Power on modem via sysfs QFile f("/sys/bus/platform/devices/neo1973-pm-gsm.0/power_on"); if(f.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) { f.write("0"); f.close(); } if(f.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate)) { f.write("1"); f.close(); } else { qWarning() << "Modem power on failed "<< f.errorString(); } // The FIC needs a special line discipline set on the device. QSerialPort *port = qobject_cast<QSerialPort *>( device ); if (port) { int discipline = N_TIHTC; ::ioctl(port->fd(), TIOCSETD, &discipline); } device->discard(); int rc; struct termios t; rc = tcgetattr(port->fd(), &t); t.c_cflag |= CRTSCTS; rc = tcsetattr(port->fd(), TCSANOW, &t); QValueSpaceItem deviceString("/Hardware/Neo/Device"); if ( deviceString.value().toString() == "GTA02") { qLog(Hardware) << __PRETTY_FUNCTION__ << "is gta02"; muxEnabled = true; } else { qLog(Hardware) << __PRETTY_FUNCTION__ << "is gta01"; muxEnabled = false; } QSettings cfg("Trolltech", "Modem"); QString multiplexing = cfg.value("Multiplexing/Active", "yes").toString(); muxEnabled &= (multiplexing != "no"); qLog(Mux) << "Neo multiplexing " << (muxEnabled ? "enabled" : "disabled") << multiplexing; // Make the modem talk to us. It can be a bit rough to get // it initialized... So we will empty the current buffer // and then send ^Z\r\n and wait for an OK or AT from the modem. This is // mostly based on ideas from ogsmd device->readAll(); int attempts = 0; for (; attempts < 2; ++attempts) { if (QSerialIODeviceMultiplexer::chat(device, QChar(0x1a))) { qLog(Modem) << "Attempts needed to initialize the modem" << attempts; break; } } if (attempts == 2) { qWarning() << "Initializing the modem failed."; abort(); } // disable echoing of commands QSerialIODeviceMultiplexer::chat(device, "ATE0"); device->readAll(); if (muxEnabled) { // Issue the AT+CMUX command to determine if this device // uses GSM 07.10-style multiplexing. return QGsm0710Multiplexer::cmuxChat( device, NEO_FRAME_SIZE, true ); } return true; }