src/Main/util.cxx

   1 // util.cxx - general-purpose utility functions.
   2 // Copyright (C) 2002  Curtis L. Olson  - http://www.flightgear.org/~curt
   3 //
   4 // This program is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU General Public License as
   6 // published by the Free Software Foundation; either version 2 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful, but
  10 // WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with this program; if not, write to the Free Software
  16 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17 //
  18 // $Id$
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include <config.h>
  22 #endif
  23
  24 #include <simgear/compiler.h>
  25
  26 #include <cmath>
  27
  28 #include <cstdlib>
  29
  30 #include <vector>
  31
  32 #include <simgear/debug/logstream.hxx>
  33 #include <simgear/math/SGLimits.hxx>
  34 #include <simgear/math/SGMisc.hxx>
  35
  36 #include <GUI/MessageBox.hxx>
  37 #include "fg_io.hxx"
  38 #include "fg_props.hxx"
  39 #include "globals.hxx"
  40 #include "util.hxx"
  41
  42 #ifdef OSG_LIBRARY_STATIC
  43 #include "osgDB/Registry"
  44 #endif
  45
  46 using std::vector;
  47
  48 // Originally written by Alex Perry.
  49 double
  50 fgGetLowPass (double current, double target, double timeratio)
  51 {
  52     if ( timeratio < 0.0 ) {
  53         if ( timeratio < -1.0 ) {
  54                                 // time went backwards; kill the filter
  55                 current = target;
  56         } else {
  57                                 // ignore mildly negative time
  58         }
  59     } else if ( timeratio < 0.2 ) {
  60                                 // Normal mode of operation; fast
  61                                 // approximation to exp(-timeratio)
  62         current = current * (1.0 - timeratio) + target * timeratio;
  63     } else if ( timeratio > 5.0 ) {
  64                                 // Huge time step; assume filter has settled
  65         current = target;
  66     } else {
  67                                 // Moderate time step; non linear response
  68         double keep = exp(-timeratio);
  69         current = current * keep + target * (1.0 - keep);
  70     }
  71
  72     return current;
  73 }
  74
  75 static string_list read_allowed_paths;
  76 static string_list write_allowed_paths;
  77
  78 /**
  79  * Allowed paths here are absolute, and may contain _one_ *,
  80  * which matches any string
  81  */
  82 void fgInitAllowedPaths()
  83 {
  84     if(SGPath("ygjmyfvhhnvdoesnotexist").realpath() == "ygjmyfvhhnvdoesnotexist"){
  85         // Forbid using this version of fgValidatePath() with older
  86         // (not normalizing non-existent files) versions of realpath(),
  87         // as that would be a security hole
  88         flightgear::fatalMessageBox("Nasal initialization error",
  89                                     "Version mismatch - please update simgear",
  90                                     "");
  91         exit(-1);
  92     }
  93     read_allowed_paths.clear();
  94     write_allowed_paths.clear();
  95     std::string fg_root = SGPath(globals->get_fg_root()).realpath();
  96     std::string fg_home = SGPath(globals->get_fg_home()).realpath();
  97 #if defined(_MSC_VER) /*for MS compilers */ || defined(_WIN32) /*needed for non MS windows compilers like MingW*/
  98      std::string sep = "\\";
  99 #else
 100      std::string sep = "/";
 101 #endif
 102     read_allowed_paths.push_back(fg_root + sep + "*");
 103     read_allowed_paths.push_back(fg_home + sep + "*");
 104     read_allowed_paths.push_back(fg_root);
 105     read_allowed_paths.push_back(fg_home);
 106     string_list const aircraft_paths = globals->get_aircraft_paths();
 107     string_list const scenery_paths = globals->get_secure_fg_scenery();
 108     // not plain fg_scenery, to avoid making
 109     // /sim/terrasync/scenery-dir a security hole
 110
 111     const string_list * path_lists_to_add[] = {
 112       &aircraft_paths,
 113       &scenery_paths
 114     };
 115
 116     for( size_t i = 0; i < sizeof(path_lists_to_add)/sizeof(path_lists_to_add[0]); i++ )
 117     {
 118       for( string_list::const_iterator it = path_lists_to_add[i]->begin(); it != path_lists_to_add[i]->end();++it )
 119       {
 120         // if we get the initialization order wrong, better to have an
 121         // obvious error than a can-read-everything security hole...
 122           if (it->empty() || fg_root.empty() || fg_home.empty()){
 123               flightgear::fatalMessageBox("Nasal initialization error",
 124                  "Empty string in FG_ROOT, FG_HOME, FG_AIRCRAFT or FG_SCENERY",
 125                                    "or fgInitAllowedPaths() called too early");
 126               exit(-1);
 127           }
 128           read_allowed_paths.push_back(SGPath(*it).realpath() + sep + "*");
 129           read_allowed_paths.push_back(SGPath(*it).realpath());
 130       }
 131     }
 132
 133     write_allowed_paths.push_back(fg_home + sep + "*.sav");
 134     write_allowed_paths.push_back(fg_home + sep + "*.log");
 135     write_allowed_paths.push_back(fg_home + sep + "cache" + sep + "*");
 136     write_allowed_paths.push_back(fg_home + sep + "Export" + sep + "*");
 137     write_allowed_paths.push_back(fg_home + sep + "state" + sep + "*.xml");
 138     write_allowed_paths.push_back(fg_home + sep + "aircraft-data" + sep + "*.xml");
 139     write_allowed_paths.push_back(fg_home + sep + "Wildfire" + sep + "*.xml");
 140     write_allowed_paths.push_back(fg_home + sep + "runtime-jetways" + sep + "*.xml");
 141     write_allowed_paths.push_back(fg_home + sep + "Input" + sep + "Joysticks" + sep + "*.xml");
 142
 143     // Check that it works
 144     if(!fgValidatePath(globals->get_fg_home() + "/../no.log",true).empty() ||
 145         !fgValidatePath(globals->get_fg_home() + "/no.logt",true).empty() ||
 146         !fgValidatePath(globals->get_fg_home() + "/nolog",true).empty() ||
 147         !fgValidatePath(globals->get_fg_home() + "no.log",true).empty() ||
 148         !fgValidatePath(globals->get_fg_home() + "\\..\\no.log",false).empty() ||
 149         fgValidatePath(globals->get_fg_home() + "/aircraft-data/yes..xml",true).empty() ||
 150         fgValidatePath(globals->get_fg_root() + "/.\\yes.bmp",false).empty()) {
 151             flightgear::fatalMessageBox("Nasal initialization error",
 152                                     "The FG_HOME directory must not be inside any of the FG_ROOT, FG_AIRCRAFT or FG_SCENERY directories",
 153                                     "(check that you have not accidentally included an extra :, as an empty part means the current directory)");
 154             exit(-1);
 155     }
 156 }
 157
 158 /**
 159  * Check whether Nasal is allowed to access a path
 160  * Warning: because this always (not just on Windows) treats both \ and /
 161  * as path separators, and accepts relative paths (check-to-use race if
 162  * the current directory changes),
 163  * always use the returned path not the original one
 164  */
 165 std::string fgValidatePath (const std::string& path, bool write)
 166 {
 167     // Normalize the path (prevents ../../.. or symlink trickery)
 168     std::string normed_path = SGPath(path).realpath();
 169
 170     const string_list& allowed_paths(write ? write_allowed_paths : read_allowed_paths);
 171     size_t star_pos;
 172
 173     // Check against each allowed pattern
 174     for( string_list::const_iterator it = allowed_paths.begin();
 175                                      it != allowed_paths.end();
 176                                    ++it )
 177     {
 178         star_pos = it->find('*');
 179         if (star_pos == std::string::npos) {
 180             if (!(it->compare(normed_path))) {
 181                 return normed_path;
 182             }
 183         } else {
 184             if ((it->size()-1 <= normed_path.size()) /* long enough to be a potential match */
 185                 && !(it->substr(0,star_pos)
 186                     .compare(normed_path.substr(0,star_pos))) /* before-star parts match */
 187                 && !(it->substr(star_pos+1,it->size()-star_pos-1)
 188                     .compare(normed_path.substr(star_pos+1+normed_path.size()-it->size(),
 189                       it->size()-star_pos-1))) /* after-star parts match */) {
 190                 return normed_path;
 191             }
 192         }
 193     }
 194     // no match found
 195     return "";
 196 }
 197 std::string fgValidatePath(const SGPath& path, bool write) { return fgValidatePath(path.str(),write); }
 198 // end of util.cxx
 199