#include #include "globals.hxx" #include "fg_init.hxx" #include "fg_os.hxx" #include "fg_props.hxx" #include "options.hxx" #include "util.hxx" #include "main.hxx" #include "locale.hxx" #include #include #include #include #include #include "AircraftDirVisitorBase.hxx" #include #include #include using std::string; using std::sort; using std::cout; using std::cerr; using std::endl; using std::vector; using std::cin; using namespace flightgear; #define NEW_DEFAULT_MODEL_HZ 120 static flightgear::Options* shared_instance = nullptr; static double atof( const string& str ) { return ::atof( str.c_str() ); } static int atoi( const string& str ) { return ::atoi( str.c_str() ); } static int fgSetupProxy( const char *arg ); /** * Set a few fail-safe default property values. * * These should all be set in $FG_ROOT/defaults.xml, but just * in case, we provide some initial sane values here. This method * should be invoked *before* reading any init files. */ void fgSetDefaults () { // Position (deliberately out of range) fgSetDouble("/position/longitude-deg", 9999.0); fgSetDouble("/position/latitude-deg", 9999.0); fgSetDouble("/position/altitude-ft", -9999.0); // Orientation fgSetDouble("/orientation/heading-deg", 9999.0); fgSetDouble("/orientation/roll-deg", 0.0); fgSetDouble("/orientation/pitch-deg", 0.424); // Velocities fgSetDouble("/velocities/uBody-fps", 0.0); fgSetDouble("/velocities/vBody-fps", 0.0); fgSetDouble("/velocities/wBody-fps", 0.0); fgSetDouble("/velocities/speed-north-fps", 0.0); fgSetDouble("/velocities/speed-east-fps", 0.0); fgSetDouble("/velocities/speed-down-fps", 0.0); fgSetDouble("/velocities/airspeed-kt", 0.0); fgSetDouble("/velocities/mach", 0.0); // Presets fgSetDouble("/sim/presets/longitude-deg", 9999.0); fgSetDouble("/sim/presets/latitude-deg", 9999.0); fgSetDouble("/sim/presets/altitude-ft", -9999.0); fgSetDouble("/sim/presets/heading-deg", 9999.0); fgSetDouble("/sim/presets/roll-deg", 0.0); fgSetDouble("/sim/presets/pitch-deg", 0.424); fgSetString("/sim/presets/speed-set", "knots"); fgSetDouble("/sim/presets/airspeed-kt", 0.0); fgSetDouble("/sim/presets/mach", 0.0); fgSetDouble("/sim/presets/uBody-fps", 0.0); fgSetDouble("/sim/presets/vBody-fps", 0.0); fgSetDouble("/sim/presets/wBody-fps", 0.0); fgSetDouble("/sim/presets/speed-north-fps", 0.0); fgSetDouble("/sim/presets/speed-east-fps", 0.0); fgSetDouble("/sim/presets/speed-down-fps", 0.0); fgSetDouble("/sim/presets/offset-distance-nm", 0.0); fgSetBool("/sim/presets/runway-requested", false); fgSetBool("/sim/presets/onground", true); fgSetBool("/sim/presets/trim", false); // Miscellaneous fgSetBool("/sim/startup/splash-screen", true); // we want mouse-pointer to have an undefined value if nothing is // specified so we can do the right thing for voodoo-1/2 cards. // fgSetString("/sim/startup/mouse-pointer", "disabled"); fgSetBool("/controls/flight/auto-coordination", false); fgSetString("/sim/logging/priority", "alert"); // Features fgSetBool("/sim/hud/color/antialiased", false); fgSetBool("/sim/hud/enable3d[1]", true); fgSetBool("/sim/hud/visibility[1]", false); fgSetBool("/sim/panel/visibility", true); fgSetBool("/sim/sound/enabled", true); fgSetBool("/sim/sound/working", true); fgSetBool("/sim/fgcom/enabled", false); // Flight Model options fgSetString("/sim/flight-model", "jsb"); fgSetString("/sim/aero", "c172"); fgSetInt("/sim/model-hz", NEW_DEFAULT_MODEL_HZ); fgSetDouble("/sim/speed-up", 1.0); // Scenery fgSetString("/sim/scenery/engine", "tilecache"); // ( scenery = pagedLOD ) fgSetString("/sim/scenery/lod-levels", "1 3 5 7 9"); fgSetString("/sim/scenery/lod-res", "1"); fgSetString("/sim/scenery/lod-texturing", "bluemarble"); // Rendering options fgSetString("/sim/rendering/fog", "nicest"); fgSetBool("/environment/clouds/status", true); fgSetBool("/sim/startup/fullscreen", false); fgSetBool("/sim/rendering/shading", true); fgTie( "/sim/rendering/filtering", SGGetTextureFilter, SGSetTextureFilter, false); fgSetInt("/sim/rendering/filtering", 1); fgSetBool("/sim/rendering/wireframe", false); fgSetBool("/sim/rendering/horizon-effect", false); fgSetBool("/sim/rendering/distance-attenuation", false); fgSetBool("/sim/rendering/specular-highlight", true); fgSetString("/sim/rendering/materials-file", "materials.xml"); fgSetInt("/sim/startup/xsize", 1024); fgSetInt("/sim/startup/ysize", 768); fgSetInt("/sim/rendering/bits-per-pixel", 32); fgSetString("/sim/view-mode", "pilot"); fgSetDouble("/sim/current-view/heading-offset-deg", 0); // HUD options fgSetString("/sim/startup/units", "feet"); fgSetString("/sim/hud/frame-stat-type", "tris"); // Time options fgSetInt("/sim/startup/time-offset", 0); fgSetString("/sim/startup/time-offset-type", "system-offset"); fgSetLong("/sim/time/cur-time-override", 0); // Freeze options fgSetBool("/sim/freeze/master", false); fgSetBool("/sim/freeze/position", false); fgSetBool("/sim/freeze/clock", false); fgSetBool("/sim/freeze/fuel", false); fgSetString("/sim/multiplay/callsign", "callsign"); fgSetString("/sim/multiplay/rxhost", ""); fgSetString("/sim/multiplay/txhost", ""); fgSetInt("/sim/multiplay/rxport", 0); fgSetInt("/sim/multiplay/txport", 0); SGPropertyNode* v = globals->get_props()->getNode("/sim/version", true); v->setValueReadOnly("flightgear", FLIGHTGEAR_VERSION); v->setValueReadOnly("simgear", SG_STRINGIZE(SIMGEAR_VERSION)); v->setValueReadOnly("openscenegraph", osgGetVersion()); #if OSG_VERSION_LESS_THAN(3,5,2) v->setValueReadOnly("openscenegraph-thread-safe-reference-counting", osg::Referenced::getThreadSafeReferenceCounting()); #endif v->setValueReadOnly("revision", REVISION); v->setValueReadOnly("build-number", JENKINS_BUILD_NUMBER); v->setValueReadOnly("build-id", JENKINS_BUILD_ID); v->setValueReadOnly("hla-support", bool(FG_HAVE_HLA)); v->setValueReadOnly("build-type", FG_BUILD_TYPE); char* envp = ::getenv( "http_proxy" ); if( envp != nullptr ) fgSetupProxy( envp ); } /////////////////////////////////////////////////////////////////////////////// // helper object to implement the --show-aircraft command. // resides here so we can share the fgFindAircraftInDir template above, // and hence ensure this command lists exectly the same aircraft as the normal // loading path. class ShowAircraft : public AircraftDirVistorBase { public: ShowAircraft() { _minStatus = getNumMaturity(fgGetString("/sim/aircraft-min-status", "all")); } void show(const vector & path_list) { for (vector::const_iterator p = path_list.begin(); p != path_list.end(); ++p) visitDir(*p, 0); simgear::requestConsole(false); // ensure console is shown on Windows std::sort(_aircraft.begin(), _aircraft.end(), [](const std::string& lhs, const std::string& rhs) { return strcasecmp(lhs.c_str(), rhs.c_str()) < 0 ? 1 : 0; }); cout << "Available aircraft:" << endl; for ( unsigned int i = 0; i < _aircraft.size(); i++ ) { cout << _aircraft[i] << endl; } } private: virtual VisitResult visit(const SGPath& path) { SGPropertyNode root; try { readProperties(path, &root); } catch (sg_exception& ) { return VISIT_CONTINUE; } int maturity = 0; string descStr(" "); descStr += path.file(); // trim common suffix from file names int nPos = descStr.rfind("-set.xml"); if (nPos == (int)(descStr.size() - 8)) { descStr.resize(nPos); } SGPropertyNode *node = root.getNode("sim"); if (node) { SGPropertyNode* desc = node->getNode("description"); // if a status tag is found, read it in if (node->hasValue("status")) { maturity = getNumMaturity(node->getStringValue("status")); } if (desc) { if (descStr.size() <= 27+3) { descStr.append(29+3-descStr.size(), ' '); } else { descStr += '\n'; descStr.append( 32, ' '); } descStr += desc->getStringValue(); } } // of have 'sim' node if (maturity >= _minStatus) { _aircraft.push_back(descStr); } return VISIT_CONTINUE; } int getNumMaturity(const char * str) { // Changes should also be reflected in $FG_ROOT/options.xml const char* levels[] = {"alpha","beta","early-production","production"}; if (!strcmp(str, "all")) { return 0; } for (size_t i=0; i<(sizeof(levels)/sizeof(levels[0]));i++) if (strcmp(str,levels[i])==0) return i; return 0; } int _minStatus; string_list _aircraft; }; /* * Search in the current directory, and in on directory deeper * for -set.xml configuration files and show the aircaft name * and the contents of the tag in a sorted manner. * * @parampath the directory to search for configuration files */ void fgShowAircraft(const vector &path_list) { ShowAircraft s; s.show(path_list); #ifdef _MSC_VER cout << "Hit a key to continue..." << endl; std::cin.get(); #endif } static bool parse_wind (const string &wind, double * min_hdg, double * max_hdg, double * speed, double * gust) { string::size_type pos = wind.find('@'); if (pos == string::npos) return false; string dir = wind.substr(0, pos); string spd = wind.substr(pos+1); pos = dir.find(':'); if (pos == string::npos) { *min_hdg = *max_hdg = atof(dir.c_str()); } else { *min_hdg = atof(dir.substr(0,pos).c_str()); *max_hdg = atof(dir.substr(pos+1).c_str()); } pos = spd.find(':'); if (pos == string::npos) { *speed = *gust = atof(spd.c_str()); } else { *speed = atof(spd.substr(0,pos).c_str()); *gust = atof(spd.substr(pos+1).c_str()); } return true; } static bool parseIntValue(char** ppParserPos, int* pValue,int min, int max, const char* field, const char* argument) { if ( !strlen(*ppParserPos) ) return true; char num[256]; int i = 0; while ( isdigit((*ppParserPos)[0]) && (i<255) ) { num[i] = (*ppParserPos)[0]; (*ppParserPos)++; i++; } num[i] = '\0'; switch ((*ppParserPos)[0]) { case 0: break; case ':': (*ppParserPos)++; break; default: SG_LOG(SG_GENERAL, SG_ALERT, "Illegal character in time string for " << field << ": '" << (*ppParserPos)[0] << "'."); // invalid field - skip rest of string to avoid further errors while ((*ppParserPos)[0]) (*ppParserPos)++; return false; } if (i<=0) return true; int value = atoi(num); if ((value < min)||(value > max)) { SG_LOG(SG_GENERAL, SG_ALERT, "Invalid " << field << " in '" << argument << "'. Valid range is " << min << "-" << max << "."); return false; } else { *pValue = value; return true; } } // parse a time string ([+/-]%f[:%f[:%f]]) into hours static double parse_time(const string& time_in) { char *time_str, num[256]; double hours, minutes, seconds; double result = 0.0; int sign = 1; int i; time_str = (char *)time_in.c_str(); // printf("parse_time(): %s\n", time_str); // check for sign if ( strlen(time_str) ) { if ( time_str[0] == '+' ) { sign = 1; time_str++; } else if ( time_str[0] == '-' ) { sign = -1; time_str++; } } // printf("sign = %d\n", sign); // get hours if ( strlen(time_str) ) { i = 0; while ( (time_str[0] != ':') && (time_str[0] != '\0') ) { num[i] = time_str[0]; time_str++; i++; } if ( time_str[0] == ':' ) { time_str++; } num[i] = '\0'; hours = atof(num); // printf("hours = %.2lf\n", hours); result += hours; } // get minutes if ( strlen(time_str) ) { i = 0; while ( (time_str[0] != ':') && (time_str[0] != '\0') ) { num[i] = time_str[0]; time_str++; i++; } if ( time_str[0] == ':' ) { time_str++; } num[i] = '\0'; minutes = atof(num); // printf("minutes = %.2lf\n", minutes); result += minutes / 60.0; } // get seconds if ( strlen(time_str) ) { i = 0; while ( (time_str[0] != ':') && (time_str[0] != '\0') ) { num[i] = time_str[0]; time_str++; i++; } num[i] = '\0'; seconds = atof(num); // printf("seconds = %.2lf\n", seconds); result += seconds / 3600.0; } SG_LOG( SG_GENERAL, SG_INFO, " parse_time() = " << sign * result ); return(sign * result); } // parse a date string (yyyy:mm:dd:hh:mm:ss) into a time_t (seconds) static long int parse_date( const string& date, const char* timeType) { struct tm gmt,*pCurrentTime; int year,month,day,hour,minute,second; char *argument, *date_str; SGTime CurrentTime; CurrentTime.update(SGGeod(),0,0); // FIXME This should obtain system/aircraft/GMT time depending on timeType pCurrentTime = CurrentTime.getGmt(); // initialize all fields with current time year = pCurrentTime->tm_year + 1900; month = pCurrentTime->tm_mon + 1; day = pCurrentTime->tm_mday; hour = pCurrentTime->tm_hour; minute = pCurrentTime->tm_min; second = pCurrentTime->tm_sec; argument = (char *)date.c_str(); date_str = argument; // start with parsing year if (!strlen(date_str) || !parseIntValue(&date_str,&year,0,9999,"year",argument)) { return -1; } if (year < 1970) { SG_LOG(SG_GENERAL, SG_ALERT, "Invalid year '" << year << "'. Use 1970 or later."); return -1; } parseIntValue(&date_str, &month, 1, 12, "month", argument); parseIntValue(&date_str, &day, 1, 31, "day", argument); parseIntValue(&date_str, &hour, 0, 23, "hour", argument); parseIntValue(&date_str, &minute, 0, 59, "minute", argument); parseIntValue(&date_str, &second, 0, 59, "second", argument); gmt.tm_sec = second; gmt.tm_min = minute; gmt.tm_hour = hour; gmt.tm_mday = day; gmt.tm_mon = month - 1; gmt.tm_year = year -1900; gmt.tm_isdst = 0; // ignore daylight savings time for the moment time_t theTime = sgTimeGetGMT( gmt.tm_year, gmt.tm_mon, gmt.tm_mday, gmt.tm_hour, gmt.tm_min, gmt.tm_sec ); SG_LOG(SG_GENERAL, SG_INFO, "Configuring startup time to " << ctime(&theTime)); return (theTime); } // parse angle in the form of [+/-]ddd:mm:ss into degrees static double parse_degree( const string& degree_str) { double result = parse_time( degree_str ); // printf("Degree = %.4f\n", result); return(result); } // parse time offset string into seconds static long int parse_time_offset( const string& time_str) { long int result; // printf("time offset = %s\n", time_str); #ifdef HAVE_RINT result = (int)rint(parse_time(time_str) * 3600.0); #else result = (int)(parse_time(time_str) * 3600.0); #endif // printf("parse_time_offset(): %d\n", result); return( result ); } // Parse --fov=x.xx type option static double parse_fov( const string& arg ) { double fov = atof(arg); if ( fov < FG_FOV_MIN ) { fov = FG_FOV_MIN; } if ( fov > FG_FOV_MAX ) { fov = FG_FOV_MAX; } fgSetDouble("/sim/view[0]/config/default-field-of-view-deg", fov); // printf("parse_fov(): result = %.4f\n", fov); return fov; } // Parse I/O channel option // // Format is "--protocol=medium,direction,hz,medium_options,..." // // protocol = { native, nmea, garmin, AV400, AV400Sim, fgfs, rul, pve, etc. } // medium = { serial, socket, file, etc. } // direction = { in, out, bi } // hz = number of times to process channel per second (floating // point values are ok. // // Serial example "--nmea=serial,dir,hz,device,baud" where // // device = OS device name of serial line to be open()'ed // baud = {300, 1200, 2400, ..., 230400} // // Socket example "--native=socket,dir,hz,machine,port,style" where // // machine = machine name or ip address if client (leave empty if server) // port = port, leave empty to let system choose // style = tcp or udp // // File example "--garmin=file,dir,hz,filename" where // // filename = file system file name static bool add_channel( const string& type, const string& channel_str ) { // This check is necessary to prevent fgviewer from segfaulting when given // weird options. (It doesn't run the full initialization) if(!globals->get_channel_options_list()) { SG_LOG(SG_GENERAL, SG_ALERT, "Option " << type << "=" << channel_str << " ignored."); return false; } SG_LOG(SG_GENERAL, SG_INFO, "Channel string = " << channel_str ); globals->get_channel_options_list()->push_back( type + "," + channel_str ); return true; } static void clearLocation () { fgSetString("/sim/presets/airport-id", ""); fgSetString("/sim/presets/vor-id", ""); fgSetString("/sim/presets/ndb-id", ""); fgSetString("/sim/presets/carrier", ""); fgSetString("/sim/presets/parkpos", ""); fgSetString("/sim/presets/carrier-position", ""); fgSetString("/sim/presets/fix", ""); } /* Using --addon=/foo/bar does: - register the add-on with the AddonManager (enabling, among other things, add-on-specific resources for simgear::ResourceManager); - load /foo/bar/addon-config.xml into the Global Property Tree; - add /foo/bar to the list of aircraft paths to provide read access: - set various properties related to the add-on under /addons; - load /foo/bar/addon-main.nas into namespace __addon[ADDON_ID]__ (see $FG_ROOT/Nasal/addons.nas); - call the main() function defined in that file. For more details, see $FG_ROOT/Docs/README.add-ons. */ static int fgOptAddon(const char *arg) { const SGPath addonPath = SGPath::fromUtf8(arg); const auto& addonManager = addons::AddonManager::instance(); try { addonManager->registerAddon(addonPath); } catch (const sg_exception &e) { string msg = "Error registering an add-on: " + e.getFormattedMessage(); SG_LOG(SG_GENERAL, SG_ALERT, msg); flightgear::fatalMessageBoxThenExit( "FlightGear", "Unable to register an add-on.", msg); } return FG_OPTIONS_OK; } static int fgOptAdditionalDataDir(const char* arg) { const SGPath dataPath = SGPath::fromUtf8(arg); if (!dataPath.exists()) { SG_LOG(SG_GENERAL, SG_ALERT, "--data path not found:'" << dataPath << "'"); flightgear::fatalMessageBoxWithoutExit( "FlightGear", "Data path not found: '" + dataPath.utf8Str() + "'."); return FG_OPTIONS_EXIT; } globals->append_data_path(dataPath, false /* = before FG_ROOT */); return FG_OPTIONS_OK; } static int fgOptVOR( const char * arg ) { clearLocation(); fgSetString("/sim/presets/vor-id", arg); return FG_OPTIONS_OK; } static int fgOptNDB( const char * arg ) { clearLocation(); fgSetString("/sim/presets/ndb-id", arg); return FG_OPTIONS_OK; } static int fgOptCarrier( const char * arg ) { clearLocation(); fgSetString("/sim/presets/carrier", arg); return FG_OPTIONS_OK; } static int fgOptCarrierPos( const char * arg ) { fgSetString("/sim/presets/carrier-position", arg); return FG_OPTIONS_OK; } static int fgOptParkpos( const char * arg ) { fgSetString("/sim/presets/parkpos", arg); fgSetBool("/sim/presets/parking-requested", true); return FG_OPTIONS_OK; } static int fgOptFIX( const char * arg ) { clearLocation(); fgSetString("/sim/presets/fix", arg); return FG_OPTIONS_OK; } static int fgOptLon( const char *arg ) { clearLocation(); fgSetDouble("/sim/presets/longitude-deg", parse_degree( arg )); fgSetDouble("/position/longitude-deg", parse_degree( arg )); return FG_OPTIONS_OK; } static int fgOptLat( const char *arg ) { clearLocation(); fgSetDouble("/sim/presets/latitude-deg", parse_degree( arg )); fgSetDouble("/position/latitude-deg", parse_degree( arg )); return FG_OPTIONS_OK; } static int fgOptAltitude( const char *arg ) { fgSetBool("/sim/presets/onground", false); if ( !strcmp(fgGetString("/sim/startup/units"), "feet") ) fgSetDouble("/sim/presets/altitude-ft", atof( arg )); else fgSetDouble("/sim/presets/altitude-ft", atof( arg ) * SG_METER_TO_FEET); return FG_OPTIONS_OK; } static int fgOptUBody( const char *arg ) { fgSetString("/sim/presets/speed-set", "UVW"); if ( !strcmp(fgGetString("/sim/startup/units"), "feet") ) fgSetDouble("/sim/presets/uBody-fps", atof( arg )); else fgSetDouble("/sim/presets/uBody-fps", atof( arg ) * SG_METER_TO_FEET); return FG_OPTIONS_OK; } static int fgOptVBody( const char *arg ) { fgSetString("/sim/presets/speed-set", "UVW"); if ( !strcmp(fgGetString("/sim/startup/units"), "feet") ) fgSetDouble("/sim/presets/vBody-fps", atof( arg )); else fgSetDouble("/sim/presets/vBody-fps", atof( arg ) * SG_METER_TO_FEET); return FG_OPTIONS_OK; } static int fgOptWBody( const char *arg ) { fgSetString("/sim/presets/speed-set", "UVW"); if ( !strcmp(fgGetString("/sim/startup/units"), "feet") ) fgSetDouble("/sim/presets/wBody-fps", atof(arg)); else fgSetDouble("/sim/presets/wBody-fps", atof(arg) * SG_METER_TO_FEET); return FG_OPTIONS_OK; } static int fgOptVNorth( const char *arg ) { fgSetString("/sim/presets/speed-set", "NED"); if ( !strcmp(fgGetString("/sim/startup/units"), "feet") ) fgSetDouble("/sim/presets/speed-north-fps", atof( arg )); else fgSetDouble("/sim/presets/speed-north-fps", atof( arg ) * SG_METER_TO_FEET); return FG_OPTIONS_OK; } static int fgOptVEast( const char *arg ) { fgSetString("/sim/presets/speed-set", "NED"); if ( !strcmp(fgGetString("/sim/startup/units"), "feet") ) fgSetDouble("/sim/presets/speed-east-fps", atof(arg)); else fgSetDouble("/sim/presets/speed-east-fps", atof(arg) * SG_METER_TO_FEET); return FG_OPTIONS_OK; } static int fgOptVDown( const char *arg ) { fgSetString("/sim/presets/speed-set", "NED"); if ( !strcmp(fgGetString("/sim/startup/units"), "feet") ) fgSetDouble("/sim/presets/speed-down-fps", atof(arg)); else fgSetDouble("/sim/presets/speed-down-fps", atof(arg) * SG_METER_TO_FEET); return FG_OPTIONS_OK; } static int fgOptVc( const char *arg ) { // fgSetString("/sim/presets/speed-set", "knots"); // fgSetDouble("/velocities/airspeed-kt", atof(arg.substr(5))); fgSetString("/sim/presets/speed-set", "knots"); fgSetDouble("/sim/presets/airspeed-kt", atof(arg)); return FG_OPTIONS_OK; } static int fgOptMach( const char *arg ) { fgSetString("/sim/presets/speed-set", "mach"); fgSetDouble("/sim/presets/mach", atof(arg)); return FG_OPTIONS_OK; } static int fgOptRoc( const char *arg ) { fgSetDouble("/sim/presets/vertical-speed-fps", atof(arg)/60); return FG_OPTIONS_OK; } static int fgOptFgScenery( const char *arg ) { globals->append_fg_scenery(SGPath::pathsFromUtf8(arg)); return FG_OPTIONS_OK; } static int fgOptAllowNasalRead( const char *arg ) { PathList paths = SGPath::pathsFromUtf8(arg); if(paths.size() == 0) { SG_LOG(SG_GENERAL, SG_WARN, "--allow-nasal-read requires a list of directories to allow"); } for( PathList::const_iterator it = paths.begin(); it != paths.end(); ++it ) { globals->append_read_allowed_paths(*it); } return FG_OPTIONS_OK; } static int fgOptFov( const char *arg ) { parse_fov( arg ); return FG_OPTIONS_OK; } static int fgOptGeometry( const char *arg ) { bool geometry_ok = true; int xsize = 0, ysize = 0; string geometry = arg; string::size_type i = geometry.find('x'); if (i != string::npos) { xsize = atoi(geometry.substr(0, i)); ysize = atoi(geometry.substr(i+1)); } else { geometry_ok = false; } if ( xsize <= 0 || ysize <= 0 ) { xsize = 640; ysize = 480; geometry_ok = false; } if ( !geometry_ok ) { SG_LOG( SG_GENERAL, SG_ALERT, "Unknown geometry: " << geometry ); SG_LOG( SG_GENERAL, SG_ALERT, "Setting geometry to " << xsize << 'x' << ysize << '\n'); } else { SG_LOG( SG_GENERAL, SG_INFO, "Setting geometry to " << xsize << 'x' << ysize << '\n'); fgSetInt("/sim/startup/xsize", xsize); fgSetInt("/sim/startup/ysize", ysize); } return FG_OPTIONS_OK; } static int fgOptBpp( const char *arg ) { string bits_per_pix = arg; if ( bits_per_pix == "16" ) { fgSetInt("/sim/rendering/bits-per-pixel", 16); } else if ( bits_per_pix == "24" ) { fgSetInt("/sim/rendering/bits-per-pixel", 24); } else if ( bits_per_pix == "32" ) { fgSetInt("/sim/rendering/bits-per-pixel", 32); } else { SG_LOG(SG_GENERAL, SG_ALERT, "Unsupported bpp " << bits_per_pix); } return FG_OPTIONS_OK; } static int fgOptTimeOffset( const char *arg ) { fgSetLong("/sim/startup/time-offset", parse_time_offset( arg )); fgSetString("/sim/startup/time-offset-type", "system-offset"); return FG_OPTIONS_OK; } static int fgOptStartDateSys( const char *arg ) { long int theTime = parse_date( arg, "system" ); if (theTime>=0) { fgSetLong("/sim/startup/time-offset", theTime); fgSetString("/sim/startup/time-offset-type", "system"); } return FG_OPTIONS_OK; } static int fgOptStartDateLat( const char *arg ) { long int theTime = parse_date( arg, "latitude" ); if (theTime>=0) { fgSetLong("/sim/startup/time-offset", theTime); fgSetString("/sim/startup/time-offset-type", "latitude"); } return FG_OPTIONS_OK; } static int fgOptStartDateGmt( const char *arg ) { long int theTime = parse_date( arg, "gmt" ); if (theTime>=0) { fgSetLong("/sim/startup/time-offset", theTime); fgSetString("/sim/startup/time-offset-type", "gmt"); } return FG_OPTIONS_OK; } static int fgOptJpgHttpd( const char * arg ) { SG_LOG(SG_ALL,SG_ALERT, "the option --jpg-httpd is no longer supported! Please use --httpd instead." " URL for the screenshot within the new httpd is http://YourFgServer:xxxx/screenshot"); return FG_OPTIONS_EXIT; } static int fgOptHttpd( const char * arg ) { // port may be any valid address:port notation // like 127.0.0.1:8080 // or just the port 8080 string port = simgear::strutils::strip(string(arg)); if( port.empty() ) return FG_OPTIONS_ERROR; fgSetString( string(flightgear::http::PROPERTY_ROOT).append("/options/listening-port").c_str(), port ); return FG_OPTIONS_OK; } static int fgSetupProxy( const char *arg ) { string options = simgear::strutils::strip( arg ); string host, port, auth; string::size_type pos; // this is NURLP - NURLP is not an url parser if( simgear::strutils::starts_with( options, "http://" ) ) options = options.substr( 7 ); if( simgear::strutils::ends_with( options, "/" ) ) options = options.substr( 0, options.length() - 1 ); host = port = auth = ""; if ((pos = options.find("@")) != string::npos) auth = options.substr(0, pos++); else pos = 0; host = options.substr(pos, options.size()); if ((pos = host.find(":")) != string::npos) { port = host.substr(++pos, host.size()); host.erase(--pos, host.size()); } fgSetString("/sim/presets/proxy/host", host.c_str()); fgSetString("/sim/presets/proxy/port", port.c_str()); fgSetString("/sim/presets/proxy/authentication", auth.c_str()); return FG_OPTIONS_OK; } static int fgOptTraceRead( const char *arg ) { string name = arg; SG_LOG(SG_GENERAL, SG_INFO, "Tracing reads for property " << name); fgGetNode(name.c_str(), true) ->setAttribute(SGPropertyNode::TRACE_READ, true); return FG_OPTIONS_OK; } static int fgOptLogLevel( const char *arg ) { fgSetString("/sim/logging/priority", arg); setLoggingPriority(arg); return FG_OPTIONS_OK; } static int fgOptLogClasses( const char *arg ) { fgSetString("/sim/logging/classes", arg); setLoggingClasses (arg); return FG_OPTIONS_OK; } static int fgOptLogDir(const char* arg) { SGPath dirPath; if (!strcmp(arg, "desktop")) { dirPath = SGPath::desktop(); } else { dirPath = SGPath::fromUtf8(arg); } if (!dirPath.isDir()) { SG_LOG(SG_GENERAL, SG_ALERT, "cannot find logging location " << dirPath); return FG_OPTIONS_ERROR; } if (!dirPath.canWrite()) { SG_LOG(SG_GENERAL, SG_ALERT, "cannot write to logging location " << dirPath); return FG_OPTIONS_ERROR; } // generate the log file name SGPath logFile; { char fileNameBuffer[100]; time_t now; time(&now); strftime(fileNameBuffer, 99, "FlightGear_%F", localtime(&now)); unsigned int logsTodayCount = 0; while (true) { std::ostringstream os; os << fileNameBuffer << "_" << logsTodayCount++ << ".log"; logFile = dirPath / os.str(); if (!logFile.exists()) { break; } } } sglog().logToFile(logFile, sglog().get_log_classes(), sglog().get_log_priority()); return FG_OPTIONS_OK; } static int fgOptTraceWrite( const char *arg ) { string name = arg; SG_LOG(SG_GENERAL, SG_INFO, "Tracing writes for property " << name); fgGetNode(name.c_str(), true) ->setAttribute(SGPropertyNode::TRACE_WRITE, true); return FG_OPTIONS_OK; } static int fgOptViewOffset( const char *arg ) { // $$$ begin - added VS Renganathan, 14 Oct 2K // for multi-window outside window imagery string woffset = arg; double default_view_offset = 0.0; if ( woffset == "LEFT" ) { default_view_offset = SGD_PI * 0.25; } else if ( woffset == "RIGHT" ) { default_view_offset = SGD_PI * 1.75; } else if ( woffset == "CENTER" ) { default_view_offset = 0.00; } else { default_view_offset = atof( woffset.c_str() ) * SGD_DEGREES_TO_RADIANS; } /* apparently not used (CLO, 11 Jun 2002) FGViewer *pilot_view = (FGViewer *)globals->get_viewmgr()->get_view( 0 ); */ // this will work without calls to the viewer... fgSetDouble( "/sim/current-view/heading-offset-deg", default_view_offset * SGD_RADIANS_TO_DEGREES ); // $$$ end - added VS Renganathan, 14 Oct 2K return FG_OPTIONS_OK; } static int fgOptVisibilityMeters( const char *arg ) { Environment::Presets::VisibilitySingleton::instance()->preset( atof( arg ) ); return FG_OPTIONS_OK; } static int fgOptVisibilityMiles( const char *arg ) { Environment::Presets::VisibilitySingleton::instance()->preset( atof( arg ) * 5280.0 * SG_FEET_TO_METER ); return FG_OPTIONS_OK; } static int fgOptMetar(const char *arg) { // The given METAR string cannot be effective without disabling // real weather fetching. fgSetBool("/environment/realwx/enabled", false); // The user-supplied METAR string fgSetString("/environment/metar/data", arg); return FG_OPTIONS_OK; } static int fgOptConsole(const char *arg) { static bool already_done = false; if (!already_done) { already_done = true; simgear::requestConsole(false); } return FG_OPTIONS_OK; } static int fgOptRandomWind( const char *arg ) { double min_hdg = sg_random() * 360.0; double max_hdg = min_hdg + (20 - sqrt(sg_random() * 400)); double speed = sg_random() * sg_random() * 40; double gust = speed + (10 - sqrt(sg_random() * 100)); Environment::Presets::WindSingleton::instance()->preset(min_hdg, max_hdg, speed, gust); return FG_OPTIONS_OK; } static int fgOptWind( const char *arg ) { double min_hdg = 0.0, max_hdg = 0.0, speed = 0.0, gust = 0.0; if (!parse_wind( arg, &min_hdg, &max_hdg, &speed, &gust)) { SG_LOG( SG_GENERAL, SG_ALERT, "bad wind value " << arg ); return FG_OPTIONS_ERROR; } Environment::Presets::WindSingleton::instance()->preset(min_hdg, max_hdg, speed, gust); return FG_OPTIONS_OK; } static int fgOptTurbulence( const char *arg ) { Environment::Presets::TurbulenceSingleton::instance()->preset( atof(arg) ); return FG_OPTIONS_OK; } static int fgOptCeiling( const char *arg ) { double elevation, thickness; string spec = arg; string::size_type pos = spec.find(':'); if (pos == string::npos) { elevation = atof(spec.c_str()); thickness = 2000; } else { elevation = atof(spec.substr(0, pos).c_str()); thickness = atof(spec.substr(pos + 1).c_str()); } Environment::Presets::CeilingSingleton::instance()->preset( elevation, thickness ); return FG_OPTIONS_OK; } static int fgOptWp( const char *arg ) { string_list *waypoints = globals->get_initial_waypoints(); if (!waypoints) { waypoints = new string_list; globals->set_initial_waypoints(waypoints); } waypoints->push_back(arg); return FG_OPTIONS_OK; } static bool parse_colon (const string &s, double * val1, double * val2) { string::size_type pos = s.find(':'); if (pos == string::npos) { *val2 = atof(s); return false; } else { *val1 = atof(s.substr(0, pos).c_str()); *val2 = atof(s.substr(pos+1).c_str()); return true; } } static int fgOptFailure( const char * arg ) { string a = arg; if (a == "pitot") { fgSetBool("/systems/pitot/serviceable", false); } else if (a == "static") { fgSetBool("/systems/static/serviceable", false); } else if (a == "vacuum") { fgSetBool("/systems/vacuum/serviceable", false); } else if (a == "electrical") { fgSetBool("/systems/electrical/serviceable", false); } else { SG_LOG(SG_INPUT, SG_ALERT, "Unknown failure mode: " << a); return FG_OPTIONS_ERROR; } return FG_OPTIONS_OK; } static int fgOptNAV1( const char * arg ) { double radial, freq; if (parse_colon(arg, &radial, &freq)) fgSetDouble("/instrumentation/nav[0]/radials/selected-deg", radial); fgSetDouble("/instrumentation/nav[0]/frequencies/selected-mhz", freq); return FG_OPTIONS_OK; } static int fgOptNAV2( const char * arg ) { double radial, freq; if (parse_colon(arg, &radial, &freq)) fgSetDouble("/instrumentation/nav[1]/radials/selected-deg", radial); fgSetDouble("/instrumentation/nav[1]/frequencies/selected-mhz", freq); return FG_OPTIONS_OK; } static int fgOptADF( const char * arg ) { SG_LOG(SG_ALL,SG_ALERT, "the option --adf is no longer supported! Please use --adf1 " "instead."); return FG_OPTIONS_EXIT; } static int fgOptADF1( const char * arg ) { double rot, freq; if (parse_colon(arg, &rot, &freq)) fgSetDouble("/instrumentation/adf[0]/rotation-deg", rot); fgSetDouble("/instrumentation/adf[0]/frequencies/selected-khz", freq); return FG_OPTIONS_OK; } static int fgOptADF2( const char * arg ) { double rot, freq; if (parse_colon(arg, &rot, &freq)) fgSetDouble("/instrumentation/adf[1]/rotation-deg", rot); fgSetDouble("/instrumentation/adf[1]/frequencies/selected-khz", freq); return FG_OPTIONS_OK; } static int fgOptDME( const char *arg ) { string opt = arg; if (opt == "nav1") { fgSetInt("/instrumentation/dme/switch-position", 1); fgSetString("/instrumentation/dme/frequencies/source", "/instrumentation/nav[0]/frequencies/selected-mhz"); } else if (opt == "nav2") { fgSetInt("/instrumentation/dme/switch-position", 3); fgSetString("/instrumentation/dme/frequencies/source", "/instrumentation/nav[1]/frequencies/selected-mhz"); } else { double frequency = atof(arg); if (frequency==0.0) { SG_LOG(SG_INPUT, SG_ALERT, "Invalid DME frequency: '" << arg << "'."); return FG_OPTIONS_ERROR; } fgSetInt("/instrumentation/dme/switch-position", 2); fgSetString("/instrumentation/dme/frequencies/source", "/instrumentation/dme/frequencies/selected-mhz"); fgSetDouble("/instrumentation/dme/frequencies/selected-mhz", frequency); } return FG_OPTIONS_OK; } static int fgOptLivery( const char *arg ) { string opt = arg; string livery_path = "livery/" + opt; fgSetString("/sim/model/texture-path", livery_path.c_str() ); return FG_OPTIONS_OK; } static int fgOptScenario( const char *arg ) { SGPath path(arg); std::string name(arg); if (path.exists()) { if (path.isRelative()) { // make absolute path = simgear::Dir::current().path() / arg; } // create description node auto n = FGAIManager::registerScenarioFile(globals->get_props(), path); if (!n) { SG_LOG(SG_GENERAL, SG_WARN, "failed to read scenario file at:" << path); return FG_OPTIONS_ERROR; } // also set the /sim/ai/scenario entry so we load it on startup name = path.file_base(); } // add the 'load it' node SGPropertyNode_ptr ai_node = fgGetNode( "/sim/ai", true ); ai_node->addChild("scenario")->setStringValue(name); return FG_OPTIONS_OK; } static int fgOptAirport( const char *arg ) { fgSetString("/sim/presets/airport-id", arg ); fgSetBool("/sim/presets/airport-requested", true ); return FG_OPTIONS_OK; } static int fgOptRunway( const char *arg ) { fgSetString("/sim/presets/runway", arg ); fgSetBool("/sim/presets/runway-requested", true ); return FG_OPTIONS_OK; } static int fgOptCallSign(const char * arg) { int i; char callsign[11]; strncpy(callsign,arg,10); callsign[10]=0; for (i=0;callsign[i];i++) { char c = callsign[i]; if (c >= 'A' && c <= 'Z') continue; if (c >= 'a' && c <= 'z') continue; if (c >= '0' && c <= '9') continue; if (c == '-' || c == '_') continue; // convert any other illegal characters callsign[i]='-'; } fgSetString("sim/multiplay/callsign", callsign ); return FG_OPTIONS_OK; } static int fgOptIgnoreAutosave(const char* arg) { fgSetBool("/sim/startup/ignore-autosave", true); // don't overwrite autosave on exit fgSetBool("/sim/startup/save-on-exit", false); return FG_OPTIONS_OK; } static int fgOptEnableFreeze(const char* arg) { fgSetBool("/sim/freeze/master", true); fgSetBool("/sim/freeze/clock", true); return FG_OPTIONS_OK; } static int fgOptDisableFreeze(const char* arg) { fgSetBool("/sim/freeze/master", false); fgSetBool("/sim/freeze/clock", false); return FG_OPTIONS_OK; } // Set a property for the --prop: option. Syntax: --prop:[:]= // can be "double" etc. but also only the first letter "d". // Examples: --prop:alpha=1 --prop:bool:beta=true --prop:d:gamma=0.123 static int fgOptSetProperty(const char* raw) { string arg(raw); string::size_type pos = arg.find('='); if (pos == arg.npos || pos == 0 || pos + 1 == arg.size()) return FG_OPTIONS_ERROR; string name = arg.substr(0, pos); string value = arg.substr(pos + 1); string type; pos = name.find(':'); if (pos != name.npos && pos != 0 && pos + 1 != name.size()) { type = name.substr(0, pos); name = name.substr(pos + 1); } SGPropertyNode *n = fgGetNode(name.c_str(), true); bool writable = n->getAttribute(SGPropertyNode::WRITE); if (!writable) n->setAttribute(SGPropertyNode::WRITE, true); bool ret = false; if (type.empty()) ret = n->setUnspecifiedValue(value.c_str()); else if (type == "s" || type == "string") ret = n->setStringValue(value.c_str()); else if (type == "d" || type == "double") ret = n->setDoubleValue(strtod(value.c_str(), 0)); else if (type == "f" || type == "float") ret = n->setFloatValue(atof(value.c_str())); else if (type == "l" || type == "long") ret = n->setLongValue(strtol(value.c_str(), 0, 0)); else if (type == "i" || type == "int") ret = n->setIntValue(atoi(value.c_str())); else if (type == "b" || type == "bool") ret = n->setBoolValue(value == "true" || atoi(value.c_str()) != 0); if (!writable) n->setAttribute(SGPropertyNode::WRITE, false); return ret ? FG_OPTIONS_OK : FG_OPTIONS_ERROR; } /* If is a URL, return suitable name for downloaded file. */ static std::string urlToLocalPath(const char* url) { bool http = simgear::strutils::starts_with(url, "http://"); bool https = simgear::strutils::starts_with(url, "https://"); if (!http && !https) { return ""; } // e.g. http://fg.com/foo/bar/wibble.fgtape const char* s2 = (http) ? url+7 : url+8; // fg.com/foo/bar/wibble.fgtape const char* s3 = strchr(s2, '/'); // /foo/bar/wibble.fgtape const char* s4 = (s3) ? strrchr(s3, '/') : NULL; // /wibble.fgtape std::string path = "url_"; if (s3) path += std::string(s2, s3-s2); // url_fg.com path += '_'; // url_fg.com_ if (s3 && s4 > s3) { path += simgear::strutils::md5(s3, s4-s3).substr(0, 8); path += '_'; // url_fg.com_12345678_ } if (s4) path += (s4+1); // url_fg.com_12345678_wibble.fgtape if (!simgear::strutils::ends_with(path, ".fgtape")) path += ".fgtape"; std::string dir = fgGetString("/sim/replay/tape-directory"); if (dir != "") { SGPath path2 = dir; path2.append(path); path = path2.str(); } return path; } // When loading a Continuous recording at startup, we need to override the // aircraft and airport. Unfortunately we can't simply set /sim/aircraft // because there may be --aircraft options later on in the command line. Also // fgMainInit() ends up calling Options::initAircraft() after we have processed // all options, and Options::initAircraft() seems to look directly at the // options again, instead of using /sim/aircraft. // // So we store any aircraft/airport override here, so that // Options::initAircraft() can use them if they are set, instead of going back // to any user-specified aircraft. // static std::string g_load_tape_aircraft; static std::string g_load_tape_airport; static int fgOptLoadTape(const char* arg) { // load a flight recorder tape but wait until the fdm is initialized. // struct DelayedTapeLoader : SGPropertyChangeListener { DelayedTapeLoader( const char * tape, simgear::HTTP::FileRequestRef filerequest) : _tape(SGPath::fromUtf8(tape)), _filerequest(filerequest) { fgGetNode("/sim/signals/fdm-initialized", true)->addChangeListener( this ); } virtual ~ DelayedTapeLoader() {} void valueChanged(SGPropertyNode* node) override { if (!fgGetBool("/sim/signals/fdm-initialized")) { return; } fgGetNode("/sim/signals/fdm-initialized", true)->removeChangeListener( this ); // tell the replay subsystem to load the tape FGReplay* replay = globals->get_subsystem(); assert(replay); SGPropertyNode_ptr arg = new SGPropertyNode(); arg->setStringValue("tape", _tape.utf8Str() ); arg->setBoolValue( "same-aircraft", 0 ); if (!replay->loadTape(_tape, false /*preview*/, *arg, _filerequest)) { // Force shutdown if we can't load tape specified on command-line. SG_LOG(SG_GENERAL, SG_POPUP, "Exiting because unable to load fgtape: " << _tape.str()); flightgear::modalMessageBox("Exiting because unable to load fgtape", _tape.str(), ""); fgOSExit(1); } delete this; // commence suicide } private: SGPath _tape; simgear::HTTP::FileRequestRef _filerequest; }; SGPropertyNode_ptr properties(new SGPropertyNode); simgear::HTTP::FileRequestRef filerequest; SGTimeStamp timeout; std::string path = urlToLocalPath(arg); if (path.empty()) { // is a local file. // // Load the recording's header if it is a Continuous recording. // path = FGReplay::makeTapePath(arg); (void) FGReplay::loadContinuousHeader(path.c_str(), nullptr /*in*/, properties); } else { // is a URL. Start download. // // Load the recording's header if it is a Continuous recording. // // This is a little messy - we need to create a FGHTTPClient subsystem // in order to do the download, and we call its update() method // directly in order to download at least the header. // const char* url = arg; FGHTTPClient* http = FGHTTPClient::getOrCreate(); SG_LOG(SG_GENERAL, SG_MANDATORY_INFO, "Replaying url " << url << " using local path: " << path); filerequest.reset(new simgear::HTTP::FileRequest(url, path, true /*append*/)); filerequest->setAcceptEncoding(""); // "" means request any supported compression. long max_download_speed = fgGetLong("/sim/replay/download-max-bytes-per-sec"); if (max_download_speed != 0) { // Can be useful to limite download speed for testing background // download. // SG_LOG(SG_GENERAL, SG_MANDATORY_INFO, "Limiting download speed" << " /sim/replay/download-max-bytes-per-sec=" << max_download_speed); filerequest->setMaxBytesPerSec(max_download_speed); } http->client()->makeRequest(filerequest); SG_LOG(SG_GENERAL, SG_DEBUG, "" << " filerequest->responseCode()=" << filerequest->responseCode() << " filerequest->responseReason()=" << filerequest->responseReason() ); // Load recording header, looping so that we wait for the initial // portion of the recording to be downloaded. We give up after a fixed // timeout. // timeout.stamp(); for(;;) { // Run http client's update() to download any pending data. http->update(0); // Try to load properties from recording header. int e = FGReplay::loadContinuousHeader(path, nullptr /*in*/, properties); if (e == 0) { // Success. We leave active - it will carry // on downloading when the main update loop gets going // later. Hopefully the delay before that happens will not // cause a server timeout. // break; } if (e == -1) { SG_LOG(SG_GENERAL, SG_POPUP, "Not a Continuous recording: url=" << url << " local filename=" << path); // Replay from URL only works with Continuous recordings. return FG_OPTIONS_EXIT; } // If we get here, need to download some more. if (timeout.elapsedMSec() > (30 * 1000)) { SG_LOG(SG_GENERAL, SG_POPUP, "Timeout while reading downloaded recording from " << url << ". local path=" << path); return FG_OPTIONS_EXIT; } SGTimeStamp::sleepForMSec(1000); } } // Set aircraft from recording header if we loaded it above; this has to // happen now, before the FDM is initialised. Also set the airport; we // don't actually have to do this because the replay doesn't need terrain // to work, but we might as well load the correct terrain. // std::string aircraft = properties->getStringValue("meta/aircraft-type"); std::string airport = properties->getStringValue("meta/closest-airport-id"); SG_LOG(SG_GENERAL, SG_MANDATORY_INFO, "From recording header: aircraft=" << aircraft << " airport=" << airport); // Override aircraft and airport settings to match what is in the // recording. // g_load_tape_aircraft = aircraft; g_load_tape_airport = airport; // Arrange to load the recording after FDM has initialised. new DelayedTapeLoader(path.c_str(), filerequest); return FG_OPTIONS_OK; } static int fgOptDisableGUI(const char*) { globals->set_headless(true); return FG_OPTIONS_OK; } /* option has_param type property b_param s_param func where: option : name of the option has_param : option is --name=value if true or --name if false type : OPTION_BOOL - property is a boolean OPTION_STRING - property is a string OPTION_DOUBLE - property is a double OPTION_INT - property is an integer OPTION_CHANNEL - name of option is the name of a channel OPTION_FUNC - the option trigger a function property : b_param : if type==OPTION_BOOL, value set to the property (has_param is false for boolean) s_param : if type==OPTION_STRING, value set to the property if has_param is false func : function called if type==OPTION_FUNC. if has_param is true, the value is passed to the function as a string, otherwise, s_param is passed. For OPTION_DOUBLE and OPTION_INT, the parameter value is converted into a double or an integer and set to the property. For OPTION_CHANNEL, add_channel is called with the parameter value as the argument. */ enum OptionType { OPTION_BOOL = 0, OPTION_STRING, OPTION_DOUBLE, OPTION_INT, OPTION_CHANNEL, OPTION_FUNC, OPTION_IGNORE }; const int OPTION_MULTI = 1 << 17; struct OptionDesc { const char *option; bool has_param; int type; const char *property; bool b_param; const char *s_param; int (*func)( const char * ); } fgOptionArray[] = { {"language", true, OPTION_IGNORE, "", false, "", 0 }, {"console", false, OPTION_FUNC, "", false, "", fgOptConsole }, {"launcher", false, OPTION_IGNORE, "", false, "", 0 }, {"enable-sentry", false, OPTION_BOOL, "/sim/startup/sentry-crash-reporting-enabled", true, "", nullptr }, {"disable-sentry", false, OPTION_BOOL, "/sim/startup/sentry-crash-reporting-enabled", false, "", nullptr }, {"allow-nasal-from-sockets", false, OPTION_IGNORE, "", false, "", 0 }, {"compositor", true, OPTION_STRING, "/sim/rendering/default-compositor", false, "", 0 }, {"disable-splash-screen", false, OPTION_BOOL, "/sim/startup/splash-screen", false, "", 0 }, {"enable-splash-screen", false, OPTION_BOOL, "/sim/startup/splash-screen", true, "", 0 }, {"disable-mouse-pointer", false, OPTION_STRING, "/sim/startup/mouse-pointer", false, "disabled", 0 }, {"enable-mouse-pointer", false, OPTION_STRING, "/sim/startup/mouse-pointer", false, "enabled", 0 }, {"disable-random-objects", false, OPTION_BOOL, "/sim/rendering/random-objects", false, "", 0 }, {"enable-random-objects", false, OPTION_BOOL, "/sim/rendering/random-objects", true, "", 0 }, {"disable-random-vegetation", false, OPTION_BOOL, "/sim/rendering/random-vegetation", false, "", 0 }, {"enable-random-vegetation", false, OPTION_BOOL, "/sim/rendering/random-vegetation", true, "", 0 }, {"disable-random-buildings", false, OPTION_BOOL, "/sim/rendering/random-buildings", false, "", 0 }, {"enable-random-buildings", false, OPTION_BOOL, "/sim/rendering/random-buildings", true, "", 0 }, {"disable-real-weather-fetch", false, OPTION_BOOL, "/environment/realwx/enabled", false, "", 0 }, {"enable-real-weather-fetch", false, OPTION_BOOL, "/environment/realwx/enabled", true, "", 0 }, {"metar", true, OPTION_FUNC, "", false, "", fgOptMetar }, {"disable-ai-models", false, OPTION_BOOL, "/sim/ai/enabled", false, "", 0 }, {"enable-ai-models", false, OPTION_BOOL, "/sim/ai/enabled", true, "", 0 }, {"disable-ai-traffic", false, OPTION_BOOL, "/sim/traffic-manager/enabled", false, "", 0 }, {"enable-ai-traffic", false, OPTION_BOOL, "/sim/traffic-manager/enabled", true, "", 0 }, {"disable-freeze", false, OPTION_FUNC, "", false, "", fgOptDisableFreeze }, {"enable-freeze", false, OPTION_FUNC, "", true, "", fgOptEnableFreeze }, {"disable-fuel-freeze", false, OPTION_BOOL, "/sim/freeze/fuel", false, "", 0 }, {"enable-fuel-freeze", false, OPTION_BOOL, "/sim/freeze/fuel", true, "", 0 }, {"disable-clock-freeze", false, OPTION_BOOL, "/sim/freeze/clock", false, "", 0 }, {"enable-clock-freeze", false, OPTION_BOOL, "/sim/freeze/clock", true, "", 0 }, {"disable-hud-3d", false, OPTION_BOOL, "/sim/hud/enable3d[1]", false, "", 0 }, {"enable-hud-3d", false, OPTION_BOOL, "/sim/hud/enable3d[1]", true, "", 0 }, {"disable-anti-alias-hud", false, OPTION_BOOL, "/sim/hud/color/antialiased", false, "", 0 }, {"enable-anti-alias-hud", false, OPTION_BOOL, "/sim/hud/color/antialiased", true, "", 0 }, {"disable-auto-coordination", false, OPTION_BOOL, "/controls/flight/auto-coordination", false, "", 0 }, {"enable-auto-coordination", false, OPTION_BOOL, "/controls/flight/auto-coordination", true, "", 0 }, {"browser-app", true, OPTION_STRING, "/sim/startup/browser-app", false, "", 0 }, {"disable-hud", false, OPTION_BOOL, "/sim/hud/visibility[1]", false, "", 0 }, {"enable-hud", false, OPTION_BOOL, "/sim/hud/visibility[1]", true, "", 0 }, {"disable-panel", false, OPTION_BOOL, "/sim/panel/visibility", false, "", 0 }, {"enable-panel", false, OPTION_BOOL, "/sim/panel/visibility", true, "", 0 }, {"disable-sound", false, OPTION_BOOL, "/sim/sound/working", false, "", 0 }, {"enable-sound", false, OPTION_BOOL, "/sim/sound/working", true, "", 0 }, {"sound-device", true, OPTION_STRING, "/sim/sound/device-name", false, "", 0 }, {"airport", true, OPTION_FUNC, "", false, "", fgOptAirport }, {"runway", true, OPTION_FUNC, "", false, "", fgOptRunway }, {"vor", true, OPTION_FUNC, "", false, "", fgOptVOR }, {"vor-frequency", true, OPTION_DOUBLE, "/sim/presets/vor-freq", false, "", fgOptVOR }, {"ndb", true, OPTION_FUNC, "", false, "", fgOptNDB }, {"ndb-frequency", true, OPTION_DOUBLE, "/sim/presets/ndb-freq", false, "", fgOptVOR }, {"carrier", true, OPTION_FUNC, "", false, "", fgOptCarrier }, {"carrier-position", true, OPTION_FUNC, "", false, "", fgOptCarrierPos }, {"fix", true, OPTION_FUNC, "", false, "", fgOptFIX }, {"offset-distance", true, OPTION_DOUBLE, "/sim/presets/offset-distance-nm", false, "", 0 }, {"offset-azimuth", true, OPTION_DOUBLE, "/sim/presets/offset-azimuth-deg", false, "", 0 }, {"lon", true, OPTION_FUNC, "", false, "", fgOptLon }, {"lat", true, OPTION_FUNC, "", false, "", fgOptLat }, {"altitude", true, OPTION_FUNC, "", false, "", fgOptAltitude }, {"uBody", true, OPTION_FUNC, "", false, "", fgOptUBody }, {"vBody", true, OPTION_FUNC, "", false, "", fgOptVBody }, {"wBody", true, OPTION_FUNC, "", false, "", fgOptWBody }, {"vNorth", true, OPTION_FUNC, "", false, "", fgOptVNorth }, {"vEast", true, OPTION_FUNC, "", false, "", fgOptVEast }, {"vDown", true, OPTION_FUNC, "", false, "", fgOptVDown }, {"vc", true, OPTION_FUNC, "", false, "", fgOptVc }, {"mach", true, OPTION_FUNC, "", false, "", fgOptMach }, {"heading", true, OPTION_DOUBLE, "/sim/presets/heading-deg", false, "", 0 }, {"roll", true, OPTION_DOUBLE, "/sim/presets/roll-deg", false, "", 0 }, {"pitch", true, OPTION_DOUBLE, "/sim/presets/pitch-deg", false, "", 0 }, {"glideslope", true, OPTION_DOUBLE, "/sim/presets/glideslope-deg", false, "", 0 }, {"roc", true, OPTION_FUNC, "", false, "", fgOptRoc }, {"fg-root", true, OPTION_IGNORE, "", false, "", 0 }, {"fg-scenery", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptFgScenery }, {"terrain-engine", true, OPTION_STRING, "/sim/scenery/engine", false, "tilecache", 0 }, {"lod-levels", true, OPTION_STRING, "/sim/scenery/lod-levels", false, "1 3 5 7", 0 }, {"lod-res", true, OPTION_STRING, "/sim/scenery/lod-res", false, "1", 0 }, {"lod-texturing", true, OPTION_STRING, "/sim/scenery/lod-texturing", false, "bluemarble", 0 }, {"lod-range-mult", true, OPTION_STRING, "/sim/scenery/lod-range-mult", false, "2", 0 }, {"fg-aircraft", true, OPTION_IGNORE | OPTION_MULTI, "", false, "", 0 }, {"fdm", true, OPTION_STRING, "/sim/flight-model", false, "", 0 }, {"aero", true, OPTION_STRING, "/sim/aero", false, "", 0 }, {"aircraft-dir", true, OPTION_IGNORE, "", false, "", 0 }, {"state", true, OPTION_IGNORE, "", false, "", 0 }, {"model-hz", true, OPTION_INT, "/sim/model-hz", false, "", 0 }, {"max-fps", true, OPTION_DOUBLE, "/sim/frame-rate-throttle-hz", false, "", 0 }, {"speed", true, OPTION_DOUBLE, "/sim/speed-up", false, "", 0 }, {"trim", false, OPTION_BOOL, "/sim/presets/trim", true, "", 0 }, {"notrim", false, OPTION_BOOL, "/sim/presets/trim", false, "", 0 }, {"on-ground", false, OPTION_BOOL, "/sim/presets/onground", true, "", 0 }, {"in-air", false, OPTION_BOOL, "/sim/presets/onground", false, "", 0 }, {"disable-hold-short", false, OPTION_BOOL, "/sim/presets/mp-hold-short-override", true, "", 0 }, {"fog-disable", false, OPTION_STRING, "/sim/rendering/fog", false, "disabled", 0 }, {"fog-fastest", false, OPTION_STRING, "/sim/rendering/fog", false, "fastest", 0 }, {"fog-nicest", false, OPTION_STRING, "/sim/rendering/fog", false, "nicest", 0 }, {"disable-horizon-effect", false, OPTION_BOOL, "/sim/rendering/horizon-effect", false, "", 0 }, {"enable-horizon-effect", false, OPTION_BOOL, "/sim/rendering/horizon-effect", true, "", 0 }, {"disable-distance-attenuation", false, OPTION_BOOL, "/sim/rendering/distance-attenuation", false, "", 0 }, {"enable-distance-attenuation", false, OPTION_BOOL, "/sim/rendering/distance-attenuation", true, "", 0 }, {"disable-specular-highlight", false, OPTION_BOOL, "/sim/rendering/specular-highlight", false, "", 0 }, {"enable-specular-highlight", false, OPTION_BOOL, "/sim/rendering/specular-highlight", true, "", 0 }, {"disable-clouds", false, OPTION_BOOL, "/environment/clouds/status", false, "", 0 }, {"enable-clouds", false, OPTION_BOOL, "/environment/clouds/status", true, "", 0 }, {"disable-clouds3d", false, OPTION_BOOL, "/sim/rendering/clouds3d-enable", false, "", 0 }, {"enable-clouds3d", false, OPTION_BOOL, "/sim/rendering/clouds3d-enable", true, "", 0 }, {"fov", true, OPTION_FUNC, "", false, "", fgOptFov }, {"aspect-ratio-multiplier", true, OPTION_DOUBLE, "/sim/current-view/aspect-ratio-multiplier", false, "", 0 }, {"disable-fullscreen", false, OPTION_BOOL, "/sim/startup/fullscreen", false, "", 0 }, {"enable-fullscreen", false, OPTION_BOOL, "/sim/startup/fullscreen", true, "", 0 }, {"disable-save-on-exit", false, OPTION_BOOL, "/sim/startup/save-on-exit", false, "", 0 }, {"enable-save-on-exit", false, OPTION_BOOL, "/sim/startup/save-on-exit", true, "", 0 }, {"read-only", false, OPTION_BOOL, "/sim/fghome-readonly", true, "", 0 }, {"ignore-autosave", false, OPTION_FUNC, "", false, "", fgOptIgnoreAutosave }, {"restore-defaults", false, OPTION_BOOL, "/sim/startup/restore-defaults", true, "", 0 }, {"shading-flat", false, OPTION_BOOL, "/sim/rendering/shading", false, "", 0 }, {"shading-smooth", false, OPTION_BOOL, "/sim/rendering/shading", true, "", 0 }, {"texture-filtering", false, OPTION_INT, "/sim/rendering/filtering", 1, "", 0 }, {"disable-wireframe", false, OPTION_BOOL, "/sim/rendering/wireframe", false, "", 0 }, {"enable-wireframe", false, OPTION_BOOL, "/sim/rendering/wireframe", true, "", 0 }, {"materials-file", true, OPTION_STRING, "/sim/rendering/materials-file", false, "", 0 }, {"disable-terrasync", false, OPTION_BOOL, "/sim/terrasync/enabled", false, "", 0 }, {"enable-terrasync", false, OPTION_BOOL, "/sim/terrasync/enabled", true, "", 0 }, {"terrasync-dir", true, OPTION_IGNORE, "", false, "", 0 }, {"download-dir", true, OPTION_IGNORE, "", false, "", 0 }, {"texture-cache-dir", true, OPTION_IGNORE, "", false, "", 0 }, {"enable-texture-cache", false, OPTION_BOOL, "/sim/rendering/texture-cache/cache-enabled", true, "", 0 }, {"disable-texture-cache", false, OPTION_BOOL, "/sim/rendering/texture-cache/cache-enabled", false, "", 0 }, {"allow-nasal-read", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptAllowNasalRead }, {"geometry", true, OPTION_FUNC, "", false, "", fgOptGeometry }, {"bpp", true, OPTION_FUNC, "", false, "", fgOptBpp }, {"units-feet", false, OPTION_STRING, "/sim/startup/units", false, "feet", 0 }, {"units-meters", false, OPTION_STRING, "/sim/startup/units", false, "meters", 0 }, {"timeofday", true, OPTION_STRING, "/sim/startup/time-offset-type", false, "noon", 0 }, {"time-offset", true, OPTION_FUNC, "", false, "", fgOptTimeOffset }, {"time-match-real", false, OPTION_STRING, "/sim/startup/time-offset-type", false, "system-offset", 0 }, {"time-match-local", false, OPTION_STRING, "/sim/startup/time-offset-type", false, "latitude-offset", 0 }, {"start-date-sys", true, OPTION_FUNC, "", false, "", fgOptStartDateSys }, {"start-date-lat", true, OPTION_FUNC, "", false, "", fgOptStartDateLat }, {"start-date-gmt", true, OPTION_FUNC, "", false, "", fgOptStartDateGmt }, {"hud-tris", false, OPTION_STRING, "/sim/hud/frame-stat-type", false, "tris", 0 }, {"hud-culled", false, OPTION_STRING, "/sim/hud/frame-stat-type", false, "culled", 0 }, {"atcsim", true, OPTION_CHANNEL, "", false, "dummy", 0 }, {"atlas", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"httpd", true, OPTION_FUNC , "", false, "", fgOptHttpd }, {"jpg-httpd", true, OPTION_FUNC, "", false, "", fgOptJpgHttpd }, {"native", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"native-ctrls", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"native-fdm", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"native-gui", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"dds-props", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"opengc", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"AV400", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"AV400Sim", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"AV400WSimA", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"AV400WSimB", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"flarm", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"garmin", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"igc", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"nmea", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"generic", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"props", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"telnet", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, {"pve", true, OPTION_CHANNEL, "", false, "", 0 }, {"ray", true, OPTION_CHANNEL, "", false, "", 0 }, {"rul", true, OPTION_CHANNEL, "", false, "", 0 }, {"joyclient", true, OPTION_CHANNEL, "", false, "", 0 }, {"jsclient", true, OPTION_CHANNEL, "", false, "", 0 }, {"proxy", true, OPTION_FUNC, "", false, "", fgSetupProxy }, {"callsign", true, OPTION_FUNC, "", false, "", fgOptCallSign}, {"multiplay", true, OPTION_CHANNEL | OPTION_MULTI, "", false, "", 0 }, #if FG_HAVE_HLA {"hla", true, OPTION_CHANNEL, "", false, "", 0 }, {"hla-local", true, OPTION_CHANNEL, "", false, "", 0 }, #endif {"trace-read", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptTraceRead }, {"trace-write", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptTraceWrite }, {"log-level", true, OPTION_FUNC, "", false, "", fgOptLogLevel }, {"log-class", true, OPTION_FUNC, "", false, "", fgOptLogClasses }, {"log-dir", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptLogDir }, {"view-offset", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptViewOffset }, {"visibility", true, OPTION_FUNC, "", false, "", fgOptVisibilityMeters }, {"visibility-miles", true, OPTION_FUNC, "", false, "", fgOptVisibilityMiles }, {"random-wind", false, OPTION_FUNC, "", false, "", fgOptRandomWind }, {"wind", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptWind }, {"turbulence", true, OPTION_FUNC, "", false, "", fgOptTurbulence }, {"ceiling", true, OPTION_FUNC, "", false, "", fgOptCeiling }, {"wp", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptWp }, {"flight-plan", true, OPTION_STRING, "/autopilot/route-manager/file-path", false, "", NULL }, {"config", true, OPTION_IGNORE | OPTION_MULTI, "", false, "", 0 }, {"addon", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptAddon }, {"data", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptAdditionalDataDir }, {"aircraft", true, OPTION_STRING, "/sim/aircraft", false, "", 0 }, {"vehicle", true, OPTION_STRING, "/sim/aircraft", false, "", 0 }, {"failure", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptFailure }, #ifdef ENABLE_IAX {"enable-fgcom", false, OPTION_BOOL, "/sim/fgcom/enabled", true, "", 0 }, {"disable-fgcom", false, OPTION_BOOL, "/sim/fgcom/enabled", false, "", 0 }, #endif {"com1", true, OPTION_DOUBLE, "/instrumentation/comm[0]/frequencies/selected-mhz", false, "", 0 }, {"com2", true, OPTION_DOUBLE, "/instrumentation/comm[1]/frequencies/selected-mhz", false, "", 0 }, {"nav1", true, OPTION_FUNC, "", false, "", fgOptNAV1 }, {"nav2", true, OPTION_FUNC, "", false, "", fgOptNAV2 }, {"adf", /*legacy*/ true, OPTION_FUNC, "", false, "", fgOptADF }, {"adf1", true, OPTION_FUNC, "", false, "", fgOptADF1 }, {"adf2", true, OPTION_FUNC, "", false, "", fgOptADF2 }, {"dme", true, OPTION_FUNC, "", false, "", fgOptDME }, {"min-status", true, OPTION_STRING, "/sim/aircraft-min-status", false, "all", 0 }, {"livery", true, OPTION_FUNC, "", false, "", fgOptLivery }, {"ai-scenario", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptScenario }, {"parking-id", true, OPTION_FUNC, "", false, "", fgOptParkpos }, {"parkpos", true, OPTION_FUNC, "", false, "", fgOptParkpos }, {"version", false, OPTION_IGNORE, "", false, "", 0 }, {"json-report", false, OPTION_IGNORE, "", false, "", 0 }, {"enable-fpe", false, OPTION_IGNORE, "", false, "", 0}, {"fgviewer", false, OPTION_IGNORE, "", false, "", 0}, {"no-default-config", false, OPTION_IGNORE, "", false, "", 0}, {"prop", true, OPTION_FUNC | OPTION_MULTI, "", false, "", fgOptSetProperty}, {"load-tape", true, OPTION_FUNC, "", false, "", fgOptLoadTape }, {"developer", true, OPTION_IGNORE | OPTION_BOOL, "", false, "", nullptr }, {"jsbsim-output-directive-file", true, OPTION_STRING, "/sim/jsbsim/output-directive-file", false, "", nullptr }, {"disable-gui", false, OPTION_FUNC, "", false, "", fgOptDisableGUI }, {"graphics-preset", true, OPTION_STRING, "/sim/rendering/preset", false, "", nullptr}, {"composite-viewer", true, OPTION_INT, "/sim/rendering/composite-viewer-enabled", false, "", nullptr}, {nullptr, false, 0, nullptr, false, nullptr, nullptr} }; namespace flightgear { /** * internal storage of a value->option binding */ class OptionValue { public: OptionValue(OptionDesc* d, const string& v) : desc(d), value(v) {;} OptionDesc* desc; string value; }; typedef std::vector OptionValueVec; typedef std::map OptionDescDict; class Options::OptionsPrivate { public: OptionValueVec::const_iterator findValue(const string& key) const { OptionValueVec::const_iterator it = values.begin(); for (; it != values.end(); ++it) { if (!it->desc) { continue; // ignore markers } if (it->desc->option == key) { return it; } } // of set values iteration return it; // not found } OptionValueVec::iterator findValue(const string& key) { OptionValueVec::iterator it = values.begin(); for (; it != values.end(); ++it) { if (!it->desc) { continue; // ignore markers } if (it->desc->option == key) { return it; } } // of set values iteration return it; // not found } OptionDesc* findOption(const string& key) const { OptionDescDict::const_iterator it = options.find(key); if (it == options.end()) { return NULL; } return it->second; } int processOption(OptionDesc* desc, const string& arg_value) { if (!desc) { return FG_OPTIONS_OK; // tolerate marker options } switch ( desc->type & 0xffff ) { case OPTION_BOOL: fgSetBool( desc->property, desc->b_param ); break; case OPTION_STRING: if ( desc->has_param && !arg_value.empty() ) { fgSetString( desc->property, arg_value.c_str() ); } else if ( !desc->has_param && arg_value.empty() ) { fgSetString( desc->property, desc->s_param ); } else if ( desc->has_param ) { SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" ); return FG_OPTIONS_ERROR; } else { SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' does not have a parameter" ); return FG_OPTIONS_ERROR; } break; case OPTION_DOUBLE: if ( !arg_value.empty() ) { fgSetDouble( desc->property, atof( arg_value ) ); } else { SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" ); return FG_OPTIONS_ERROR; } break; case OPTION_INT: if ( !arg_value.empty() ) { fgSetInt( desc->property, atoi( arg_value ) ); } else { SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" ); return FG_OPTIONS_ERROR; } break; case OPTION_CHANNEL: // XXX return value of add_channel should be checked? if ( desc->has_param && !arg_value.empty() ) { add_channel( desc->option, arg_value ); } else if ( !desc->has_param && arg_value.empty() ) { add_channel( desc->option, desc->s_param ); } else if ( desc->has_param ) { SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" ); return FG_OPTIONS_ERROR; } else { SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' does not have a parameter" ); return FG_OPTIONS_ERROR; } break; case OPTION_FUNC: if ( desc->has_param && !arg_value.empty() ) { return desc->func( arg_value.c_str() ); } else if ( !desc->has_param && arg_value.empty() ) { return desc->func( desc->s_param ); } else if ( desc->has_param ) { SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' needs a parameter" ); return FG_OPTIONS_ERROR; } SG_LOG( SG_GENERAL, SG_ALERT, "Option '" << desc->option << "' does not have a parameter" ); return FG_OPTIONS_ERROR; case OPTION_IGNORE: break; } return FG_OPTIONS_OK; } /** * insert a marker value into the values vector. This is necessary * when processing options, to ensure the correct ordering, where we scan * for marker values in reverse, and then forwards within each group. */ void insertGroupMarker() { values.push_back(OptionValue(NULL, "-")); } /** * given a current iterator into the values, find the preceding group marker, * or return the beginning of the value vector. */ OptionValueVec::const_iterator rfindGroup(OptionValueVec::const_iterator pos) const { while (--pos != values.begin()) { if (pos->desc == NULL) { return pos; // found a marker, we're done } } return pos; } // Return a pointer to a new JSON array node // (["/foo/bar", "/other/path", ...]) created from the given PathList. cJSON *createJSONArrayFromPathList(const PathList& pl) const { cJSON *resultNode = cJSON_CreateArray(); cJSON *prevNode = nullptr; bool isFirst = true; for (const SGPath& path : pl) { cJSON *pathNode = cJSON_CreateString(path.utf8Str().c_str()); if (isFirst) { isFirst = false; resultNode->child = pathNode; } else { prevNode->next = pathNode; pathNode->prev = prevNode; } prevNode = pathNode; } return resultNode; } bool showHelp, verbose, showAircraft, shouldLoadDefaultConfig; OptionDescDict options; OptionValueVec values; simgear::PathList configFiles; simgear::PathList propertyFiles; }; Options* Options::sharedInstance() { if (shared_instance == NULL) { shared_instance = new Options; } return shared_instance; } void Options::reset() { if (shared_instance != nullptr) { delete shared_instance; shared_instance = nullptr; } } Options::Options() : p(new OptionsPrivate()) { p->showHelp = false; p->verbose = false; p->showAircraft = false; p->shouldLoadDefaultConfig = true; // build option map OptionDesc *desc = &fgOptionArray[ 0 ]; while ( desc->option != 0 ) { // REVIEW: Memory Leak - 15,768 bytes in 219 blocks are still reachable p->options[ desc->option ] = desc; ++desc; } } Options::~Options() { } OptionResult Options::init(int argc, char** argv, const SGPath& appDataPath) { // first, process the command line bool inOptions = true; for (int i=1; ipropertyFiles.push_back(f); } } } // of arguments iteration p->insertGroupMarker(); // command line is one group // establish log-level before anything else - otherwise it is not possible // to show extra (debug/info/warning) messages for the start-up phase. // Leave the simgear logstream default value of SG_ALERT if the argument is // not supplied. if (isOptionSet("log-level")) fgOptLogLevel(valueForOption("log-level").c_str()); simgear::PathList::const_iterator i; for (i = p->configFiles.begin(); i != p->configFiles.end(); ++i) { readConfig(*i); } if (!p->shouldLoadDefaultConfig) { return setupRoot(argc, argv); } // then config files SGPath config; if( !hostname.empty() ) { // Check for ~/.fgfsrc.hostname config = SGPath::home(); config.append(".fgfsrc"); config.concat( "." ); config.concat( hostname ); readConfig(config); } // Check for ~/.fgfsrc config = SGPath::home(); config.append(".fgfsrc"); readConfig(config); // check for a config file in app data SGPath appDataConfig(appDataPath); appDataConfig.append("fgfsrc"); if (appDataConfig.exists()) { readConfig(appDataConfig); } // setup FG_ROOT auto res = setupRoot(argc, argv); if (res != FG_OPTIONS_OK) { return res; } // system.fgfsrc is disabled, as we no longer allow anything in fgdata to set // fg-root/fg-home/fg-aircraft and hence control what files Nasal can access std::string nameForError = config.utf8Str(); if( ! hostname.empty() ) { config = globals->get_fg_root(); config.append( "system.fgfsrc" ); config.concat( "." ); config.concat( hostname ); if (config.exists()) { flightgear::fatalMessageBoxThenExit( "Unsupported configuration", "You have a '" + config.utf8Str() + "' file, which is no longer " "processed for security reasons.", "If you created this file intentionally, please move it to '" + nameForError + "'."); } } config = globals->get_fg_root(); config.append( "system.fgfsrc" ); if (config.exists()) { flightgear::fatalMessageBoxThenExit( "Unsupported configuration", "You have a '" + config.utf8Str() + "' file, which is no longer " "processed for security reasons.", "If you created this file intentionally, please move it to '" + nameForError + "'."); } return FG_OPTIONS_OK; } void Options::initPaths() { for (const string& pathOpt : valuesForOption("fg-aircraft")) { PathList paths = SGPath::pathsFromUtf8(pathOpt); globals->append_aircraft_paths(paths); } const char* envp = ::getenv("FG_AIRCRAFT"); if (envp) { globals->append_aircraft_paths(SGPath::pathsFromEnv("FG_AIRCRAFT")); } } OptionResult Options::initAircraft() { string aircraft; if (g_load_tape_aircraft != "") { // Use Continuous recording's aircraft if we are replaying on startup. aircraft = g_load_tape_aircraft; } else if (isOptionSet("aircraft")) { aircraft = valueForOption("aircraft"); } else if (isOptionSet("vehicle")) { aircraft = valueForOption("vehicle"); } if (!aircraft.empty()) { fgSetString("/sim/aircraft-id", aircraft); const auto lastDotPos = aircraft.rfind('.'); if (lastDotPos != string::npos) { // ensure /sim/aircraft is only the local ID, not the fully-qualified ID // otherwise some existing logic gets confused. fgSetString("/sim/aircraft", aircraft.substr(lastDotPos + 1)); } else { fgSetString("/sim/aircraft", aircraft); } SG_LOG(SG_INPUT, SG_INFO, "aircraft = " << aircraft ); } else { SG_LOG(SG_INPUT, SG_INFO, "No user specified aircraft, using default" ); // ensure aircraft-id is valid fgSetString("/sim/aircraft-id", fgGetString("/sim/aircraft")); } if (p->showAircraft) { PathList path_list; fgOptLogLevel( "alert" ); // First place to check is the 'Aircraft' sub-directory in $FG_ROOT SGPath rootAircraft = globals->get_fg_root(); rootAircraft.append("Aircraft"); path_list.push_back(rootAircraft); // Additionally, aircraft may also be found in user-defined places // (via $FG_AIRCRAFT or with the '--fg-aircraft' option) PathList aircraft_paths = globals->get_aircraft_paths(); path_list.insert(path_list.end(), aircraft_paths.begin(), aircraft_paths.end()); fgShowAircraft(path_list); // this is to indicate that we did show it return FG_OPTIONS_SHOW_AIRCRAFT; } if (isOptionSet("aircraft-dir")) { SGPath aircraftDirPath = SGPath::fromUtf8(valueForOption("aircraft-dir")); SGPath realAircraftPath = aircraftDirPath.realpath(); globals->append_read_allowed_paths(realAircraftPath); // Set this now, so it's available in FindAndCacheAircraft. Use realpath() // as in FGGlobals::append_aircraft_path(), otherwise fgValidatePath() // will deny access to resources under this path if one of its components // is a symlink (which is not a problem, since it was given as is by the // user---this is very different from a symlink *under* the aircraft dir // or a scenery dir). fgSetString("/sim/aircraft-dir", realAircraftPath.utf8Str()); } if (isOptionSet("state")) { std::string stateName = valueForOption("state"); // can't validate this until the -set.xml is parsed fgSetString("/sim/aircraft-state", stateName); } return FG_OPTIONS_OK; } void Options::processArgResult(int result) { if ((result == FG_OPTIONS_HELP) || (result == FG_OPTIONS_ERROR)) p->showHelp = true; else if (result == FG_OPTIONS_VERBOSE_HELP) p->verbose = true; else if (result == FG_OPTIONS_SHOW_AIRCRAFT) { p->showAircraft = true; } else if (result == FG_OPTIONS_NO_DEFAULT_CONFIG) { p->shouldLoadDefaultConfig = false; } else if (result == FG_OPTIONS_SHOW_SOUND_DEVICES) { SGSoundMgr smgr; smgr.init(); string vendor = smgr.get_vendor(); string renderer = smgr.get_renderer(); cout << renderer << " provided by " << vendor << endl; cout << endl << "No. Device" << endl; vector devices = smgr.get_available_devices(); for (vector ::size_type i=0; i> skipcomment; while ( ! in.eof() ) { string line; getline( in, line, '\n' ); // catch extraneous (DOS) line ending character int i; for (i = line.length(); i > 0; i--) if (line[i - 1] > 32) break; line = line.substr( 0, i ); if ( parseOption(line, /* fromConfigFile */ true) == FG_OPTIONS_ERROR ) { cerr << endl << "Config file parse error: " << path << " '" << line << "'" << endl; p->showHelp = true; } in >> skipcomment; } p->insertGroupMarker(); // each config file is a group } int Options::parseOption(const string& s, bool fromConfigFile) { if ((s == "--help") || (s=="-h")) { return FG_OPTIONS_HELP; } else if ( (s == "--verbose") || (s == "-v") ) { // verbose help/usage request return FG_OPTIONS_VERBOSE_HELP; } else if ((s == "--console") || (s == "-c")) { fgOptConsole(nullptr); return FG_OPTIONS_OK; } else if (s.find("-psn") == 0) { // on Mac, when launched from the GUI, we are passed the ProcessSerialNumber // as an argument (and no others). Silently ignore the argument here. return FG_OPTIONS_OK; } else if ( s.find( "--show-aircraft") == 0) { return(FG_OPTIONS_SHOW_AIRCRAFT); } else if ( s.find( "--show-sound-devices") == 0) { return(FG_OPTIONS_SHOW_SOUND_DEVICES); } else if ( s.find( "--no-default-config") == 0) { return FG_OPTIONS_NO_DEFAULT_CONFIG; } else if ( s.find( "--prop:") == 0) { // property setting has a slightly different syntax, so fudge things OptionDesc* desc = p->findOption("prop"); if (s.find("=", 7) == string::npos) { // no equals token SG_LOG(SG_GENERAL, SG_ALERT, "malformed property option:" << s); return FG_OPTIONS_ERROR; } p->values.push_back(OptionValue(desc, s.substr(7))); return FG_OPTIONS_OK; } else if ( s.find("--config=") == 0) { SGPath path = s.substr(9); if (path.extension() == "xml") { p->propertyFiles.push_back(path); } else if (fromConfigFile) { flightgear::fatalMessageBoxThenExit( "FlightGear", "Invalid use of the --config option.", "Sorry, it is currently not supported to load a configuration file " "using --config from another configuration file.\n\n" "Note: this does not apply to loading of XML PropertyList files " "with --config."); } else { // the --config option comes from the command line p->configFiles.push_back(path); } return FG_OPTIONS_OK; } else if ( s.find( "--" ) == 0 ) { size_t eqPos = s.find( '=' ); string key, value; if (eqPos == string::npos) { key = s.substr(2); } else { key = s.substr( 2, eqPos - 2 ); value = s.substr( eqPos + 1); } return addOption(key, value); } else { flightgear::modalMessageBox("Unknown option", "Unknown command-line option: " + s); return FG_OPTIONS_ERROR; } } int Options::addOption(const string &key, const string &value) { if (key == "config") { // occurs when the launcher adds --config options SGPath path(value); if (!path.exists()) { return FG_OPTIONS_ERROR; } if (path.extension() == "xml") { p->propertyFiles.push_back(path); } else { p->insertGroupMarker(); // begin a group for the config file readConfig(path); } return FG_OPTIONS_OK; } OptionDesc* desc = p->findOption(key); if (!desc) { flightgear::modalMessageBox("Unknown option", "Unknown command-line option: " + key); return FG_OPTIONS_ERROR; } if (!(desc->type & OPTION_MULTI)) { OptionValueVec::const_iterator it = p->findValue(key); if (it != p->values.end()) { SG_LOG(SG_GENERAL, SG_WARN, "multiple values forbidden for option:" << key << ", ignoring:" << value); return FG_OPTIONS_OK; } } p->values.push_back(OptionValue(desc, value)); return FG_OPTIONS_OK; } int Options::setOption(const string &key, const string &value) { OptionDesc* desc = p->findOption(key); if (!desc) { flightgear::modalMessageBox("Unknown option", "Unknown command-line option: " + key); return FG_OPTIONS_ERROR; } if (!(desc->type & OPTION_MULTI)) { OptionValueVec::iterator it = p->findValue(key); if (it != p->values.end()) { // remove existing valye p->values.erase(it); } } p->values.push_back(OptionValue(desc, value)); return FG_OPTIONS_OK; } void Options::clearOption(const std::string& key) { OptionValueVec::iterator it = p->findValue(key); for (; it != p->values.end(); it = p->findValue(key)) { p->values.erase(it); } } bool Options::isOptionSet(const string &key) const { OptionValueVec::const_iterator it = p->findValue(key); return (it != p->values.end()); } string Options::valueForOption(const string& key, const string& defValue) const { OptionValueVec::const_iterator it = p->findValue(key); if (it == p->values.end()) { return defValue; } return it->value; } string_list Options::valuesForOption(const std::string& key) const { string_list result; OptionValueVec::const_iterator it = p->values.begin(); for (; it != p->values.end(); ++it) { if (!it->desc) { continue; // ignore marker values } if (it->desc->option == key) { result.push_back(it->value); } } return result; } SGPath defaultDownloadDir() { #if defined(SG_WINDOWS) const SGPath p = SGPath::home() / "FlightGear" / "Downloads"; return p; #endif return globals->get_fg_home(); } SGPath defaultTextureCacheDir() { return defaultDownloadDir() / "TextureCache"; } OptionResult Options::processOptions() { // establish locale before showing help (this selects the default locale, // when no explicit option was set) globals->get_locale()->selectLanguage(valueForOption("language").c_str()); // now FG_ROOT is setup, process various command line options that bail us // out quickly, but rely on aircraft / root settings if (p->showHelp) { showUsage(); return FG_OPTIONS_EXIT; } // processing order is complicated. We must process groups LIFO, but the // values *within* each group in FIFO order, to retain consistency with // older versions of FG, and existing user configs. // in practice this means system.fgfsrc must be *processed* before // .fgfsrc, which must be processed before the command line args, and so on. OptionValueVec::const_iterator groupEnd = p->values.end(); while (groupEnd != p->values.begin()) { OptionValueVec::const_iterator groupBegin = p->rfindGroup(groupEnd); // run over the group in FIFO order OptionValueVec::const_iterator it; for (it = groupBegin; it != groupEnd; ++it) { int result = p->processOption(it->desc, it->value); switch(result) { case FG_OPTIONS_ERROR: showUsage(); return FG_OPTIONS_ERROR; case FG_OPTIONS_EXIT: return FG_OPTIONS_EXIT; default: break; } if (it->desc) { SG_LOG(SG_GENERAL, SG_INFO, "\toption:" << it->desc->option << " = " << it->value); } } groupEnd = groupBegin; } for (const SGPath& file : p->propertyFiles) { SG_LOG(SG_GENERAL, SG_INFO, "Reading command-line property file " << file); readProperties(file, globals->get_props()); } // now options are process, do supplemental fixup const char *envp = ::getenv( "FG_SCENERY" ); if (envp) { globals->append_fg_scenery(SGPath::pathsFromEnv("FG_SCENERY")); } // Download dir fix-up SGPath downloadDir = SGPath::fromUtf8(valueForOption("download-dir")); if (downloadDir.isNull()) { downloadDir = defaultDownloadDir(); SG_LOG(SG_GENERAL, SG_INFO, "Using default download dir: " << downloadDir); } else { SG_LOG(SG_GENERAL, SG_INFO, "Using explicit download dir: " << downloadDir); } simgear::Dir d(downloadDir); if (!d.exists()) { SG_LOG(SG_GENERAL, SG_INFO, "Creating download dir: " << downloadDir); d.create(0755); } // This is safe because the value of 'downloadDir' is trustworthy. In // particular, it can't be influenced by Nasal code, not even indirectly // via a Nasal-writable place such as the property tree. globals->set_download_dir(downloadDir); // Texture Cache directory handling SGPath textureCacheDir = SGPath::fromUtf8(valueForOption("texture-cache-dir")); if (textureCacheDir.isNull()) { textureCacheDir = defaultTextureCacheDir(); SG_LOG(SG_GENERAL, SG_INFO, "Using default texture cache directory: " << textureCacheDir); } else { SG_LOG(SG_GENERAL, SG_INFO, "Using explicit texture cache directory: " << textureCacheDir); } simgear::Dir tcd(textureCacheDir); if (!tcd.exists()) { SG_LOG(SG_GENERAL, SG_INFO, "Creating texture cache directory: " << textureCacheDir); tcd.create(0755); } globals->set_texture_cache_dir(textureCacheDir); // TerraSync directory fixup SGPath terrasyncDir = SGPath::fromUtf8(valueForOption("terrasync-dir")); if (terrasyncDir.isNull()) { terrasyncDir = downloadDir / "TerraSync"; // No “default” qualifier here, because 'downloadDir' may be non-default SG_LOG(SG_GENERAL, SG_INFO, "Using TerraSync dir: " << terrasyncDir); } else { SG_LOG(SG_GENERAL, SG_INFO, "Using explicit TerraSync dir: " << terrasyncDir); } d = simgear::Dir(terrasyncDir); if (!d.exists()) { SG_LOG(SG_GENERAL, SG_INFO, "Creating TerraSync dir: " << terrasyncDir); d.create(0755); } // This is safe because the value of 'terrasyncDir' is trustworthy. In // particular, it can't be influenced by Nasal code, not even indirectly // via a Nasal-writable place such as the property tree. globals->set_terrasync_dir(terrasyncDir); // check if we setup a scenery path so far bool addFGDataScenery = globals->get_fg_scenery().empty(); // always add the terrasync location, regardless of whether terrasync // is enabled or not. This allows us to toggle terrasync on/off at // runtime and have things work as expected const PathList& scenery_paths(globals->get_fg_scenery()); if (std::find(scenery_paths.begin(), scenery_paths.end(), terrasyncDir) == scenery_paths.end()) { // terrasync dir is not in the scenery paths, add it globals->append_fg_scenery(terrasyncDir); } if (addFGDataScenery) { // no scenery paths set at all, use the data in FG_ROOT // ensure this path is added last SGPath root(globals->get_fg_root()); root.append("Scenery"); globals->append_fg_scenery(root); } if (!g_load_tape_aircraft.empty()) { // This might not be necessary, because we always end up calling // Options::initAircraft() later on, which also knows to use // g_load_tape_aircraft if it is not "". // SG_LOG(SG_GENERAL, SG_MANDATORY_INFO, "overriding aircraft from " << fgGetString("/sim/aircraft") << " to " << g_load_tape_aircraft); fgSetString("/sim/aircraft", g_load_tape_aircraft); } if (!g_load_tape_airport.empty()) { SG_LOG(SG_GENERAL, SG_MANDATORY_INFO, "overriding airport from " << fgGetString("/sim/presets/airport-id") << " to " << g_load_tape_airport); fgOptAirport(g_load_tape_airport.c_str()); } if (isOptionSet("json-report")) { printJSONReport(); return FG_OPTIONS_EXIT; } else if (isOptionSet("version")) { showVersion(); return FG_OPTIONS_EXIT; } return FG_OPTIONS_OK; } void Options::showUsage() const { fgOptLogLevel( "alert" ); FGLocale *locale = globals->get_locale(); SGPropertyNode options_root; simgear::requestConsole(false); // ensure console is shown on Windows cout << endl; try { fgLoadProps("options.xml", &options_root); } catch (const sg_exception &) { cout << "Unable to read the help file." << endl; cout << "Make sure the file options.xml is located in the FlightGear base directory," << endl; cout << "and the location of the base directory is specified by setting $FG_ROOT or" << endl; cout << "by adding --fg-root=path as a program argument." << endl; exit(-1); } SGPropertyNode *options = options_root.getNode("options"); if (!options) { SG_LOG( SG_GENERAL, SG_ALERT, "Error reading options.xml: element not found." ); exit(-1); } if (!locale->loadResource("options")) { cout << "Unable to read the language resource." << endl; exit(-1); } std::string usage = locale->getLocalizedString(options->getStringValue("usage"), "options"); if (!usage.empty()) { cout << usage << endl; } vectorsection = options->getChildren("section"); for (unsigned int j = 0; j < section.size(); j++) { string msg = ""; vectoroption = section[j]->getChildren("option"); for (unsigned int k = 0; k < option.size(); k++) { SGPropertyNode *name = option[k]->getNode("name"); SGPropertyNode *short_name = option[k]->getNode("short"); SGPropertyNode *key = option[k]->getNode("key"); SGPropertyNode *arg = option[k]->getNode("arg"); bool brief = option[k]->getNode("brief") != 0; if ((brief || p->verbose) && name) { string tmp = name->getStringValue(); if (key){ tmp.append(":"); tmp.append(key->getStringValue()); } if (arg) { tmp.append("="); tmp.append(arg->getStringValue()); } if (short_name) { tmp.append(", -"); tmp.append(short_name->getStringValue()); } if (tmp.size() <= 25) { msg+= " --"; msg += tmp; msg.append( 27-tmp.size(), ' '); } else { msg += "\n --"; msg += tmp + '\n'; msg.append(32, ' '); } // There may be more than one tag associated // with one option vector desc; desc = option[k]->getChildren("description"); if (! desc.empty()) { for ( unsigned int l = 0; l < desc.size(); l++) { string t = desc[l]->getStringValue(); // There may be more than one translation line. vectortrans_desc = locale->getLocalizedStrings(t.c_str(),"options"); for ( unsigned int m = 0; m < trans_desc.size(); m++ ) { string t_str = trans_desc[m]->getStringValue(); if ((m > 0) || ((l > 0) && m == 0)) { msg.append( 32, ' '); } // If the string is too large to fit on the screen, // then split it up in several pieces. while ( t_str.size() > 47 ) { string::size_type m = t_str.rfind(' ', 47); msg += t_str.substr(0, m) + '\n'; msg.append( 32, ' '); t_str.erase(t_str.begin(), t_str.begin() + m + 1); } msg += t_str + '\n'; } } } } } std::string name = locale->getLocalizedString(section[j]->getStringValue("name"),"options"); if (!msg.empty() && !name.empty()) { cout << endl << name << ":" << endl; cout << msg; msg.erase(); } } if ( !p->verbose ) { std::string verbose_help = locale->getLocalizedString(options->getStringValue("verbose-help"),"options"); if (!verbose_help.empty()) cout << endl << verbose_help << endl; } #ifdef _MSC_VER std::cout << "Hit a key to continue..." << std::endl; std::cin.get(); #endif } void Options::showVersion() const { cout << "FlightGear version: " << FLIGHTGEAR_VERSION << endl; cout << "Revision: " << REVISION << endl; cout << "Build-Id: " << JENKINS_BUILD_ID << endl; cout << "Build-Type: " << FG_BUILD_TYPE << endl; cout << "FG_ROOT=" << globals->get_fg_root().utf8Str() << endl; cout << "FG_HOME=" << globals->get_fg_home().utf8Str() << endl; cout << "FG_SCENERY="; PathList scn = globals->get_fg_scenery(); cout << SGPath::join(scn, SGPath::pathListSep) << endl; cout << "SimGear version: " << SG_STRINGIZE(SIMGEAR_VERSION) << endl; cout << "OSG version: " << osgGetVersion() << endl; cout << "PLIB version: " << PLIB_VERSION << endl; } // Print a report using JSON syntax on the standard output, encoded in UTF-8. // // The report format is versioned, don't forget to update it when making // changes (see below). void Options::printJSONReport() const { cJSON *rootNode = cJSON_CreateObject(); cJSON *metaNode = cJSON_CreateObject(); cJSON_AddItemToObject(rootNode, "meta", metaNode); cJSON_AddStringToObject(metaNode, "type", "FlightGear JSON report"); // When making compatible changes to the format (e.g., adding members to // JSON objects), only the minor version number should be increased. // Increase the major version number when a change is backward-incompatible // (such as the removal, renaming or semantic change of a member). Of // course, incompatible changes should only be considered as a last // recourse. cJSON_AddNumberToObject(metaNode, "format major version", 1); cJSON_AddNumberToObject(metaNode, "format minor version", 0); cJSON *generalNode = cJSON_CreateObject(); cJSON_AddItemToObject(rootNode, "general", generalNode); cJSON_AddStringToObject(generalNode, "name", "FlightGear"); cJSON_AddStringToObject(generalNode, "version", FLIGHTGEAR_VERSION); cJSON_AddStringToObject(generalNode, "build ID", JENKINS_BUILD_ID); cJSON_AddStringToObject(generalNode, "build type", FG_BUILD_TYPE); cJSON *configNode = cJSON_CreateObject(); cJSON_AddItemToObject(rootNode, "config", configNode); cJSON_AddStringToObject(configNode, "FG_ROOT", globals->get_fg_root().utf8Str().c_str()); cJSON_AddStringToObject(configNode, "FG_HOME", globals->get_fg_home().utf8Str().c_str()); cJSON *sceneryPathsNode = p->createJSONArrayFromPathList(globals->get_fg_scenery()); cJSON_AddItemToObject(configNode, "scenery paths", sceneryPathsNode); cJSON *aircraftPathsNode = p->createJSONArrayFromPathList( globals->get_aircraft_paths()); cJSON_AddItemToObject(configNode, "aircraft paths", aircraftPathsNode); cJSON_AddStringToObject(configNode, "TerraSync directory", globals->get_terrasync_dir().utf8Str().c_str()); cJSON_AddStringToObject(configNode, "download directory", globals->get_download_dir().utf8Str().c_str()); cJSON_AddStringToObject(configNode, "autosave file", globals->autosaveFilePath().utf8Str().c_str()); // Get the ordered lists of apt.dat, fix.dat and nav.dat files used by the // NavCache NavDataCache* cache = NavDataCache::instance(); if (!cache) { cache = NavDataCache::createInstance(); } cJSON *navDataNode = cJSON_CreateObject(); cJSON_AddItemToObject(rootNode, "navigation data", navDataNode); // Write each list to the JSON tree for (const auto& datType: {NavDataCache::DATFILETYPE_APT, NavDataCache::DATFILETYPE_FIX, NavDataCache::DATFILETYPE_NAV}) { // For this method, it doesn't matter if the cache is out-of-date const NavDataCache::DatFilesGroupInfo& datFilesInfo = cache->getDatFilesInfo(datType); cJSON *datPathsNode = p->createJSONArrayFromPathList(datFilesInfo.paths); string key = NavDataCache::datTypeStr[datType] + ".dat files"; cJSON_AddItemToObject(navDataNode, key.c_str(), datPathsNode); } // Print the JSON tree to the standard output char *report = cJSON_Print(rootNode); cout << report << endl; cJSON_Delete(rootNode); } #if defined(__CYGWIN__) SGPath Options::platformDefaultRoot() const { return SGPath::fromUtf8("../data"); } #elif defined(SG_WINDOWS) SGPath Options::platformDefaultRoot() const { return SGPath::fromUtf8("..\\data"); } #elif defined(SG_MAC) // platformDefaultRoot defined in CocoaHelpers.mm #else SGPath Options::platformDefaultRoot() const { return SGPath::fromUtf8(PKGLIBDIR); } #endif string_list Options::extractOptions() const { string_list result; for (auto opt : p->values) { if (opt.desc == nullptr) { continue; } if (!strcmp(opt.desc->option,"prop")) { result.push_back("prop:" + opt.value); } else if (opt.value.empty()) { result.push_back(opt.desc->option); } else { result.push_back(std::string(opt.desc->option) + "=" + opt.value); } } return result; } OptionResult Options::setupRoot(int argc, char** argv) { SGPath root(globals->get_fg_root()); bool usingDefaultRoot = false; // root has already been set, so skip the fg_root setting and validation. if (!root.isNull()) { return FG_OPTIONS_OK; } if (isOptionSet("fg-root")) { root = SGPath::fromUtf8(valueForOption("fg-root")); // easy! SG_LOG(SG_GENERAL, SG_INFO, "set from command-line argument: fg_root = " << root ); } else { // Next check if fg-root is set as an env variable char *envp = ::getenv( "FG_ROOT" ); if ( envp != nullptr ) { root = SGPath::fromEnv("FG_ROOT"); SG_LOG(SG_GENERAL, SG_INFO, "set from FG_ROOT env var: fg_root = " << root ); } else { #if defined(HAVE_QT) auto restoreResult = restoreUserSelectedRoot(root); if (restoreResult == SetupRootResult::UserExit) { return FG_OPTIONS_EXIT; } else if (restoreResult == SetupRootResult::UseDefault) { root = SGPath{}; // clear any value, so we fall through in root.isNull() below } #endif if (root.isNull()) { usingDefaultRoot = true; root = platformDefaultRoot(); SG_LOG(SG_GENERAL, SG_INFO, "platform default fg_root = " << root ); } else { SG_LOG(SG_GENERAL, SG_INFO, "Qt launcher set fg_root = " << root ); } } } globals->set_fg_root(root); string base_version = fgBasePackageVersion(root); #if defined(HAVE_QT) // only compare major and minor version, not the patch level. const int versionComp = simgear::strutils::compare_versions(FLIGHTGEAR_VERSION, base_version, 2); // note we never end up here if restoring a user selected root via // the Qt GUI, since that code pre-validates the path. But if we're using // a command-line, env-var or default root this check can fail and // we still want to use the GUI in that case if (versionComp != 0) { flightgear::initApp(argc, argv); bool ok = flightgear::showSetupRootDialog(usingDefaultRoot); if (!ok) { return FG_OPTIONS_EXIT; } } #else SG_UNUSED(usingDefaultRoot); // validate it if (base_version.empty()) { flightgear::fatalMessageBoxThenExit( "Base package not found", "Required data files not found, please check your installation.", "Looking for base-package files at: '" + root.str() + "'"); } // only compare major and minor version, not the patch level. const int versionComp = simgear::strutils::compare_versions(FLIGHTGEAR_VERSION, base_version, 2); if (versionComp != 0) { flightgear::fatalMessageBoxThenExit( "Base package version mismatch", "Version check failed, please check your installation.", "Found data files for version '" + base_version + "' at '" + globals->get_fg_root().str() + "', version '" + std::string(FLIGHTGEAR_VERSION) + "' is required."); } #endif return FG_OPTIONS_OK; } bool Options::shouldLoadDefaultConfig() const { return p->shouldLoadDefaultConfig; } void Options::setShouldLoadDefaultConfig(bool load) { p->shouldLoadDefaultConfig = load; } bool Options::checkForArg(int argc, char* argv[], const char* checkArg) { for (int i = 0; i < argc; ++i) { char* arg = argv[i]; if (arg == nullptr) { continue; } if (*arg != '-') { // we only care about args with a leading hypen continue; } arg++; if (*arg == '-') { // skip double hypens arg++; } if (strcmp(arg, checkArg) == 0) { return true; } } return false; } std::string Options::getArgValue(int argc, char* argv[], const char* checkArg) { const auto len = strlen(checkArg); for (int i = 0; i < argc; ++i) { char* arg = argv[i]; if (arg == nullptr) { continue; } if (strncmp(arg, checkArg, len) == 0) { const auto alen = strlen(arg); if ((alen - len) < 2) return {}; // no value after the =, or missing = entirely return std::string(arg + len + 1); } } // of args iteration return {}; } } // of namespace flightgear