New version : 2018.3.4

The following changes fixes a case for me where I hear the sound change levels up and down for each pause un-pause cycle.
Patch provided by daniel.c.wickstrom@gmail.com.

CMakeLists.txt

@@ -32,6 +32,7 @@ include (GenerateExportHeader)
 
 # only relevant for building shared libs but let's set it regardless
 set(CMAKE_OSX_RPATH 1)
+set(CMAKE_OSX_DEPLOYMENT_TARGET "10.9" CACHE STRING "Minimum OS X deployment version")
 
 # let's use & require C++11 - note these are only functional with CMake 3.1
 # we do manual fallbacks for CMake 3.0 in the compilers section
@@ -44,12 +45,7 @@ string(STRIP ${versionFile} SIMGEAR_VERSION)
 
 project(SimGear VERSION ${SIMGEAR_VERSION} LANGUAGES C CXX)
 
-# using 10.7 because boost requires libc++ and 10.6 doesn't include it
-# Cmake documentation says we must set this before calling project(), but
-# it only seems to be picked up setting it /after/ the call to project()
-set(CMAKE_OSX_DEPLOYMENT_TARGET "10.7")
-
-# add a dependency on the versino file
+# add a dependency on the version file
 set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS version)
 
 set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS TRUE)
@@ -126,12 +122,17 @@ option(ENABLE_RTI       "Set to ON to build SimGear with RTI support" OFF)
 option(ENABLE_GDAL      "Set to ON to build SimGear with GDAL support" OFF)
 option(ENABLE_TESTS     "Set to OFF to disable building SimGear's test applications" ON)
 option(ENABLE_SOUND     "Set to OFF to disable building SimGear's sound support" ON)
-option(USE_AEONWAVE     "Set to ON to use AeonWave instead of OpenAL" OFF)
+option(USE_AEONWAVE     "Set to ON to use AeonWave instead of OpenAL" ON)
 option(ENABLE_PKGUTIL   "Set to ON to build the sg_pkgutil application (default)" ON)
 option(ENABLE_DNS       "Set to ON to use udns library and DNS service resolver" ON)
-option(ENABLE_SIMD      "Enable SSE/SSE2 support for x86 compilers" ON)
+option(ENABLE_SIMD      "Enable SSE/SSE2 support for compilers" ON)
+option(ENABLE_SIMD_CODE	"Enable SSE/SSE2 support code for compilers" OFF)
 option(ENABLE_OPENMP    "Enable OpenMP compiler support" OFF)
 
+if (NOT ENABLE_SIMD AND ENABLE_SIMD_CODE)
+  set(ENABLE_SIMD_CODE OFF)
+endif()
+
 include (DetectArch)
 
 # until the fstream fix is applied and generally available in OSG,
@@ -167,14 +168,22 @@ endif (MSVC)
 if (MSVC AND MSVC_3RDPARTY_ROOT)
   message(STATUS "3rdparty files located in ${MSVC_3RDPARTY_ROOT}")
 
+  string(SUBSTRING ${MSVC_VERSION} 0 2 MSVC_VERSION_MAJOR)
+  string(SUBSTRING ${MSVC_VERSION} 2 2 MSVC_VERSION_MINOR)
+
   set( OSG_MSVC "msvc" )
-  if (${MSVC_VERSION} EQUAL 1900)
+  if (${MSVC_VERSION_MAJOR} EQUAL "19")
+    if (${MSVC_VERSION_MINOR} EQUAL "00")
       set( OSG_MSVC ${OSG_MSVC}140 )
-  elseif (${MSVC_VERSION} EQUAL 1800)
-      set( OSG_MSVC ${OSG_MSVC}120 )
+    else ()
+      set( OSG_MSVC ${OSG_MSVC}141 )
+    endif ()
+  elseif (${MSVC_VERSION_MAJOR} EQUAL "18")
+    set( OSG_MSVC ${OSG_MSVC}120 )
   else ()
-      message(FATAL_ERROR "Visual Studio 2013/2015 is required now")
+    message(FATAL_ERROR "Visual Studio 2013/15/17 is required")
   endif ()
+
   if (CMAKE_CL_64)
       set( OSG_MSVC ${OSG_MSVC}-64 )
       set( MSVC_3RDPARTY_DIR 3rdParty.x64 )
@@ -194,11 +203,8 @@ if (MSVC AND MSVC_3RDPARTY_ROOT)
     message(STATUS "BOOST_INCLUDEDIR is ${BOOST_INCLUDEDIR}")
   endif()
 
-  if (NOT USE_AEONWAVE)
-    set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
-    set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib)
-    message(STATUS "OPENAL_INCLUDE_DIR is ${OPENAL_INCLUDE_DIR}")
-  endif()
+  set (OPENAL_INCLUDE_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/include)
+  set (OPENAL_LIBRARY_DIR ${MSVC_3RDPARTY_ROOT}/${MSVC_3RDPARTY_DIR}/lib)
 endif (MSVC AND MSVC_3RDPARTY_ROOT)
 
 if(APPLE)
@@ -222,12 +228,19 @@ else()
 
     if (ENABLE_SOUND)
         if (USE_AEONWAVE)
-            find_package(AAX COMPONENTS aax REQUIRED)
-        else()
+            find_package(AAX)
+        endif()
+
+        if(NOT AAX_FOUND)
+            set(USE_AEONWAVE FALSE)
             find_package(OpenAL REQUIRED)
         endif()
 
-        message(STATUS "Sound support: ENABLED")
+        if(AAX_FOUND)
+            message(STATUS "Sound support: AeonWave")
+        else()
+            message(STATUS "Sound support: OpenAL")
+        endif()
     endif(ENABLE_SOUND)
 
     find_package(OpenSceneGraph 3.2.0 REQUIRED osgText osgSim osgDB osgParticle osgGA osgViewer osgUtil)
@@ -404,8 +417,8 @@ if(CMAKE_COMPILER_IS_GNUCXX)
         "${CMAKE_CXX_FLAGS} -O0 -fno-omit-frame-pointer -fno-inline")
     elseif (ENABLE_SIMD)
       if (X86 OR X86_64)
-        set(CMAKE_C_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse")
-        set(CMAKE_CXX_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse")
+        set(CMAKE_C_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
+        set(CMAKE_CXX_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
       endif()
     endif()
 
@@ -432,8 +445,8 @@ if (CLANG)
         "${CMAKE_CXX_FLAGS} -O0 -fno-omit-frame-pointer -fno-inline-functions")
     elseif (ENABLE_SIMD)
       if (X86 OR X86_64)
-        set(CMAKE_C_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse")
-        set(CMAKE_CXX_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse")
+        set(CMAKE_C_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
+        set(CMAKE_CXX_FLAGS_RELEASE "-O3 -msse2 -mfpmath=sse -ftree-vectorize -ftree-slp-vectorize")
       endif()
     endif()
 endif()

CMakeModules/FindAAX.cmake

@@ -1,61 +1,74 @@
-# Locate AAX
+# Try to find AAX (AeonWave)
 # This module defines
-# AAX_LIBRARIES
-# AAX_FOUND, if false, do not try to link to AAX 
-# AAX_INCLUDE_DIR, where to find the headers
+#
+# AAX_FOUND - if false, do not try to link to AAX
+# AAX_INCLUDE_DIR - where to find the headers
+# AAX_LIBRARIES - Link these to use AAX
+#
+# Copyright (C) 2016-2018 by Erik Hofman.
+# Copyright (C) 2016-2018 by Adalin B.V.
 #
 # $AAXDIR is an environment variable that would
 # correspond to the ./configure --prefix=$AAXDIR
 # used in building AAX.
 #
-# Created by Erik Hofman.
+# This file is Public Domain (www.unlicense.org)
+# This is free and unencumbered software released into the public domain.
 
-FIND_PATH(AAX_INCLUDE_DIR aax/aax.h
-  HINTS
-  $ENV{AAXDIR}
-  $ENV{ProgramFiles}/aax
-  $ENV{ProgramFiles}/AeonWave
-  $ENV{ProgramFiles}/Adalin/AeonWave
-  ${CMAKE_SOURCE_DIR}/aax
-  PATH_SUFFIXES include
-  PATHS
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt
-)
+if (AAX_LIBRARY AND AAX_INCLUDE_DIR)
+  # in cache already
+  set(AAX_FOUND TRUE)
+else()
+  find_path(AAX_INCLUDE_DIR aax/aax.h
+    HINTS
+    $ENV{AAXDIR}
+    $ENV{ProgramFiles}/aax
+    $ENV{ProgramFiles}/AeonWave
+    $ENV{ProgramFiles}/Adalin/AeonWave
+    ${CMAKE_SOURCE_DIR}/aax
+    PATH_SUFFIXES include
+    PATHS
+    ~/Library/Frameworks
+    /Library/Frameworks
+    /usr/local
+    /usr
+    /opt
+  )
 
-FIND_LIBRARY(AAX_LIBRARY 
-  NAMES AAX aax AAX32
-  HINTS
-  $ENV{AAXDIR}
-  $ENV{ProgramFiles}/AAX
-  $ENV{ProgramFiles}/AeonWave
-  $ENV{ProgramFiles}/Adalin/AeonWave
-  ${CMAKE_BUILD_DIR}/aax
-  PATH_SUFFIXES bin lib lib/${CMAKE_LIBRARY_ARCHITECTURE} lib64 libs64 libs libs/Win32 libs/Win64
-  PATHS
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt
-)
+  find_library(AAX_LIBRARY 
+    NAMES AAX aax libAAX
+    HINTS
+    $ENV{AAXDIR}
+    $ENV{ProgramFiles}/AAX
+    $ENV{ProgramFiles}/AeonWave
+    $ENV{ProgramFiles}/Adalin/AeonWave
+    ${CMAKE_BUILD_DIR}/aax
+    PATH_SUFFIXES lib64 lib lib/${CMAKE_LIBRARY_ARCHITECTURE} libs64 libs libs/Win32 libs/Win64 bin
+    PATHS
+    ~/Library/Frameworks
+    /Library/Frameworks
+    /usr/local
+    /usr
+    /opt
+  )
 
-IF(AAX_LIBRARY AND AAX_INCLUDE_DIR)
-  SET(AAX_FOUND "YES")
-ELSE(AAX_LIBRARY AND AAX_INCLUDE_DIR)
-  IF(NOT AAX_INCLUDE_DIR)
-    MESSAGE(FATAL_ERROR "Unable to find the AAX library development files.")
-    SET(AAX_FOUND "NO")
-  ENDIF(NOT AAX_INCLUDE_DIR)
-  IF(NOT AAX_LIBRARY)
-    IF(SINGLE_PACKAGE)
-      SET(AAX_LIBRARY "${aax_BUILD_DIR}/aax/AAX32.dll")
-      SET(AAX_FOUND "YES")
-    ELSE(SINGLE_PACKAGE)
-    ENDIF(SINGLE_PACKAGE)
-  ENDIF(NOT AAX_LIBRARY)
-ENDIF(AAX_LIBRARY AND AAX_INCLUDE_DIR)
+  set(AAX_DEFINITIONS "")
+  if (AAX_LIBRARY AND AAX_INCLUDE_DIR)
+    set(AAX_FOUND TRUE)
+  endif()
+
+  if (AAX_FOUND)
+    if (NOT Udns_FIND_QUIETLY)
+      message(STATUS "Found AeonWave: ${AAX_LIBRARIES}")
+    endif ()
+  else ()
+    if (Udns_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find AeonWave")
+    endif ()
+  endif ()
+
+  # show the AAX_INCLUDE_DIRS and AAX_LIBRARIES variables only in the advanced view
+  mark_as_advanced(AAX_INCLUDE_DIRS AAX_LIBRARIES)
+
+endif()
 

CMakeModules/SimGearComponent.cmake

@@ -12,6 +12,11 @@ macro(simgear_component_common name includePath sourcesList sources headers)
 		set_property(GLOBAL
 			APPEND PROPERTY PUBLIC_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
         set(fh${sourcesList} "${fh${sourcesList}}#${CMAKE_CURRENT_SOURCE_DIR}/${h}")
+
+        # also append headers to the sources list, so that IDEs find the files
+        # correctly (otherwise they are not in the project)
+        set_property(GLOBAL
+            APPEND PROPERTY ${sourcesList} "${CMAKE_CURRENT_SOURCE_DIR}/${h}")
 	endforeach()
 
     set_property(GLOBAL APPEND PROPERTY FG_GROUPS_${sourcesList}_C "${fc${sourcesList}}@")

README.OpenAL

@@ -1,20 +0,0 @@
-[This file is mirrored in both the FlightGear and SimGear packages.]
-
-You *must* have the development components of OpenAL installed on your system
-to build FlightGear!"  You can get a copy here:
-
-      http://connect.creativelabs.com/openal/default.aspx
-
-Build notes:
-
-You can download a versioned release of the openal library from 
-http://www.openal.org/downloads.html. Download the openal source,
-release 0.0.8 (dated February 11, 2006) and run:  
-tar xjvf openal-soft-1.5.304.tar.bz2
-cd openal-soft-1.5.304/
-ccmake .
-
-[ While running ccmake: press 'c' to configure, press 'c' once more, and
-  then press 'g' to generate and exit ]
-
-

README.sound

@@ -0,0 +1,39 @@
+[This file is mirrored in both the FlightGear and SimGear packages.]
+
+For Sound support FlightGear requires one of the two following packages:
+- OpenAL
+- AeonWave
+
+== OpenAL ===
+
+You *must* have the development components of OpenAL installed on your system
+to build FlightGear!"  You can get a copy here:
+
+      http://connect.creativelabs.com/openal/default.aspx
+
+Build notes:
+
+You can download a versioned release of the openal library from
+http://www.openal.org/downloads.html. Download the openal source,
+release 0.0.8 (dated February 11, 2006) and run:
+tar xjvf openal-soft-1.5.304.tar.bz2
+cd openal-soft-1.5.304/
+ccmake .
+
+[ While running ccmake: press 'c' to configure, press 'c' once more, and
+  then press 'g' to generate and exit ]
+
+
+== AeonWave ===
+
+For FlightGear AeonWave has a number of advantages over OpenAL:
+* Correct Doppler effect behavior
+* Default distance attenuation frequency filtering
+* Native support for 29 types of audio formats.
+* Native support for wav, mp3, vorbis and raw file formats.
+
+The source code of AeonWave can be found on GitHub:
+https://github.com/adalinbv
+
+Optimized binary packages are available at:
+http://www.adalin.com/

simgear/canvas/Canvas.cxx

@@ -39,6 +39,75 @@ namespace simgear
 {
 namespace canvas
 {
+  static int globalinstanceid = 1;
+  /**
+   * Camera Callback for moving completed canvas images to subscribed listener.
+   */
+  class CanvasImageCallback : public osg::Camera::DrawCallback {
+    public:
+    osg::Image *_rawImage;
+
+    CanvasImageCallback(osg::Image *rawImage)
+    : _min_delta_tick(1.0 / 8.0) {
+      _previousFrameTick = osg::Timer::instance()->tick();
+      _rawImage = rawImage;
+      SG_LOG(SG_GENERAL,SG_INFO,"CanvasImageCallback created. instance is " << instanceid);
+    }
+
+    virtual void operator()(osg::RenderInfo& renderInfo) const {
+      osg::Timer_t n = osg::Timer::instance()->tick();
+      double dt = osg::Timer::instance()->delta_s(_previousFrameTick, n);
+      if (dt < _min_delta_tick)
+        return;
+      _previousFrameTick = n;
+      SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImageCallback " << instanceid << ": image available for " << _subscribers.size() << " subscribers. camera is " << renderInfo.getCurrentCamera());
+
+      bool hasSubscribers = false;
+      {
+        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_lock);
+        hasSubscribers = !_subscribers.empty();
+      }
+      if (hasSubscribers) {
+        //Make sure image can be overwritten by next frame while it is still returned to the client
+        osg::Image* image = new osg::Image(*_rawImage, osg::CopyOp::DEEP_COPY_ALL);
+        {
+          OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_lock);
+          while (!_subscribers.empty()) {
+            try {
+              CanvasImageReadyListener *subs = _subscribers.back();
+              if (subs){
+                subs->imageReady(image);
+              }else{
+                SG_LOG(SG_GENERAL,SG_WARN,"CanvasImageCallback subscriber null");
+              }
+            } catch (...) { }
+            _subscribers.pop_back();
+          }
+        }
+      }
+    }
+
+    void subscribe(CanvasImageReadyListener * subscriber) {
+      OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_lock);
+      _subscribers.push_back(subscriber);
+    }
+
+    void unsubscribe(CanvasImageReadyListener * subscriber) {
+      OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_lock);
+      _subscribers.remove(subscriber);
+    }
+
+    int getSubscriberCount() {
+      return _subscribers.size();
+    }
+
+    private:
+      mutable list<CanvasImageReadyListener*> _subscribers;
+      mutable OpenThreads::Mutex _lock;
+      mutable double _previousFrameTick;
+      double _min_delta_tick;
+      int instanceid = globalinstanceid++;
+  };
 
   //----------------------------------------------------------------------------
   Canvas::CullCallback::CullCallback(const CanvasWeakPtr& canvas):
@@ -248,6 +317,21 @@ namespace canvas
 
       osg::Camera* camera = _texture.getCamera();
 
+      string canvasname = _node->getStringValue("name");
+      int renderToImage = _node->getBoolValue("render-to-image");
+
+      if (renderToImage){
+        CanvasImageCallback *_screenshotCallback = dynamic_cast<CanvasImageCallback*> (camera->getFinalDrawCallback());
+        if (!_screenshotCallback) {
+          // no draw callback yet
+          osg::Image* shot = new osg::Image();
+          shot->allocateImage(getSizeX(), getSizeY(), 24, GL_RGB, GL_UNSIGNED_BYTE);
+          camera->attach(osg::Camera::COLOR_BUFFER, shot);
+          camera->setFinalDrawCallback(new CanvasImageCallback(shot));
+          SG_LOG(SG_GENERAL,SG_INFO,"CanvasImage: attached image and draw callback to camera " << camera << " for canvas " << canvasname << ". Ready for subscriber now.");
+        }
+      }
+
       // TODO Allow custom render order? For now just keep in order with
       //      property tree.
       camera->setRenderOrder(osg::Camera::PRE_RENDER, _node->getIndex());
@@ -347,6 +431,41 @@ namespace canvas
     }
   }
 
+  int Canvas::subscribe(CanvasImageReadyListener * subscriber) {
+    osg::Camera* camera = _texture.getCamera();
+    const string canvasname = _node->getStringValue("name");
+
+    SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImage: subscribe to canvas " << canvasname.c_str() << ", camera ="<< camera);
+
+    if (!_node->getBoolValue("render-to-image")) {
+      SG_LOG(SG_GENERAL,SG_INFO,"CanvasImage: Setting render-to-image");
+      _node->addChild("render-to-image", 0)->setBoolValue(1);
+      setStatusFlags(STATUS_DIRTY, true);
+    }
+
+    CanvasImageCallback *_screenshotCallback = dynamic_cast<CanvasImageCallback*> (camera->getFinalDrawCallback());
+    if (_screenshotCallback) {
+      // Camera ready for subscriber. Otherwise, draw callback is created by canvas thread later.
+      SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImage: adding subscriber to camera draw callback");
+      _screenshotCallback->subscribe(subscriber);
+      // TODO: check: Is this the correct way to ensure the canvas will be available?
+      enableRendering(true);
+      return 1;
+    }
+    return 0;
+  }
+
+  int Canvas::unsubscribe(CanvasImageReadyListener * subscriber) {
+    osg::Camera* camera = _texture.getCamera();
+    SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImage: unsubscribe");
+    CanvasImageCallback *cb = dynamic_cast<CanvasImageCallback*> (camera->getFinalDrawCallback());
+    if (cb) {
+      SG_LOG(SG_GENERAL,SG_DEBUG,"CanvasImage: unsubscribe from camera " << camera);
+      cb->unsubscribe(subscriber);
+    }
+    return 0;
+  }
+
   //----------------------------------------------------------------------------
   bool Canvas::addEventListener( const std::string& type,
                                  const EventListener& cb )

simgear/canvas/Canvas.hxx

@@ -44,6 +44,17 @@ namespace canvas
   class CanvasMgr;
   class MouseEvent;
 
+  /**
+   * A listener interested in completed canvas drawing.
+   */
+  class CanvasImageReadyListener {
+  public:
+    virtual void imageReady(osg::ref_ptr<osg::Image>) = 0;
+    virtual ~CanvasImageReadyListener()
+    {
+    }
+  };
+
   /**
    * Canvas to draw onto (to an off-screen render target).
    */
@@ -160,7 +171,12 @@ namespace canvas
        */
       void enableRendering(bool force = false);
 
-      void update(double delta_time_sec);
+      void update(double delta_time_sec) override;
+
+      osg::Camera* getCamera();
+      int subscribe(CanvasImageReadyListener * subscriber);
+      int unsubscribe(CanvasImageReadyListener * subscriber);
+      int getSubscriberCount();
 
       bool addEventListener(const std::string& type, const EventListener& cb);
       bool dispatchEvent(const EventPtr& event);

simgear/canvas/elements/CanvasMap.cxx

@@ -97,17 +97,26 @@ namespace canvas
           || (!geo_node->isDirty() && !_projection_dirty) )
         continue;
 
-      GeoCoord lat = parseGeoCoord(geo_node->getLat());
-      if( lat.type != GeoCoord::LATITUDE )
-        continue;
-
-      GeoCoord lon = parseGeoCoord(geo_node->getLon());
-      if( lon.type != GeoCoord::LONGITUDE )
-        continue;
-
-      Projection::ScreenPosition pos =
-        _projection->worldToScreen(lat.value, lon.value);
-
+      double latD = -9999.0, lonD = -9999.0;
+      if (geo_node->isDirty()) {
+        GeoCoord lat = parseGeoCoord(geo_node->getLat());
+        if( lat.type != GeoCoord::LATITUDE )
+          continue;
+        
+        GeoCoord lon = parseGeoCoord(geo_node->getLon());
+        if( lon.type != GeoCoord::LONGITUDE )
+          continue;
+        
+        // save the parsed values so we can re-use them if only projection
+        // is changed (very common case for moving vehicle)
+        latD = lat.value;
+        lonD = lon.value;
+        geo_node->setCachedLatLon(std::make_pair(latD, lonD));
+      } else {
+        std::tie(latD, lonD) = geo_node->getCachedLatLon();
+      }
+      
+      Projection::ScreenPosition pos = _projection->worldToScreen(latD, lonD);
       geo_node->setScreenPos(pos.x, pos.y);
 
 //      geo_node->print();

simgear/canvas/elements/CanvasPath.cxx

@@ -863,6 +863,9 @@ namespace canvas
   //----------------------------------------------------------------------------
   void Path::childChanged(SGPropertyNode* child)
   {
+    if( child->getParent() != _node )
+      return;
+      
     const std::string& name = child->getNameString();
     const std::string &prName = child->getParent()->getNameString();
 
@@ -892,9 +895,6 @@ namespace canvas
       return;
     }
 
-    if( child->getParent() != _node )
-      return;
-
     if( name == "cmd" )
       _attributes_dirty |= CMDS;
     else if( name == "coord" )

simgear/canvas/elements/map/geo_node_pair.hxx

@@ -67,7 +67,8 @@ namespace canvas
       {
         _node_lat = node;
         _status &= ~LAT_MISSING;
-
+        _xNode.reset();
+          
         if( node == _node_lon )
         {
           _node_lon = 0;
@@ -79,7 +80,8 @@ namespace canvas
       {
         _node_lon = node;
         _status &= ~LON_MISSING;
-
+        _yNode.reset();
+          
         if( node == _node_lat )
         {
           _node_lat = 0;
@@ -97,19 +99,34 @@ namespace canvas
         return _node_lon ? _node_lon->getStringValue() : "";
       }
 
+      void setCachedLatLon(const std::pair<double, double>& latLon)
+      { _cachedLatLon = latLon; }
+      
+      std::pair<double, double> getCachedLatLon()
+      { return _cachedLatLon; }
+      
       void setTargetName(const std::string& name)
       {
         _target_name = name;
+        _xNode.reset();
+        _yNode.reset();
       }
 
       void setScreenPos(float x, float y)
       {
         assert( isComplete() );
-        SGPropertyNode *parent = _node_lat->getParent();
-        parent->getChild(_target_name, _node_lat->getIndex(), true)
-              ->setDoubleValue(x);
-        parent->getChild(_target_name, _node_lon->getIndex(), true)
-              ->setDoubleValue(y);
+        if (!_xNode) {
+          SGPropertyNode *parent = _node_lat->getParent();
+          _xNode = parent->getChild(_target_name, _node_lat->getIndex(), true);
+        }
+          
+        if (!_yNode) {
+          SGPropertyNode *parent = _node_lat->getParent();
+          _yNode = parent->getChild(_target_name, _node_lon->getIndex(), true);
+        }
+          
+        _xNode->setDoubleValue(x);
+        _yNode->setDoubleValue(y);
       }
 
       void print()
@@ -125,6 +142,9 @@ namespace canvas
       SGPropertyNode *_node_lat,
                      *_node_lon;
       std::string   _target_name;
+      SGPropertyNode_ptr _xNode,
+          _yNode;
+      std::pair<double, double> _cachedLatLon;
 
   };
 

simgear/debug/CMakeLists.txt

@@ -1,7 +1,7 @@
 
 include (SimGearComponent)
 
-set(HEADERS debug_types.h logstream.hxx BufferedLogCallback.hxx)
+set(HEADERS debug_types.h logstream.hxx BufferedLogCallback.hxx OsgIoCapture.hxx)
 set(SOURCES logstream.cxx BufferedLogCallback.cxx)
 
-simgear_component(debug debug "${SOURCES}" "${HEADERS}")
+simgear_component(debug debug "${SOURCES}" "${HEADERS}")

simgear/debug/OsgIoCapture.hxx

@@ -0,0 +1,45 @@
+#include <cstring>
+
+#include <osg/Notify>
+
+using namespace osg;
+
+
+/**
+ * merge OSG output into our logging system, so it gets recorded to file,
+ * and so we can display a GUI console with renderer issues, especially
+ * shader compilation warnings and errors.
+ */
+class NotifyLogger : public osg::NotifyHandler
+{
+public:
+    // note this callback will be invoked by OSG from multiple threads.
+    // fortunately our Simgear logging implementation already handles
+    // that internally, so we simply pass the message on.
+    virtual void notify(osg::NotifySeverity severity, const char* message) {
+        // Detect whether a osg::Reference derived object is deleted with a non-zero
+        // reference count. In this case trigger a segfault to get a stack trace.
+        if (strstr(message, "the final reference count was")) {
+            // as this is going to segfault ignore the translation of severity and always output the message.
+            SG_LOG(SG_GL, SG_ALERT, message);
+            int* trigger_segfault = 0;
+            *trigger_segfault     = 0;
+            return;
+        }
+        SG_LOG(SG_GL, translateSeverity(severity), message);
+    }
+
+private:
+    sgDebugPriority translateSeverity(osg::NotifySeverity severity) {
+        switch (severity) {
+            case osg::ALWAYS:
+            case osg::FATAL:      return SG_ALERT;
+            case osg::WARN:       return SG_WARN;
+            case osg::NOTICE:
+            case osg::INFO:       return SG_INFO;
+            case osg::DEBUG_FP:
+            case osg::DEBUG_INFO: return SG_DEBUG;
+            default:              return SG_ALERT;
+        }
+    }
+};

simgear/debug/debug_types.h

@@ -34,7 +34,8 @@ typedef enum {
     SG_GUI         = 0x00800000,
     SG_TERRASYNC   = 0x01000000,
     SG_PARTICLES   = 0x02000000,
-    SG_UNDEFD      = 0x04000000, // For range checking
+    SG_HEADLESS    = 0x04000000,
+    SG_UNDEFD      = 0x08000000, // For range checking
 
     SG_ALL         = 0xFFFFFFFF
 } sgDebugClass;

simgear/debug/logstream.cxx

@@ -100,6 +100,7 @@ const char* LogCallback::debugClassToString(sgDebugClass c)
         case SG_GUI:        return "gui";
         case SG_TERRASYNC:  return "terrasync";
         case SG_PARTICLES:  return "particles";
+        case SG_HEADLESS:   return "headless";
         default:            return "unknown";
     }
 }

simgear/io/HTTPClient.cxx

@@ -472,12 +472,26 @@ size_t Client::requestReadCallback(char *ptr, size_t size, size_t nmemb, void *u
   return actualBytes;
 }
 
+bool isRedirectStatus(int code)
+{
+    return ((code >= 300) && (code < 400));
+}
+    
 size_t Client::requestHeaderCallback(char *rawBuffer, size_t size, size_t nitems, void *userdata)
 {
   size_t byteSize = size * nitems;
   Request* req = static_cast<Request*>(userdata);
   std::string h = strutils::simplify(std::string(rawBuffer, byteSize));
 
+  if (req->readyState() >= HTTP::Request::HEADERS_RECEIVED) {
+      // this can happen with chunked transfers (secondary chunks)
+      // or redirects
+      if (isRedirectStatus(req->responseCode())) {
+          req->responseStart(h);
+          return byteSize;
+      }
+  }
+    
   if (req->readyState() == HTTP::Request::OPENED) {
     req->responseStart(h);
     return byteSize;

simgear/io/HTTPRepository.cxx

@@ -90,8 +90,10 @@ namespace simgear
         case HTTPRepository::REPO_ERROR_CANCELLED:   return "cancelled";
         case HTTPRepository::REPO_PARTIAL_UPDATE:   return "partial update (incomplete)";
         }
+
+        return "Unknown response code";
     }
-    
+
 class HTTPRepoPrivate
 {
 public:
@@ -180,17 +182,11 @@ class HTTPDirectory
         ChildInfo(Type ty, const std::string & nameData, const std::string & hashData) :
             type(ty),
             name(nameData),
-            hash(hashData),
-            sizeInBytes(0)
+            hash(hashData)
         {
         }
 
-        ChildInfo(const ChildInfo& other) :
-            type(other.type),
-            name(other.name),
-            hash(other.hash),
-            sizeInBytes(other.sizeInBytes)
-        { }
+		ChildInfo(const ChildInfo& other) = default;
 
         void setSize(const std::string & sizeData)
         {
@@ -204,7 +200,8 @@ class HTTPDirectory
 
         Type type;
         std::string name, hash;
-        size_t sizeInBytes;
+		size_t sizeInBytes = 0;
+		SGPath path; // absolute path on disk
     };
 
     typedef std::vector<ChildInfo> ChildInfoList;
@@ -271,44 +268,45 @@ public:
             return;
         }
 
-        string_list indexNames = indexChildren();
-        const_string_list_iterator nameIt = indexNames.begin();
-        for (; nameIt != indexNames.end(); ++nameIt) {
-            SGPath p(absolutePath());
-            p.append(*nameIt);
-            if (p.exists()) {
-                continue; // only copy if the file is missing entirely
-            }
+		char* buf = nullptr;
+		size_t bufSize = 0;
 
-            ChildInfoList::iterator c = findIndexChild(*nameIt);
-            if (c->type == ChildInfo::DirectoryType) {
-                continue; // only care about files
-            }
+		for (const auto& child : children) {
+			if (child.type != ChildInfo::FileType)
+				continue;
 
-            SGPath cp = _repository->installedCopyPath;
-            cp.append(relativePath());
-            cp.append(*nameIt);
-            if (!cp.exists()) {
-                continue;
-            }
-            
-            SGBinaryFile src(cp);
-            SGBinaryFile dst(p);
-            src.open(SG_IO_IN);
-            dst.open(SG_IO_OUT);
+			if (child.path.exists())
+				continue;
 
-            char* buf = (char*) malloc(cp.sizeInBytes());
-            if (!buf) {
-                continue;
-            }
+			SGPath cp = _repository->installedCopyPath;
+			cp.append(relativePath());
+			cp.append(child.name);
+			if (!cp.exists()) {
+				continue;
+			}
 
-            src.read(buf, cp.sizeInBytes());
-            dst.write(buf, cp.sizeInBytes());
-            src.close();
-            dst.close();
+			SGBinaryFile src(cp);
+			SGBinaryFile dst(child.path);
+			src.open(SG_IO_IN);
+			dst.open(SG_IO_OUT);
 
-            free(buf);
-        }
+			if (bufSize < cp.sizeInBytes()) {
+				bufSize = cp.sizeInBytes();
+				free(buf);
+				buf = (char*) malloc(bufSize);
+				if (!buf) {
+					continue;
+				}
+			}
+
+			src.read(buf, cp.sizeInBytes());
+			dst.write(buf, cp.sizeInBytes());
+			src.close();
+			dst.close();
+
+		}
+
+		free(buf);
     }
 
     void updateChildrenBasedOnHash()
@@ -317,36 +315,40 @@ public:
 
         copyInstalledChildren();
 
-        string_list indexNames = indexChildren(),
-            toBeUpdated, orphans;
+		string_list toBeUpdated, orphans,
+			indexNames = indexChildren();
         simgear::Dir d(absolutePath());
         PathList fsChildren = d.children(0);
-        PathList::const_iterator it = fsChildren.begin();
 
+        for (const auto& child : fsChildren) {
+			const auto& fileName = child.file();
+			if ((fileName == ".dirindex") || (fileName == ".hashes")) {
+				continue;
+			}
 
-        for (; it != fsChildren.end(); ++it) {
-            ChildInfo info(it->isDir() ? ChildInfo::DirectoryType : ChildInfo::FileType,
-                           it->file(), "");
+            ChildInfo info(child.isDir() ? ChildInfo::DirectoryType : ChildInfo::FileType, 
+				fileName, "");
+			info.path = child;
             std::string hash = hashForChild(info);
 
-            ChildInfoList::iterator c = findIndexChild(it->file());
+            ChildInfoList::iterator c = findIndexChild(fileName);
             if (c == children.end()) {
-                orphans.push_back(it->file());
+                orphans.push_back(fileName);
             } else if (c->hash != hash) {
 #if 0
-                SG_LOG(SG_TERRASYNC, SG_DEBUG, "hash mismatch'" << it->file() );
+                SG_LOG(SG_TERRASYNC, SG_DEBUG, "hash mismatch'" << fileName);
                 // file exists, but hash mismatch, schedule update
                 if (!hash.empty()) {
-                    SG_LOG(SG_TERRASYNC, SG_DEBUG, "file exists but hash is wrong for:" << it->file() );
+                    SG_LOG(SG_TERRASYNC, SG_DEBUG, "file exists but hash is wrong for:" << fileName);
                     SG_LOG(SG_TERRASYNC, SG_DEBUG, "on disk:" << hash << " vs in info:" << c->hash);
                 }
 #endif
-                toBeUpdated.push_back(it->file() );
+                toBeUpdated.push_back(fileName);
             } else {
                 // file exists and hash is valid. If it's a directory,
                 // perform a recursive check.
                 if (c->type == ChildInfo::DirectoryType) {
-                    HTTPDirectory* childDir = childDirectory(it->file());
+                    HTTPDirectory* childDir = childDirectory(fileName);
                     childDir->updateChildrenBasedOnHash();
                 }
             }
@@ -354,7 +356,7 @@ public:
             // remove existing file system children from the index list,
             // so we can detect new children
             // https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Erase-Remove
-            indexNames.erase(std::remove(indexNames.begin(), indexNames.end(), it->file()), indexNames.end());
+            indexNames.erase(std::remove(indexNames.begin(), indexNames.end(), fileName), indexNames.end());
         } // of real children iteration
 
         // all remaining names in indexChilden are new children
@@ -423,19 +425,16 @@ public:
     void didUpdateFile(const std::string& file, const std::string& hash, size_t sz)
     {
         // check hash matches what we expected
-        ChildInfoList::iterator it = findIndexChild(file);
+        auto it = findIndexChild(file);
         if (it == children.end()) {
             SG_LOG(SG_TERRASYNC, SG_WARN, "updated file but not found in dir:" << _relativePath << " " << file);
         } else {
-            SGPath fpath(absolutePath());
-            fpath.append(file);
-
             if (it->hash != hash) {
                 // we don't erase the file on a hash mismatch, becuase if we're syncing during the
                 // middle of a server-side update, the downloaded file may actually become valid.
                 _repository->failedToUpdateChild(_relativePath, HTTPRepository::REPO_ERROR_CHECKSUM);
             } else {
-                _repository->updatedFileContents(fpath, hash);
+                _repository->updatedFileContents(it->path, hash);
                 _repository->totalDownloaded += sz;
             } // of hash matches
         } // of found in child list
@@ -534,8 +533,8 @@ private:
                 continue;
             }
 
-            children.push_back(ChildInfo(typeData == "f" ? ChildInfo::FileType : ChildInfo::DirectoryType, tokens[1], tokens[2]));
-
+            children.emplace_back(ChildInfo(typeData == "f" ? ChildInfo::FileType : ChildInfo::DirectoryType, tokens[1], tokens[2]));
+			children.back().path = absolutePath() / tokens[1];
             if (tokens.size() > 3) {
                 children.back().setSize(tokens[3]);
             }
@@ -567,8 +566,7 @@ private:
 
     std::string hashForChild(const ChildInfo& child) const
     {
-        SGPath p(absolutePath());
-        p.append(child.name);
+		SGPath p(child.path);
         if (child.type == ChildInfo::DirectoryType) {
             p.append(".dirindex");
         }
@@ -677,7 +675,7 @@ std::string HTTPRepository::resultCodeAsString(ResultCode code)
 {
     return innerResultCodeAsString(code);
 }
-    
+
 HTTPRepository::ResultCode
 HTTPRepository::failure() const
 {
@@ -746,7 +744,11 @@ HTTPRepository::failure() const
             if (responseCode() == -1) {
                 code = HTTPRepository::REPO_ERROR_CANCELLED;
             }
-            
+
+			if (file) {
+				file->close();
+			}
+
             file.reset();
             if (pathInRepo.exists()) {
                 pathInRepo.remove();
@@ -818,7 +820,7 @@ HTTPRepository::failure() const
 
                     // dir index data has changed, so write to disk and update
                     // the hash accordingly
-                    sg_ofstream of(pathInRepo(), std::ios::trunc | std::ios::out);
+                    sg_ofstream of(pathInRepo(), std::ios::trunc | std::ios::out | std::ios::binary);
                     if (!of.is_open()) {
                         throw sg_io_exception("Failed to open directory index file for writing", pathInRepo());
                     }
@@ -997,11 +999,11 @@ HTTPRepository::failure() const
 
         SGPath cachePath = basePath;
         cachePath.append(".hashes");
-        sg_ofstream stream(cachePath, std::ios::out | std::ios::trunc);
+        sg_ofstream stream(cachePath, std::ios::out | std::ios::trunc | std::ios::binary);
         HashCache::const_iterator it;
         for (it = hashes.begin(); it != hashes.end(); ++it) {
-            stream << it->filePath << ":" << it->modTime << ":"
-            << it->lengthBytes << ":" << it->hashHex << "\n";
+            stream << it->filePath << "*" << it->modTime << "*"
+            << it->lengthBytes << "*" << it->hashHex << "\n";
         }
         stream.close();
         hashCacheDirty = false;
@@ -1025,7 +1027,7 @@ HTTPRepository::failure() const
             if( line.empty() || line[0] == '#' )
                 continue;
 
-            string_list tokens = simgear::strutils::split( line, ":" );
+			string_list tokens = simgear::strutils::split(line, "*");
             if( tokens.size() < 4 ) {
                 SG_LOG(SG_TERRASYNC, SG_WARN, "invalid entry in '" << cachePath << "': '" << line << "' (ignoring line)");
                 continue;
@@ -1084,7 +1086,7 @@ HTTPRepository::failure() const
 		} else {
 			// we encounter this code path when deleting an orphaned directory
 		}
-		
+
 		Dir dir(absPath);
 		bool result = dir.remove(true);
 
@@ -1152,7 +1154,7 @@ HTTPRepository::failure() const
             }
 
             SG_LOG(SG_TERRASYNC, SG_WARN, "failed to update repository:" << baseUrl
-                   << "\n\tchecksum failure for: " << relativePath 
+                   << "\n\tchecksum failure for: " << relativePath
                    << "\n\tthis typically indicates the remote repository is corrupt or was being updated during the sync");
         } else if (fileStatus == HTTPRepository::REPO_ERROR_CANCELLED) {
             // if we were cancelled, don't report or log

simgear/io/HTTPRequest.cxx

@@ -328,6 +328,16 @@ unsigned int Request::responseLength() const
   return _responseLength;
 }
 
+//------------------------------------------------------------------------------
+void Request::setSuccess(int code)
+{
+    _responseStatus = code;
+    _responseReason.clear();
+    if( !isComplete() ) {
+        setReadyState(DONE);
+    }
+}
+    
 //------------------------------------------------------------------------------
 void Request::setFailure(int code, const std::string& reason)
 {

simgear/io/HTTPRequest.hxx

@@ -224,7 +224,7 @@ protected:
     virtual void onAlways();
 
     void setFailure(int code, const std::string& reason);
-
+    void setSuccess(int code);
 private:
     friend class Client;
     friend class Connection;

simgear/io/sg_file.hxx

@@ -62,7 +62,7 @@ public:
     SGFile( int existingFd );
 
     /** Destructor */
-    ~SGFile();
+    virtual ~SGFile();
 
     // open the file based on specified direction
     bool open( const SGProtocolDir dir );

simgear/io/test_HTTP.cxx

@@ -273,7 +273,23 @@ public:
             d << "\r\n"; // final CRLF to terminate the headers
             d << contentStr;
             push(d.str().c_str());
-
+        } else if (path == "/test_redirect") {
+            string contentStr("<html>See <a href=\"wibble\">Here</a></html>");
+            stringstream d;
+            d << "HTTP/1.1 " << 302 << " " << "Found" << "\r\n";
+            d << "Location:" << " http://localhost:2000/was_redirected" << "\r\n";
+            d << "Content-Length:" << contentStr.size() << "\r\n";
+            d << "\r\n"; // final CRLF to terminate the headers
+            d << contentStr;
+            push(d.str().c_str());
+        } else if (path == "/was_redirected") {
+            string contentStr(BODY1);
+            stringstream d;
+            d << "HTTP/1.1 " << 200 << " " << reasonForCode(200) << "\r\n";
+            d << "Content-Length:" << contentStr.size() << "\r\n";
+            d << "\r\n"; // final CRLF to terminate the headers
+            d << contentStr;
+            push(d.str().c_str());
         } else {
           TestServerChannel::processRequestHeaders();
         }
@@ -773,6 +789,24 @@ cout << "testing proxy close" << endl;
         SG_CHECK_EQUAL(tr2->bodyData, string(BODY1));
         SG_CHECK_EQUAL(tr2->responseBytesReceived(), strlen(BODY1));
     }
+    
+    {
+        cout << "redirect test" << endl;
+        // redirect test
+        testServer.disconnectAll();
+        cl.clearAllConnections();
+        
+        TestRequest* tr = new TestRequest("http://localhost:2000/test_redirect");
+        HTTP::Request_ptr own(tr);
+        cl.makeRequest(tr);
+        
+        waitForComplete(&cl, tr);
+        SG_CHECK_EQUAL(tr->responseCode(), 200);
+        SG_CHECK_EQUAL(tr->responseReason(), string("OK"));
+        SG_CHECK_EQUAL(tr->responseLength(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->responseBytesReceived(), strlen(BODY1));
+        SG_CHECK_EQUAL(tr->bodyData, string(BODY1));
+    }
 
     cout << "all tests passed ok" << endl;
     return EXIT_SUCCESS;

simgear/io/test_HTTP.hxx

@@ -30,7 +30,6 @@ public:
 
     virtual ~TestServerChannel()
     {
-        std::cerr << "dtor test server channel" << std::endl;
     }
 
     virtual void collectIncomingData(const char* s, int n)
@@ -139,8 +138,8 @@ public:
 
     void sendErrorResponse(int code, bool close, std::string content)
     {
-        std::cerr << "sending error " << code << " for " << path << std::endl;
-        std::cerr << "\tcontent:" << content << std::endl;
+     //   std::cerr << "sending error " << code << " for " << path << std::endl;
+       // std::cerr << "\tcontent:" << content << std::endl;
 
         std::stringstream headerData;
         headerData << "HTTP/1.1 " << code << " " << reasonForCode(code) << "\r\n";
@@ -168,7 +167,6 @@ public:
 
     virtual void handleClose (void)
     {
-        std::cerr << "channel close" << std::endl;
         NetBufferChannel::handleClose();
     }
 

simgear/io/test_repository.cxx

@@ -309,7 +309,8 @@ std::string test_computeHashForPath(const SGPath& p)
         return std::string();
     sha1nfo info;
     sha1_init(&info);
-    char* buf = static_cast<char*>(alloca(1024 * 1024));
+    char* buf = static_cast<char*>(malloc(1024 * 1024));
+	assert(buf);
     size_t readLen;
 
     SGBinaryFile f(p);
@@ -319,6 +320,9 @@ std::string test_computeHashForPath(const SGPath& p)
         sha1_write(&info, buf, readLen);
     }
 
+	f.close();
+	free(buf);
+
     std::string hashBytes((char*) sha1_result(&info), HASH_LENGTH);
     return strutils::encodeHex(hashBytes);
 }
@@ -433,6 +437,34 @@ void testBasicClone(HTTP::Client* cl)
     std::cout << "Passed test: basic clone and update" << std::endl;
 }
 
+void testUpdateNoChanges(HTTP::Client* cl)
+{
+	std::unique_ptr<HTTPRepository> repo;
+	SGPath p(simgear::Dir::current().path());
+	p.append("http_repo_basic"); // same as before
+
+	global_repo->clearRequestCounts();
+
+	repo.reset(new HTTPRepository(p, cl));
+	repo->setBaseUrl("http://localhost:2000/repo");
+	repo->update();
+
+	waitForUpdateComplete(cl, repo.get());
+
+	verifyFileState(p, "fileA");
+	verifyFileState(p, "dirC/subdirA/subsubA/fileCAAA");
+
+	verifyRequestCount("dirA", 0);
+	verifyRequestCount("dirB", 0);
+	verifyRequestCount("dirB/subdirA", 0);
+	verifyRequestCount("dirB/subdirA/fileBAA", 0);
+	verifyRequestCount("dirC", 0);
+	verifyRequestCount("dirC/fileCA", 0);
+
+	std::cout << "Passed test:no changes update" << std::endl;
+
+}
+
 void testModifyLocalFiles(HTTP::Client* cl)
 {
     std::unique_ptr<HTTPRepository> repo;
@@ -469,10 +501,6 @@ void testModifyLocalFiles(HTTP::Client* cl)
     std::cout << "Passed test: identify and fix locally modified files" << std::endl;
 }
 
-void testNoChangesUpdate()
-{
-
-}
 
 void testMergeExistingFileWithoutDownload(HTTP::Client* cl)
 {
@@ -725,7 +753,7 @@ void testCopyInstalledChildren(HTTP::Client* cl)
     verifyRequestCount("dirJ/fileJC", 1);
     verifyRequestCount("dirJ/fileJD", 1);
 
-    std::cout << "Copy installed children" << std::endl;
+    std::cout << "passed Copy installed children" << std::endl;
 }
 
 int main(int argc, char* argv[])
@@ -751,6 +779,7 @@ int main(int argc, char* argv[])
     global_repo->defineFile("dirC/subdirA/subsubA/fileCAAA");
 
     testBasicClone(&cl);
+	testUpdateNoChanges(&cl);
 
     testModifyLocalFiles(&cl);
 

simgear/io/test_untar.cxx

@@ -11,6 +11,7 @@
 
 #include <simgear/misc/test_macros.hxx>
 #include <simgear/misc/sg_path.hxx>
+#include <simgear/misc/sg_dir.hxx>
 #include <simgear/io/sg_file.hxx>
 
 
@@ -31,7 +32,7 @@ void testTarGz()
     uint8_t* buf = (uint8_t*) alloca(8192);
     size_t bufSize = f.read((char*) buf, 8192);
 
-    SG_VERIFY(TarExtractor::isTarData(buf, bufSize));
+    SG_VERIFY(ArchiveExtractor::determineType(buf, bufSize) == ArchiveExtractor::TarData);
 
     f.close();
 }
@@ -44,18 +45,146 @@ void testPlainTar()
     SGBinaryFile f(p);
     f.open(SG_IO_IN);
 
-    uint8_t* buf = (uint8_t*) alloca(8192);
-    size_t bufSize = f.read((char*) buf, 8192);
+	uint8_t* buf = (uint8_t*)alloca(8192);
+	size_t bufSize = f.read((char*) buf, 8192);
 
-    SG_VERIFY(TarExtractor::isTarData(buf, bufSize));
+	SG_VERIFY(ArchiveExtractor::determineType(buf, bufSize) == ArchiveExtractor::TarData);
 
     f.close();
 }
 
+void testExtractStreamed()
+{
+	SGPath p = SGPath(SRC_DIR);
+	p.append("test.tar.gz");
+
+	SGBinaryFile f(p);
+	f.open(SG_IO_IN);
+
+	SGPath extractDir = simgear::Dir::current().path() / "test_extract_streamed";
+	simgear::Dir pd(extractDir);
+	pd.removeChildren();
+
+	ArchiveExtractor ex(extractDir);
+
+	uint8_t* buf = (uint8_t*) alloca(128);
+	while (!f.eof()) {
+		size_t bufSize = f.read((char*) buf, 128);
+		ex.extractBytes(buf, bufSize);
+	}
+
+	ex.flush();
+	SG_VERIFY(ex.isAtEndOfArchive());
+	SG_VERIFY(ex.hasError() == false);
+
+	SG_VERIFY((extractDir / "testDir/hello.c").exists());
+	SG_VERIFY((extractDir / "testDir/foo.txt").exists());
+}
+
+void testExtractLocalFile()
+{
+
+}
+
+void testFilterTar()
+{
+    SGPath p = SGPath(SRC_DIR);
+    p.append("badTar.tgz");
+    
+    SGBinaryFile f(p);
+    f.open(SG_IO_IN);
+    
+    SGPath extractDir = simgear::Dir::current().path() / "test_filter_tar";
+    simgear::Dir pd(extractDir);
+    pd.removeChildren();
+    
+    ArchiveExtractor ex(extractDir);
+    
+    uint8_t* buf = (uint8_t*) alloca(128);
+    while (!f.eof()) {
+        size_t bufSize = f.read((char*) buf, 128);
+        ex.extractBytes(buf, bufSize);
+    }
+    
+    ex.flush();
+    SG_VERIFY(ex.isAtEndOfArchive());
+    SG_VERIFY(ex.hasError() == false);
+    
+    SG_VERIFY((extractDir / "tarWithBadContent/regular-file.txt").exists());
+    SG_VERIFY(!(extractDir / "tarWithBadContent/symbolic-linked.png").exists());
+    SG_VERIFY((extractDir / "tarWithBadContent/screenshot.png").exists());
+    SG_VERIFY((extractDir / "tarWithBadContent/dirOne/subDirA").exists());
+    SG_VERIFY(!(extractDir / "tarWithBadContent/dirOne/subDirA/linked.txt").exists());
+
+
+}
+
+void testExtractZip()
+{
+	SGPath p = SGPath(SRC_DIR);
+	p.append("zippy.zip");
+
+	SGBinaryFile f(p);
+	f.open(SG_IO_IN);
+
+	SGPath extractDir = simgear::Dir::current().path() / "test_extract_zip";
+	simgear::Dir pd(extractDir);
+	pd.removeChildren();
+
+	ArchiveExtractor ex(extractDir);
+
+	uint8_t* buf = (uint8_t*)alloca(128);
+	while (!f.eof()) {
+		size_t bufSize = f.read((char*)buf, 128);
+		ex.extractBytes(buf, bufSize);
+	}
+
+	ex.flush();
+	SG_VERIFY(ex.isAtEndOfArchive());
+	SG_VERIFY(ex.hasError() == false);
+
+	SG_VERIFY((extractDir / "zippy/dirA/hello.c").exists());
+	SG_VERIFY((extractDir / "zippy/bar.xml").exists());
+	SG_VERIFY((extractDir / "zippy/long-named.json").exists());
+}
+
+void testPAXAttributes()
+{
+    SGPath p = SGPath(SRC_DIR);
+    p.append("pax-extended.tar");
+    
+    SGBinaryFile f(p);
+    f.open(SG_IO_IN);
+    
+    SGPath extractDir = simgear::Dir::current().path() / "test_pax_extended";
+    simgear::Dir pd(extractDir);
+    pd.removeChildren();
+    
+    ArchiveExtractor ex(extractDir);
+    
+    uint8_t* buf = (uint8_t*) alloca(128);
+    while (!f.eof()) {
+        size_t bufSize = f.read((char*) buf, 128);
+        ex.extractBytes(buf, bufSize);
+    }
+    
+    ex.flush();
+    SG_VERIFY(ex.isAtEndOfArchive());
+    SG_VERIFY(ex.hasError() == false);
+
+}
+
 int main(int ac, char ** av)
 {
     testTarGz();
     testPlainTar();
-
+    testFilterTar();
+	testExtractStreamed();
+	testExtractZip();
+   
+    // disabled to avoiding checking in large PAX archive
+    // testPAXAttributes();
+    
+	std::cout << "all tests passed" << std::endl;
     return 0;
 }

simgear/io/untar.cxx

@@ -31,12 +31,80 @@
 #include <simgear/sg_inlines.h>
 #include <simgear/io/sg_file.hxx>
 #include <simgear/misc/sg_dir.hxx>
-
+#include <simgear/io/iostreams/sgstream.hxx>
 #include <simgear/debug/logstream.hxx>
+#include <simgear/package/unzip.h>
+#include <simgear/structure/exception.hxx>
 
 namespace simgear
 {
 
+	class ArchiveExtractorPrivate
+	{
+	public:
+		ArchiveExtractorPrivate(ArchiveExtractor* o) :
+			outer(o)
+		{
+			assert(outer);
+		}
+
+		typedef enum {
+			INVALID = 0,
+			READING_HEADER,
+			READING_FILE,
+			READING_PADDING,
+            READING_PAX_GLOBAL_ATTRIBUTES,
+            READING_PAX_FILE_ATTRIBUTES,
+			PRE_END_OF_ARCHVE,
+			END_OF_ARCHIVE,
+			ERROR_STATE, ///< states above this are error conditions
+			BAD_ARCHIVE,
+			BAD_DATA,
+			FILTER_STOPPED
+		} State;
+
+		State state = INVALID;
+		ArchiveExtractor* outer = nullptr;
+
+		virtual void extractBytes(const uint8_t* bytes, size_t count) = 0;
+
+		virtual void flush() = 0;
+
+		SGPath extractRootPath()
+		{
+			return outer->_rootPath;
+		}
+
+		ArchiveExtractor::PathResult filterPath(std::string& pathToExtract)
+		{
+			return outer->filterPath(pathToExtract);
+		}
+
+
+		bool isSafePath(const std::string& p) const
+		{
+			if (p.empty()) {
+				return false;
+			}
+
+			// reject absolute paths
+			if (p.at(0) == '/') {
+				return false;
+			}
+
+			// reject paths containing '..'
+			size_t doubleDot = p.find("..");
+			if (doubleDot != std::string::npos) {
+				return false;
+			}
+
+			// on POSIX could use realpath to sanity check
+			return true;
+		}
+	};
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 const int ZLIB_DECOMPRESS_BUFFER_SIZE = 32 * 1024;
 const int ZLIB_INFLATE_WINDOW_BITS = MAX_WBITS;
 const int ZLIB_DECODE_GZIP_HEADER = 16;
@@ -81,24 +149,14 @@ typedef struct
 #define FIFOTYPE '6'            /* FIFO special */
 #define CONTTYPE '7'            /* reserved */
 
-class TarExtractorPrivate
+	const char PAX_GLOBAL_HEADER = 'g';
+	const char PAX_FILE_ATTRIBUTES = 'x';
+
+
+class TarExtractorPrivate : public ArchiveExtractorPrivate
 {
 public:
-    typedef enum {
-        INVALID = 0,
-        READING_HEADER,
-        READING_FILE,
-        READING_PADDING,
-        PRE_END_OF_ARCHVE,
-        END_OF_ARCHIVE,
-        ERROR_STATE, ///< states above this are error conditions
-        BAD_ARCHIVE,
-        BAD_DATA,
-        FILTER_STOPPED
-    } State;
-
-    SGPath path;
-    State state;
+    
     union {
         UstarHeaderBlock header;
         uint8_t headerBytes[TAR_HEADER_BLOCK_SIZE];
@@ -109,17 +167,22 @@ public:
     size_t currentFileSize;
     z_stream zlibStream;
     uint8_t* zlibOutput;
-    bool haveInitedZLib;
-    bool uncompressedData; // set if reading a plain .tar (not tar.gz)
+    bool haveInitedZLib = false;
+    bool uncompressedData = false; // set if reading a plain .tar (not tar.gz)
     uint8_t* headerPtr;
-    TarExtractor* outer;
     bool skipCurrentEntry = false;
+    std::string paxAttributes;
+    std::string paxPathName;
     
-    TarExtractorPrivate(TarExtractor* o) :
-        haveInitedZLib(false),
-        uncompressedData(false),
-        outer(o)
+    TarExtractorPrivate(ArchiveExtractor* o) :
+		ArchiveExtractorPrivate(o)
     {
+		memset(&zlibStream, 0, sizeof(z_stream));
+		zlibOutput = (unsigned char*)malloc(ZLIB_DECOMPRESS_BUFFER_SIZE);
+		zlibStream.zalloc = Z_NULL;
+		zlibStream.zfree = Z_NULL;
+		zlibStream.avail_out = ZLIB_DECOMPRESS_BUFFER_SIZE;
+		zlibStream.next_out = zlibOutput;
     }
 
     ~TarExtractorPrivate()
@@ -127,6 +190,17 @@ public:
         free(zlibOutput);
     }
 
+    void readPaddingIfRequired()
+    {
+        size_t pad = currentFileSize % TAR_HEADER_BLOCK_SIZE;
+        if (pad) {
+            bytesRemaining = TAR_HEADER_BLOCK_SIZE - pad;
+            setState(READING_PADDING);
+        } else {
+            setState(READING_HEADER);
+        }
+    }
+    
     void checkEndOfState()
     {
         if (bytesRemaining > 0) {
@@ -138,13 +212,7 @@ public:
                 currentFile->close();
                 currentFile.reset();
             }
-            size_t pad = currentFileSize % TAR_HEADER_BLOCK_SIZE;
-            if (pad) {
-                bytesRemaining = TAR_HEADER_BLOCK_SIZE - pad;
-                setState(READING_PADDING);
-            } else {
-                setState(READING_HEADER);
-            }
+            readPaddingIfRequired();
         } else if (state == READING_HEADER) {
             processHeader();
         } else if (state == PRE_END_OF_ARCHVE) {
@@ -153,6 +221,12 @@ public:
             } else {
                 // what does the spec say here?
             }
+        } else if (state == READING_PAX_GLOBAL_ATTRIBUTES) {
+            parsePAXAttributes(true);
+            readPaddingIfRequired();
+        } else if (state == READING_PAX_FILE_ATTRIBUTES) {
+            parsePAXAttributes(false);
+            readPaddingIfRequired();
         } else if (state == READING_PADDING) {
             setState(READING_HEADER);
         }
@@ -168,6 +242,77 @@ public:
         state = newState;
     }
 
+	void extractBytes(const uint8_t* bytes, size_t count) override
+	{
+		zlibStream.next_in = (uint8_t*) bytes;
+		zlibStream.avail_in = count;
+
+		if (!haveInitedZLib) {
+			// now we have data, see if we're dealing with GZ-compressed data or not
+			if ((bytes[0] == 0x1f) && (bytes[1] == 0x8b)) {
+				// GZIP identification bytes
+				if (inflateInit2(&zlibStream, ZLIB_INFLATE_WINDOW_BITS | ZLIB_DECODE_GZIP_HEADER) != Z_OK) {
+					SG_LOG(SG_IO, SG_WARN, "inflateInit2 failed");
+					state = TarExtractorPrivate::BAD_DATA;
+					return;
+				}
+			} else {
+				UstarHeaderBlock* header = (UstarHeaderBlock*)bytes;
+				if (strncmp(header->magic, TMAGIC, TMAGLEN) != 0) {
+					SG_LOG(SG_IO, SG_WARN, "didn't find tar magic in header");
+					state = TarExtractorPrivate::BAD_DATA;
+					return;
+				}
+
+				uncompressedData = true;
+			}
+
+			haveInitedZLib = true;
+			setState(TarExtractorPrivate::READING_HEADER);
+		} // of init on first-bytes case
+
+		if (uncompressedData) {
+			processBytes((const char*) bytes, count);
+		} else {
+			size_t writtenSize;
+			// loop, running zlib() inflate and sending output bytes to
+			// our request body handler. Keep calling inflate until no bytes are
+			// written, and ZLIB has consumed all available input
+			do {
+				zlibStream.next_out = zlibOutput;
+				zlibStream.avail_out = ZLIB_DECOMPRESS_BUFFER_SIZE;
+				int result = inflate(&zlibStream, Z_NO_FLUSH);
+				if (result == Z_OK || result == Z_STREAM_END) {
+					// nothing to do
+
+				}
+				else if (result == Z_BUF_ERROR) {
+					// transient error, fall through
+				}
+				else {
+					//  _error = result;
+					SG_LOG(SG_IO, SG_WARN, "Permanent ZLib error:" << zlibStream.msg);
+					state = TarExtractorPrivate::BAD_DATA;
+					return;
+				}
+
+				writtenSize = ZLIB_DECOMPRESS_BUFFER_SIZE - zlibStream.avail_out;
+				if (writtenSize > 0) {
+					processBytes((const char*) zlibOutput, writtenSize);
+				}
+
+				if (result == Z_STREAM_END) {
+					break;
+				}
+			} while ((zlibStream.avail_in > 0) || (writtenSize > 0));
+		} // of Zlib-compressed data
+	}
+
+	void flush() override
+	{
+		// no-op for tar files, we process everything greedily
+	}
+
     void processHeader()
     {
         if (headerIsAllZeros()) {
@@ -180,28 +325,32 @@ public:
         }
 
         if (strncmp(header.magic, TMAGIC, TMAGLEN) != 0) {
-            SG_LOG(SG_IO, SG_WARN, "magic is wrong");
+            SG_LOG(SG_IO, SG_WARN, "Untar: magic is wrong");
             state = BAD_ARCHIVE;
             return;
         }
 
         skipCurrentEntry = false;
         std::string tarPath = std::string(header.prefix) + std::string(header.fileName);
-
+        if (!paxPathName.empty()) {
+            tarPath = paxPathName;
+            paxPathName.clear(); // clear for next file
+        }
+        
         if (!isSafePath(tarPath)) {
             SG_LOG(SG_IO, SG_WARN, "bad tar path:" << tarPath);
             skipCurrentEntry = true;
         }
 
-        auto result = outer->filterPath(tarPath);
-        if (result == TarExtractor::Stop) {
+        auto result = filterPath(tarPath);
+        if (result == ArchiveExtractor::Stop) {
             setState(FILTER_STOPPED);
             return;
-        } else if (result == TarExtractor::Skipped) {
+        } else if (result == ArchiveExtractor::Skipped) {
             skipCurrentEntry = true;
         }
         
-        SGPath p = path / tarPath;
+        SGPath p = extractRootPath() / tarPath;
         if (header.typeflag == DIRTYPE) {
             if (!skipCurrentEntry) {
                 Dir dir(p);
@@ -216,6 +365,20 @@ public:
                 currentFile->open(SG_IO_OUT);
             }
             setState(READING_FILE);
+        } else if (header.typeflag == PAX_GLOBAL_HEADER) {
+            setState(READING_PAX_GLOBAL_ATTRIBUTES);
+            currentFileSize = ::strtol(header.size, NULL, 8);
+            bytesRemaining = currentFileSize;
+            paxAttributes.clear();
+        } else if (header.typeflag == PAX_FILE_ATTRIBUTES) {
+            setState(READING_PAX_FILE_ATTRIBUTES);
+            currentFileSize = ::strtol(header.size, NULL, 8);
+            bytesRemaining = currentFileSize;
+            paxAttributes.clear();
+        } else if ((header.typeflag == SYMTYPE) || (header.typeflag == LNKTYPE)) {
+            SG_LOG(SG_IO, SG_WARN, "Tarball contains a link or symlink, will be skipped:" << tarPath);
+            skipCurrentEntry = true;
+            setState(READING_HEADER);
         } else {
             SG_LOG(SG_IO, SG_WARN, "Unsupported tar file type:" << header.typeflag);
             state = BAD_ARCHIVE;
@@ -240,6 +403,9 @@ public:
             headerPtr += curBytes;
         } else if (state == READING_PADDING) {
             bytesRemaining -= curBytes;
+        } else if ((state == READING_PAX_FILE_ATTRIBUTES) || (state == READING_PAX_GLOBAL_ATTRIBUTES)) {
+            bytesRemaining -= curBytes;
+            paxAttributes.append(bytes, curBytes);
         }
 
         checkEndOfState();
@@ -261,132 +427,283 @@ public:
         return true;
     }
 
-    bool isSafePath(const std::string& p) const
+    // https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.3.0/com.ibm.zos.v2r3.bpxa500/paxex.htm#paxex
+    void parsePAXAttributes(bool areGlobal)
     {
-        if (p.empty()) {
-            return false;
+        auto lineStart = 0;
+        for (;;) {
+            auto firstSpace = paxAttributes.find(' ', lineStart);
+            auto firstEq = paxAttributes.find('=', lineStart);
+            if ((firstEq == std::string::npos) || (firstSpace == std::string::npos)) {
+                SG_LOG(SG_IO, SG_WARN, "Malfroemd PAX attributes in tarfile");
+                break;
+            }
+            
+            uint32_t lengthBytes = std::stoul(paxAttributes.substr(lineStart, firstSpace));
+            uint32_t dataBytes = lengthBytes - (firstEq + 1);
+            std::string name = paxAttributes.substr(firstSpace+1, firstEq - (firstSpace + 1));
+            
+            // dataBytes - 1 here to trim off the trailing newline
+            std::string data = paxAttributes.substr(firstEq+1, dataBytes - 1);
+            
+            processPAXAttribute(areGlobal, name, data);
+            
+            lineStart += lengthBytes;
         }
-
-        // reject absolute paths
-        if (p.at(0) == '/') {
-            return false;
+    }
+    
+    void processPAXAttribute(bool isGlobalAttr, const std::string& attrName, const std::string& data)
+    {
+        if (!isGlobalAttr && (attrName == "path")) {
+            // data is UTF-8 encoded path name
+            paxPathName = data;
         }
-
-        // reject paths containing '..'
-        size_t doubleDot = p.find("..");
-        if (doubleDot != std::string::npos) {
-            return false;
-        }
-
-        // on POSIX could use realpath to sanity check
-        return true;
     }
 };
 
-TarExtractor::TarExtractor(const SGPath& rootPath) :
-    d(new TarExtractorPrivate(this))
-{
+///////////////////////////////////////////////////////////////////////////////
 
-    d->path = rootPath;
-    d->state = TarExtractorPrivate::INVALID;
-
-    memset(&d->zlibStream, 0, sizeof(z_stream));
-    d->zlibOutput = (unsigned char*) malloc(ZLIB_DECOMPRESS_BUFFER_SIZE);
-    d->zlibStream.zalloc = Z_NULL;
-    d->zlibStream.zfree = Z_NULL;
-
-    d->zlibStream.avail_out = ZLIB_DECOMPRESS_BUFFER_SIZE;
-    d->zlibStream.next_out = d->zlibOutput;
+extern "C" {
+	void fill_memory_filefunc(zlib_filefunc_def*);
 }
 
-TarExtractor::~TarExtractor()
+class ZipExtractorPrivate : public ArchiveExtractorPrivate
+{
+public:
+	std::string m_buffer;
+
+	ZipExtractorPrivate(ArchiveExtractor* outer) :
+		ArchiveExtractorPrivate(outer)
+	{
+
+	}
+
+	~ZipExtractorPrivate()
+	{
+
+	}
+
+	void extractBytes(const uint8_t* bytes, size_t count) override
+	{
+		// becuase the .zip central directory is at the end of the file,
+		// we have no choice but to simply buffer bytes here until flush()
+		// is called
+		m_buffer.append((const char*) bytes, count);
+	}
+
+	void flush() override
+	{
+		zlib_filefunc_def memoryAccessFuncs;
+		fill_memory_filefunc(&memoryAccessFuncs);
+
+		char bufferName[128];
+#if defined(SG_WINDOWS)
+        ::snprintf(bufferName, 128, "%p+%llx", m_buffer.data(), m_buffer.size());
+#else
+		::snprintf(bufferName, 128, "%p+%lx", m_buffer.data(), m_buffer.size());
+#endif
+		unzFile zip = unzOpen2(bufferName, &memoryAccessFuncs);
+
+		const size_t BUFFER_SIZE = 32 * 1024;
+		void* buf = malloc(BUFFER_SIZE);
+
+		try {
+			int result = unzGoToFirstFile(zip);
+			if (result != UNZ_OK) {
+				throw sg_exception("failed to go to first file in archive");
+			}
+
+			while (true) {
+				extractCurrentFile(zip, (char*)buf, BUFFER_SIZE);
+				if (state == FILTER_STOPPED) {
+					break;
+				}
+
+				result = unzGoToNextFile(zip);
+				if (result == UNZ_END_OF_LIST_OF_FILE) {
+					break;
+				}
+				else if (result != UNZ_OK) {
+					throw sg_io_exception("failed to go to next file in the archive");
+				}
+			}
+			state = END_OF_ARCHIVE;
+		}
+		catch (sg_exception&) {
+			state = BAD_ARCHIVE;
+		}
+
+		free(buf);
+		unzClose(zip);
+	}
+
+	void extractCurrentFile(unzFile zip, char* buffer, size_t bufferSize)
+	{
+		unz_file_info fileInfo;
+		unzGetCurrentFileInfo(zip, &fileInfo,
+			buffer, bufferSize,
+			NULL, 0,  /* extra field */
+			NULL, 0 /* comment field */);
+
+		std::string name(buffer);
+		if (!isSafePath(name)) {
+			throw sg_format_exception("Bad zip path", name);
+		}
+
+		auto filterResult = filterPath(name);
+		if (filterResult == ArchiveExtractor::Stop) {
+			state = FILTER_STOPPED;
+			return;
+		}
+		else if (filterResult == ArchiveExtractor::Skipped) {
+			return;
+		}
+
+		if (fileInfo.uncompressed_size == 0) {
+			// assume it's a directory for now
+			// since we create parent directories when extracting
+			// a path, we're done here
+			return;
+		}
+
+		int result = unzOpenCurrentFile(zip);
+		if (result != UNZ_OK) {
+			throw sg_io_exception("opening current zip file failed", sg_location(name));
+		}
+
+		sg_ofstream outFile;
+		bool eof = false;
+		SGPath path = extractRootPath() / name;
+
+		// create enclosing directory heirarchy as required
+		Dir parentDir(path.dir());
+		if (!parentDir.exists()) {
+			bool ok = parentDir.create(0755);
+			if (!ok) {
+				throw sg_io_exception("failed to create directory heirarchy for extraction", path);
+			}
+		}
+
+		outFile.open(path, std::ios::binary | std::ios::trunc | std::ios::out);
+		if (outFile.fail()) {
+			throw sg_io_exception("failed to open output file for writing", path);
+		}
+
+		while (!eof) {
+			int bytes = unzReadCurrentFile(zip, buffer, bufferSize);
+			if (bytes < 0) {
+				throw sg_io_exception("unzip failure reading curent archive", sg_location(name));
+			}
+			else if (bytes == 0) {
+				eof = true;
+			}
+			else {
+				outFile.write(buffer, bytes);
+			}
+		}
+
+		outFile.close();
+		unzCloseCurrentFile(zip);
+	}
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+ArchiveExtractor::ArchiveExtractor(const SGPath& rootPath) :
+	_rootPath(rootPath)
+{
+}
+
+ArchiveExtractor::~ArchiveExtractor()
 {
 
 }
 
-void TarExtractor::extractBytes(const char* bytes, size_t count)
+void ArchiveExtractor::extractBytes(const uint8_t* bytes, size_t count)
 {
-    if (d->state >= TarExtractorPrivate::ERROR_STATE) {
+	if (!d) {
+		_prebuffer.append((char*) bytes, count);
+		auto r = determineType((uint8_t*) _prebuffer.data(), _prebuffer.size());
+		if (r == InsufficientData) {
+			return;
+		}
+
+		if (r == TarData) {
+			d.reset(new TarExtractorPrivate(this));
+		}
+		else if (r == ZipData) {
+			d.reset(new ZipExtractorPrivate(this));
+		}
+		else {
+			SG_LOG(SG_IO, SG_ALERT, "Invcalid archive type");
+			_invalidDataType = true;
+			return;
+		}
+
+		// if hit here, we created the extractor. Feed the prefbuffer
+		// bytes through it
+		d->extractBytes((uint8_t*) _prebuffer.data(), _prebuffer.size());
+		_prebuffer.clear();
+		return;
+	}
+
+    if (d->state >= ArchiveExtractorPrivate::ERROR_STATE) {
         return;
     }
 
-    d->zlibStream.next_in = (uint8_t*) bytes;
-    d->zlibStream.avail_in = count;
-
-    if (!d->haveInitedZLib) {
-        // now we have data, see if we're dealing with GZ-compressed data or not
-        uint8_t* ubytes = (uint8_t*) bytes;
-        if ((ubytes[0] == 0x1f) && (ubytes[1] == 0x8b)) {
-            // GZIP identification bytes
-            if (inflateInit2(&d->zlibStream, ZLIB_INFLATE_WINDOW_BITS | ZLIB_DECODE_GZIP_HEADER) != Z_OK) {
-                SG_LOG(SG_IO, SG_WARN, "inflateInit2 failed");
-                d->state = TarExtractorPrivate::BAD_DATA;
-                return;
-            }
-        } else {
-            UstarHeaderBlock* header = (UstarHeaderBlock*) bytes;
-            if (strncmp(header->magic, TMAGIC, TMAGLEN) != 0) {
-                SG_LOG(SG_IO, SG_WARN, "didn't find tar magic in header");
-                d->state = TarExtractorPrivate::BAD_DATA;
-                return;
-            }
-
-            d->uncompressedData = true;
-        }
-
-        d->haveInitedZLib = true;
-        d->setState(TarExtractorPrivate::READING_HEADER);
-    } // of init on first-bytes case
-
-    if (d->uncompressedData) {
-        d->processBytes(bytes, count);
-    } else {
-        size_t writtenSize;
-        // loop, running zlib() inflate and sending output bytes to
-        // our request body handler. Keep calling inflate until no bytes are
-        // written, and ZLIB has consumed all available input
-        do {
-            d->zlibStream.next_out = d->zlibOutput;
-            d->zlibStream.avail_out = ZLIB_DECOMPRESS_BUFFER_SIZE;
-            int result = inflate(&d->zlibStream, Z_NO_FLUSH);
-            if (result == Z_OK || result == Z_STREAM_END) {
-                // nothing to do
-
-            } else if (result == Z_BUF_ERROR) {
-                // transient error, fall through
-            } else {
-                //  _error = result;
-                SG_LOG(SG_IO, SG_WARN, "Permanent ZLib error:" << d->zlibStream.msg);
-                d->state = TarExtractorPrivate::BAD_DATA;
-                return;
-            }
-
-            writtenSize = ZLIB_DECOMPRESS_BUFFER_SIZE - d->zlibStream.avail_out;
-            if (writtenSize > 0) {
-                d->processBytes((const char*) d->zlibOutput, writtenSize);
-            }
-
-            if (result == Z_STREAM_END) {
-                break;
-            }
-        } while ((d->zlibStream.avail_in > 0) || (writtenSize > 0));
-    } // of Zlib-compressed data
+	d->extractBytes(bytes, count);
 }
 
-bool TarExtractor::isAtEndOfArchive() const
+void ArchiveExtractor::flush()
 {
-    return (d->state == TarExtractorPrivate::END_OF_ARCHIVE);
+	if (!d)
+		return;
+
+	d->flush();
 }
 
-bool TarExtractor::hasError() const
+bool ArchiveExtractor::isAtEndOfArchive() const
 {
-    return (d->state >= TarExtractorPrivate::ERROR_STATE);
+	if (!d)
+		return false;
+
+    return (d->state == ArchiveExtractorPrivate::END_OF_ARCHIVE);
 }
 
-bool TarExtractor::isTarData(const uint8_t* bytes, size_t count)
+bool ArchiveExtractor::hasError() const
+{
+	if (_invalidDataType)
+		return true;
+
+	if (!d)
+		return false;
+
+    return (d->state >= ArchiveExtractorPrivate::ERROR_STATE);
+}
+
+ArchiveExtractor::DetermineResult ArchiveExtractor::determineType(const uint8_t* bytes, size_t count)
+{
+	// check for ZIP
+	if (count < 4) {
+		return InsufficientData;
+	}
+
+	if (memcmp(bytes, "PK\x03\x04", 4) == 0) {
+		return ZipData;
+	}
+
+	auto r = isTarData(bytes, count);
+	if ((r == TarData) || (r == InsufficientData))
+		return r;
+
+	return Invalid;
+}
+
+
+ArchiveExtractor::DetermineResult ArchiveExtractor::isTarData(const uint8_t* bytes, size_t count)
 {
     if (count < 2) {
-        return false;
+        return InsufficientData;
     }
 
     UstarHeaderBlock* header = 0;
@@ -404,21 +721,20 @@ bool TarExtractor::isTarData(const uint8_t* bytes, size_t count)
 
         if (inflateInit2(&z, ZLIB_INFLATE_WINDOW_BITS | ZLIB_DECODE_GZIP_HEADER) != Z_OK) {
             inflateEnd(&z);
-            return false;
+            return Invalid;
         }
 
         int result = inflate(&z, Z_SYNC_FLUSH);
         if (result != Z_OK) {
             SG_LOG(SG_IO, SG_WARN, "inflate failed:" << result);
             inflateEnd(&z);
-            return false; // not tar data
+            return Invalid; // not tar data
         }
 
         size_t written = 4096 - z.avail_out;
         if (written < TAR_HEADER_BLOCK_SIZE) {
-            SG_LOG(SG_IO, SG_WARN, "insufficient data for header");
             inflateEnd(&z);
-            return false;
+            return InsufficientData;
         }
 
         header = reinterpret_cast<UstarHeaderBlock*>(zlibOutput);
@@ -426,22 +742,25 @@ bool TarExtractor::isTarData(const uint8_t* bytes, size_t count)
     } else {
         // uncompressed tar
         if (count < TAR_HEADER_BLOCK_SIZE) {
-            SG_LOG(SG_IO, SG_WARN, "insufficient data for header");
-            return false;
+            return InsufficientData;
         }
 
         header = (UstarHeaderBlock*) bytes;
     }
 
     if (strncmp(header->magic, TMAGIC, TMAGLEN) != 0) {
-        SG_LOG(SG_IO, SG_WARN, "not a tar file");
-        return false;
+        return Invalid;
     }
 
-    return true;
+    return TarData;
 }
 
-auto TarExtractor::filterPath(std::string& pathToExtract)
+void ArchiveExtractor::extractLocalFile(const SGPath& archiveFile)
+{
+
+}
+
+auto ArchiveExtractor::filterPath(std::string& pathToExtract)
   -> PathResult
 {
     SG_UNUSED(pathToExtract);

simgear/io/untar.hxx

@@ -21,40 +21,68 @@
 #include <memory>
 
 #include <cstdlib>
-#include <stdint.h> // for uint8_t
+#include <cstdint>
+
 #include <simgear/misc/sg_path.hxx>
 
 namespace simgear
 {
 
-class TarExtractorPrivate;
+class ArchiveExtractorPrivate;
 
-class TarExtractor
+class ArchiveExtractor
 {
 public:
-    TarExtractor(const SGPath& rootPath);
-	~TarExtractor();
+	ArchiveExtractor(const SGPath& rootPath);
+	~ArchiveExtractor();
 
-    static bool isTarData(const uint8_t* bytes, size_t count);
+	enum DetermineResult
+	{
+		Invalid,
+		InsufficientData,
+		TarData,
+		ZipData
+	};
 
-    void extractBytes(const char* bytes, size_t count);
+	static DetermineResult determineType(const uint8_t* bytes, size_t count);
+
+	/**
+	 * @brief API to extract a local zip or tar.gz 
+	 */
+	void extractLocalFile(const SGPath& archiveFile);
+
+	/**
+	 * @brief API to extract from memory - this can be called multiple
+	 * times for streamking from a network socket etc
+	 */
+    void extractBytes(const uint8_t* bytes, size_t count);
+
+	void flush();
 
     bool isAtEndOfArchive() const;
 
     bool hasError() const;
 
+	enum PathResult {
+		Accepted,
+		Skipped,
+		Modified,
+		Stop
+	};
+
 protected:
-    enum PathResult {
-      Accepted,
-      Skipped,
-      Modified,
-      Stop
-    };
+
 
     virtual PathResult filterPath(std::string& pathToExtract);
 private:
-    friend class TarExtractorPrivate;
-    std::unique_ptr<TarExtractorPrivate> d;
+	static DetermineResult isTarData(const uint8_t* bytes, size_t count);
+
+    friend class ArchiveExtractorPrivate;
+    std::unique_ptr<ArchiveExtractorPrivate> d;
+
+	SGPath _rootPath;
+	std::string _prebuffer; // store bytes before type is determined
+	bool _invalidDataType = false;
 };
 
 } // of namespace simgear

simgear/math/SGMatrix.hxx

@@ -142,10 +142,10 @@ public:
   T (&sg(void))[4][4]
   { return _data.ptr(); }
   /// Readonly raw storage interface
-  const simd4x4_t<T,4> (&simd4x4(void) const)
+  const simd4x4_t<T,4> &simd4x4(void) const
   { return _data; }
   /// Readonly raw storage interface
-  simd4x4_t<T,4> (&simd4x4(void))
+  simd4x4_t<T,4> &simd4x4(void)
   { return _data; }
 
 

simgear/math/SGVec2.hxx

@@ -87,10 +87,10 @@ public:
   /// Access raw data
   T (&data(void))[2]
   { return _data.ptr(); }
-  const simd4_t<T,2> (&simd2(void) const)
+  const simd4_t<T,2> &simd2(void) const
   { return _data; }
   /// Readonly raw storage interface
-  simd4_t<T,2> (&simd2(void))
+  simd4_t<T,2> &simd2(void)
   { return _data; }
 
   /// Inplace addition

simgear/math/SGVec3.hxx

@@ -106,10 +106,10 @@ public:
   T (&data(void))[3]
   { return _data.ptr(); }
   /// Readonly raw storage interface
-  const simd4_t<T,3> (&simd3(void) const)
+  const simd4_t<T,3> &simd3(void) const
   { return _data; }
   /// Readonly raw storage interface
-  simd4_t<T,3> (&simd3(void))
+  simd4_t<T,3> &simd3(void)
   { return _data; }
 
   /// Inplace addition

simgear/math/SGVec4.hxx

@@ -99,10 +99,10 @@ public:
   T (&data(void))[4]
   { return _data.ptr(); }
   /// Readonly raw storage interface
-  const simd4_t<T,4> (&simd4(void) const)
+  const simd4_t<T,4> &simd4(void) const
   { return _data; }
   /// Readonly raw storage interface
-  simd4_t<T,4> (&simd4(void))
+  simd4_t<T,4> &simd4(void)
   { return _data; }
 
   /// Inplace addition

simgear/math/simd.hxx

@@ -309,7 +309,7 @@ inline simd4_t<T,N> operator*(simd4_t<T,N> v, T f) {
     return v;
 }
 
-#ifdef ENABLE_SIMD
+#ifdef ENABLE_SIMD_CODE
 
 # ifdef __SSE__
 namespace simd4
@@ -352,10 +352,10 @@ public:
     simd4_t(const simd4_t<float,2>& v) { simd4 = v.v4(); }
     simd4_t(const __m128& v) { simd4 = v; }
 
-    inline const __m128 (&v4(void) const) {
+    inline const __m128 &v4(void) const {
         return simd4;
     }
-    inline __m128 (&v4(void)) {
+    inline __m128 &v4(void) {
         return simd4;
     }
 
@@ -1120,11 +1120,11 @@ public:
     simd4_t(const simd4_t<int,2>& v) { simd4 = v.v4(); }
     simd4_t(const __m128i& v) { simd4 = v; }
 
-    inline __m128i (&v4(void)) {
+    inline __m128i &v4(void) {
         return simd4;
     }
 
-    inline const __m128i (&v4(void) const) {
+    inline const __m128i &v4(void) const {
         return simd4;
     }
 
@@ -1305,7 +1305,7 @@ inline simd4_t<int,N> max(simd4_t<int,N> v1, const simd4_t<int,N>& v2) {
 
 # endif
 
-#endif /* ENABLE_SIMD */
+#endif /* ENABLE_SIMD_CODE */
 
 #endif /* __SIMD_H__ */
 

simgear/math/simd4x4.hxx

@@ -289,7 +289,7 @@ inline simd4x4_t<T,N> operator*(const simd4x4_t<T,N>& m1, const simd4x4_t<T,N>&
 }
 
 
-#ifdef ENABLE_SIMD
+#ifdef ENABLE_SIMD_CODE
 
 # ifdef __SSE__
 template<>
@@ -1191,7 +1191,7 @@ inline simd4_t<int,3> transform<int>(const simd4x4_t<int,4>& m, const simd4_t<in
 } /* namespace simd4x */
 # endif
 
-#endif /* ENABLE_SIMD */
+#endif /* ENABLE_SIMD_CODE */
 
 #endif /* __SIMD4X4_H__ */
 

simgear/misc/ResourceManager.cxx

@@ -17,14 +17,23 @@
 //
 // $Id$
 
+#include <assert.h>
+#include <algorithm>
+
 #include <simgear_config.h>
 
 #include <simgear/misc/ResourceManager.hxx>
+#include <simgear/debug/logstream.hxx>
 
 namespace simgear
 {
     
-static ResourceManager* static_manager = NULL;
+static ResourceManager* static_manager = nullptr;
+
+ResourceProvider::~ResourceProvider()
+{
+    // pin to this compilation unit
+}
 
 ResourceManager::ResourceManager()
 {
@@ -40,13 +49,20 @@ ResourceManager* ResourceManager::instance()
     return static_manager;
 }    
 
+ResourceManager::~ResourceManager()
+{
+    assert(this == static_manager);
+    static_manager = nullptr;
+    std::for_each(_providers.begin(), _providers.end(), 
+        [](ResourceProvider* p) { delete p; });
+}
 /**
  * trivial provider using a fixed base path
  */
 class BasePathProvider : public ResourceProvider
 {
 public:
-    BasePathProvider(const SGPath& aBase, int aPriority) :
+    BasePathProvider(const SGPath& aBase, ResourceManager::Priority aPriority) :
         ResourceProvider(aPriority),
         _base(aBase)
     {
@@ -69,6 +85,8 @@ void ResourceManager::addBasePath(const SGPath& aPath, Priority aPriority)
 
 void ResourceManager::addProvider(ResourceProvider* aProvider)
 {
+    assert(aProvider);
+
     ProviderVec::iterator it = _providers.begin();
     for (; it != _providers.end(); ++it) {
       if (aProvider->priority() > (*it)->priority()) {
@@ -81,6 +99,16 @@ void ResourceManager::addProvider(ResourceProvider* aProvider)
     _providers.push_back(aProvider);
 }
 
+void ResourceManager::removeProvider(ResourceProvider* aProvider)
+{
+    assert(aProvider);
+    auto it = std::find(_providers.begin(), _providers.end(), aProvider);
+    if (it == _providers.end()) {
+        SG_LOG(SG_GENERAL, SG_DEV_ALERT, "unknown provider doing remove");
+        return;
+    }
+}
+
 SGPath ResourceManager::findPath(const std::string& aResource, SGPath aContext)
 {
     if (!aContext.isNull()) {
@@ -90,9 +118,8 @@ SGPath ResourceManager::findPath(const std::string& aResource, SGPath aContext)
         }
     }
     
-    ProviderVec::iterator it = _providers.begin();
-    for (; it != _providers.end(); ++it) {
-      SGPath path = (*it)->resolve(aResource, aContext);
+    for (auto provider : _providers) {
+      SGPath path = provider->resolve(aResource, aContext);
       if (!path.isNull()) {
         return path;
       }

simgear/misc/ResourceManager.hxx

@@ -36,6 +36,8 @@ class ResourceProvider;
 class ResourceManager
 {
 public:
+    ~ResourceManager();
+
     typedef enum {
       PRIORITY_DEFAULT = 0,
       PRIORITY_FALLBACK = -100,
@@ -55,6 +57,8 @@ public:
      */
     void addProvider(ResourceProvider* aProvider);
     
+    void removeProvider(ResourceProvider* aProvider);
+
     /**
      * given a resource name (or path), find the appropriate real resource
      * path.
@@ -75,17 +79,19 @@ class ResourceProvider
 public:
     virtual SGPath resolve(const std::string& aResource, SGPath& aContext) const = 0;
     
-    virtual int priority() const
+    virtual ~ResourceProvider();
+
+    virtual ResourceManager::Priority priority() const
     {
       return _priority;
     }
     
 protected:
-    ResourceProvider(int aPriority) :
+    ResourceProvider(ResourceManager::Priority aPriority) :
       _priority(aPriority)
     {}
     
-    int _priority;
+    ResourceManager::Priority _priority = ResourceManager::PRIORITY_DEFAULT;
 };
     
 } // of simgear namespace

simgear/misc/path_test.cxx

@@ -160,7 +160,7 @@ void test_path_dir()
 	SG_VERIFY(sub2.isFile());
 	SG_CHECK_EQUAL(sub2.sizeInBytes(), 250);
 
-    SGPath sub3 = p / "subß" / "file𝕽";
+    SGPath sub3 = p / "subß" / u8"file𝕽";
     sub3.create_dir(0755);
 
     {
@@ -174,7 +174,7 @@ void test_path_dir()
     sub3.set_cached(false);
     SG_VERIFY(sub3.exists());
     SG_CHECK_EQUAL(sub3.sizeInBytes(), 100);
-    SG_CHECK_EQUAL(sub3.file(), "file𝕽");
+    SG_CHECK_EQUAL(sub3.file(), u8"file𝕽");
 
 	simgear::Dir subD(p / "subA");
 	simgear::PathList dirChildren = subD.children(simgear::Dir::TYPE_DIR | simgear::Dir::NO_DOT_OR_DOTDOT);
@@ -188,7 +188,7 @@ void test_path_dir()
     simgear::Dir subS(sub3.dirPath());
     fileChildren = subS.children(simgear::Dir::TYPE_FILE | simgear::Dir::NO_DOT_OR_DOTDOT);
     SG_CHECK_EQUAL(fileChildren.size(), 1);
-    SG_CHECK_EQUAL(fileChildren[0], subS.path() / "file𝕽");
+    SG_CHECK_EQUAL(fileChildren[0], subS.path() / u8"file𝕽");
 
 }
 

simgear/misc/sg_path.cxx

@@ -107,7 +107,7 @@ static SGPath pathForKnownFolder(REFKNOWNFOLDERID folderId, const SGPath& def)
             // system call will allocate dynamic memory... which we must release when done
             wchar_t* localFolder = 0;
 
-            if (pSHGetKnownFolderPath(folderId, KF_FLAG_DEFAULT_PATH, NULL, &localFolder) == S_OK) {
+			if (pSHGetKnownFolderPath(folderId, KF_FLAG_DONT_VERIFY, NULL, &localFolder) == S_OK) {
                 SGPath folder_path = SGPath(localFolder, def.getPermissionChecker());
                 // release dynamic memory
                 CoTaskMemFree(static_cast<void*>(localFolder));

simgear/misc/stdint.hxx

@@ -12,65 +12,50 @@
 // $Id$
 
 
-//////////////////////////////////////////////////////////////////////
-//
-//  There are many sick systems out there:
-//
-//  check for sizeof(float) and sizeof(double)
-//  if sizeof(float) != 4 this code must be patched
-//  if sizeof(double) != 8 this code must be patched
-//
-//  Those are comments I fetched out of glibc source:
-//  - s390 is big-endian
-//  - Sparc is big-endian, but v9 supports endian conversion
-//    on loads/stores and GCC supports such a mode.  Be prepared.
-//  - The MIPS architecture has selectable endianness.
-//  - x86_64 is little-endian.
-//  - CRIS is little-endian.
-//  - m68k is big-endian.
-//  - Alpha is little-endian.
-//  - PowerPC can be little or big endian.
-//  - SH is bi-endian but with a big-endian FPU.
-//  - hppa1.1 big-endian.
-//  - ARM is (usually) little-endian but with a big-endian FPU.
-//
-//////////////////////////////////////////////////////////////////////
+#include <cstdint>
+#include <cstdlib> // for _byteswap_foo on Win32
 
-
-#ifdef _MSC_VER
-typedef signed char      int8_t;
-typedef signed short     int16_t;
-typedef signed int       int32_t;
-typedef signed __int64   int64_t;
-typedef unsigned char    uint8_t;
-typedef unsigned short   uint16_t;
-typedef unsigned int     uint32_t;
-typedef unsigned __int64 uint64_t;
-
-typedef int ssize_t;
-#elif defined(sgi) || defined(__sun)
-# include <sys/types.h>
-#else
-# include <stdint.h>
+#if defined(_MSC_VER)
+using ssize_t = int64_t; // this is a POSIX type, not a C one
 #endif
 
-
 inline uint16_t sg_bswap_16(uint16_t x) {
+#if defined(__llvm__) || \
+ (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) && !defined(__ICC)
+    return __builtin_bswap16(x);
+#elif defined(_MSC_VER) && !defined(_DEBUG)
+   return _byteswap_ushort(x);
+#else
     x = (x >> 8) | (x << 8);
     return x;
+#endif
 }
 
 inline uint32_t sg_bswap_32(uint32_t x) {
+#if defined(__llvm__) || \
+ (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && !defined(__ICC)
+    return __builtin_bswap32(x);
+#elif defined(_MSC_VER) && !defined(_DEBUG)
+   return _byteswap_ulong(x);
+#else
     x = ((x >>  8) & 0x00FF00FFL) | ((x <<  8) & 0xFF00FF00L);
     x = (x >> 16) | (x << 16);
     return x;
+#endif
 }
 
 inline uint64_t sg_bswap_64(uint64_t x) {
+#if defined(__llvm__) || \
+ (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && !defined(__ICC)
+   return __builtin_bswap64(x);
+#elif defined(_MSC_VER) && !defined(_DEBUG)
+   return _byteswap_uint64(x);
+#else
     x = ((x >>  8) & 0x00FF00FF00FF00FFLL) | ((x <<  8) & 0xFF00FF00FF00FF00LL);
     x = ((x >> 16) & 0x0000FFFF0000FFFFLL) | ((x << 16) & 0xFFFF0000FFFF0000LL);
     x = (x >> 32) | (x << 32);
     return x;
+#endif
 }
 
 

simgear/misc/strutils.cxx

@@ -37,7 +37,7 @@
 #include <simgear/package/md5.h>
 #include <simgear/compiler.h>   // SG_WINDOWS
 #include <simgear/structure/exception.hxx>
-
+#include <simgear/math/SGGeod.hxx>
 
 #if defined(SG_WINDOWS)
 	#include <windows.h>
@@ -1133,6 +1133,306 @@ bool matchPropPathToTemplate(const std::string& path, const std::string& templat
 
     // unreachable
 }
+ 
+bool parseStringAsLatLonValue(const std::string& s, double& degrees)
+{
+    try {
+            string ss = simplify(s);
+            auto spacePos = ss.find_first_of(" *");
+        
+            if (spacePos == std::string::npos) {
+                degrees = std::stod(ss);
+            } else {
+                degrees = std::stod(ss.substr(0, spacePos));
+                
+                double minutes = 0.0, seconds = 0.0;
+                
+                // check for minutes marker
+                auto quotePos = ss.find('\'');
+                if (quotePos == std::string::npos) {
+                    const auto minutesStr = ss.substr(spacePos+1);
+                    if (!minutesStr.empty()) {
+                        minutes = std::stod(minutesStr);
+                    }
+                } else {
+                    minutes = std::stod(ss.substr(spacePos+1, quotePos - spacePos));
+                    const auto secondsStr = ss.substr(quotePos+1);
+                    if (!secondsStr.empty()) {
+                        seconds = std::stod(secondsStr);
+                    }
+                }
+                
+                if ((seconds < 0.0) || (minutes < 0.0)) {
+                    // don't allow sign information in minutes or seconds
+                    return false;
+                }
+                
+                double offset = (minutes / 60.0) + (seconds / 3600.0);
+                degrees += (degrees >= 0.0) ? offset : -offset;
+            }
+        
+            // since we simplified, any trailing N/S/E/W must be the last char
+            const char lastChar = ::toupper(ss.back());
+            if ((lastChar == 'W') || (lastChar == 'S')) {
+                degrees = -degrees;
+            }
+    } catch (std::exception&) {
+        // std::stdo can throw
+        return false;
+    }
+    
+    return true;
+}
+        
+namespace {
+    bool isLatString(const std::string &s)
+    {
+        const char lastChar = ::toupper(s.back());
+        return (lastChar == 'N') || (lastChar == 'S');
+    }
+    
+    bool isLonString(const std::string &s)
+    {
+        const char lastChar = ::toupper(s.back());
+        return (lastChar == 'E') || (lastChar == 'W');
+    }
+} // of anonymous namespace
+        
+bool parseStringAsGeod(const std::string& s, SGGeod* result, bool assumeLonLatOrder)
+{
+    if (s.empty())
+        return false;
+    
+    const auto commaPos = s.find(',');
+    if (commaPos == string::npos) {
+        return false;
+    }
+    
+    auto termA = simplify(s.substr(0, commaPos)),
+        termB = simplify(s.substr(commaPos+1));
+    double valueA, valueB;
+    if (!parseStringAsLatLonValue(termA, valueA) || !parseStringAsLatLonValue(termB, valueB)) {
+        return false;
+    }
+    
+    if (result) {
+        // explicit ordering
+        if (isLatString(termA) && isLonString(termB)) {
+            *result = SGGeod::fromDeg(valueB, valueA);
+        } else if (isLonString(termA) && isLatString(termB)) {
+            *result = SGGeod::fromDeg(valueA, valueB);
+        } else {
+            // implicit ordering
+            // SGGeod wants longitude, latitude
+            *result = assumeLonLatOrder ? SGGeod::fromDeg(valueA, valueB)
+                                        : SGGeod::fromDeg(valueB, valueA);
+        }
+    }
+    
+    return true;
+}
+        
+namespace {
+    const char* static_degreeSymbols[] = {
+        "*",
+        " ",
+        "\xB0",     // Latin-1 B0 codepoint
+        "\xC2\xB0"  // UTF-8 equivalent
+    };
+} // of anonymous namespace
+        
+std::string formatLatLonValueAsString(double deg, LatLonFormat format,
+                                      char c,
+                                      DegreeSymbol degreeSymbol)
+{
+    double min, sec;
+    const int sign = deg < 0.0 ? -1 : 1;
+    deg = fabs(deg);
+    char buf[128];
+    const char* degSym = static_degreeSymbols[static_cast<int>(degreeSymbol)];
+    
+    switch (format) {
+    case LatLonFormat::DECIMAL_DEGREES:
+        ::snprintf(buf, sizeof(buf), "%3.6f%c", deg, c);
+        break;
+        
+    case LatLonFormat::DEGREES_MINUTES:
+        // d mm.mmm' (DMM format) -- uses a round-off factor tailored to the
+        // required precision of the minutes field (three decimal places),
+        // preventing minute values of 60.
+        min = (deg - int(deg)) * 60.0;
+        if (min >= 59.9995) {
+            min -= 60.0;
+            deg += 1.0;
+        }
+        snprintf(buf, sizeof(buf), "%d%s%06.3f'%c", int(deg), degSym, fabs(min), c);
+        break;
+        
+    case LatLonFormat::DEGREES_MINUTES_SECONDS:
+        // d mm'ss.s" (DMS format) -- uses a round-off factor tailored to the
+        // required precision of the seconds field (one decimal place),
+        // preventing second values of 60.
+        min = (deg - int(deg)) * 60.0;
+        sec = (min - int(min)) * 60.0;
+        if (sec >= 59.95) {
+            sec -= 60.0;
+            min += 1.0;
+            if (min >= 60.0) {
+                min -= 60.0;
+                deg += 1.0;
+            }
+        }
+        ::snprintf(buf, sizeof(buf), "%d%s%02d'%04.1f\"%c", int(deg), degSym,
+                   int(min), fabs(sec), c);
+        break;
+            
+    case LatLonFormat::SIGNED_DECIMAL_DEGREES:
+        // d.dddddd' (signed DDD format).
+        ::snprintf(buf, sizeof(buf), "%3.6f", sign*deg);
+        break;
+    
+    case LatLonFormat::SIGNED_DEGREES_MINUTES:
+        // d mm.mmm' (signed DMM format).
+        min = (deg - int(deg)) * 60.0;
+        if (min >= 59.9995) {
+            min -= 60.0;
+            deg += 1.0;
+        }
+        if (sign == 1) {
+            snprintf(buf, sizeof(buf), "%d%s%06.3f'", int(deg), degSym, fabs(min));
+        } else {
+            snprintf(buf, sizeof(buf), "-%d%s%06.3f'", int(deg), degSym, fabs(min));
+        }
+        break;
+        
+            
+    case LatLonFormat::SIGNED_DEGREES_MINUTES_SECONDS:
+        // d mm'ss.s" (signed DMS format).
+        min = (deg - int(deg)) * 60.0;
+        sec = (min - int(min)) * 60.0;
+        if (sec >= 59.95) {
+            sec -= 60.0;
+            min += 1.0;
+            if (min >= 60.0) {
+                min -= 60.0;
+                deg += 1.0;
+            }
+        }
+        if (sign == 1) {
+            snprintf(buf, sizeof(buf), "%d%s%02d'%04.1f\"", int(deg), degSym, int(min), fabs(sec));
+        } else {
+            snprintf(buf, sizeof(buf), "-%d%s%02d'%04.1f\"", int(deg), degSym, int(min), fabs(sec));
+        }
+        break;
+            
+    case LatLonFormat::ZERO_PAD_DECIMAL_DEGRESS:
+        // dd.dddddd X, ddd.dddddd X (zero padded DDD format).
+        if (c == 'N' || c == 'S') {
+            snprintf(buf, sizeof(buf), "%09.6f%c", deg, c);
+        } else {
+            snprintf(buf, sizeof(buf), "%010.6f%c", deg, c);
+        }
+        break;
+            
+    case LatLonFormat::ZERO_PAD_DEGREES_MINUTES:
+        // dd mm.mmm' X, ddd mm.mmm' X (zero padded DMM format).
+        min = (deg - int(deg)) * 60.0;
+        if (min >= 59.9995) {
+            min -= 60.0;
+            deg += 1.0;
+        }
+        if (c == 'N' || c == 'S') {
+            snprintf(buf, sizeof(buf), "%02d%s%06.3f'%c", int(deg), degSym, fabs(min), c);
+        } else {
+            snprintf(buf, sizeof(buf), "%03d%s%06.3f'%c", int(deg), degSym, fabs(min), c);
+        }
+        break;
+            
+    case LatLonFormat::ZERO_PAD_DEGREES_MINUTES_SECONDS:
+        // dd mm'ss.s" X, dd mm'ss.s" X (zero padded DMS format).
+        min = (deg - int(deg)) * 60.0;
+        sec = (min - int(min)) * 60.0;
+        if (sec >= 59.95) {
+            sec -= 60.0;
+            min += 1.0;
+            if (min >= 60.0) {
+                min -= 60.0;
+                deg += 1.0;
+            }
+        }
+        if (c == 'N' || c == 'S') {
+            snprintf(buf, sizeof(buf), "%02d%s%02d'%04.1f\"%c", int(deg), degSym, int(min), fabs(sec), c);
+        } else {
+            snprintf(buf, sizeof(buf), "%03d%s%02d'%04.1f\"%c", int(deg), degSym, int(min), fabs(sec), c);
+        }
+        break;
+            
+    case LatLonFormat::TRINITY_HOUSE:
+        // dd* mm'.mmm X, ddd* mm'.mmm X (Trinity House Navigation standard).
+        min = (deg - int(deg)) * 60.0;
+        if (min >= 59.9995) {
+            min -= 60.0;
+            deg += 1.0;
+        }
+        if (c == 'N' || c == 'S') {
+            snprintf(buf, sizeof(buf), "%02d* %02d'.%03d%c", int(deg), int(min), int(SGMisc<double>::round((min-int(min))*1000)), c);
+        } else {
+            snprintf(buf, sizeof(buf), "%03d* %02d'.%03d%c", int(deg), int(min), int(SGMisc<double>::round((min-int(min))*1000)), c);
+        }
+        break;
+            
+    case LatLonFormat::DECIMAL_DEGREES_SYMBOL:
+        ::snprintf(buf, sizeof(buf), "%3.6f%s%c", deg, degSym, c);
+        break;
+            
+    case LatLonFormat::ICAO_ROUTE_DEGREES:
+    {
+        min = (deg - int(deg)) * 60.0;
+        if (min >= 59.9995) {
+            min -= 60.0;
+            deg += 1.0;
+        }
+        
+        if (static_cast<int>(min) == 0) {
+            // 7-digit mode
+            if (c == 'N' || c == 'S') {
+                snprintf(buf, sizeof(buf), "%02d%c", int(deg), c);
+            } else {
+                snprintf(buf, sizeof(buf), "%03d%c", int(deg), c);
+            }
+        } else {
+            // 11-digit mode
+            if (c == 'N' || c == 'S') {
+                snprintf(buf, sizeof(buf), "%02d%02d%c", int(deg), int(min), c);
+            } else {
+                snprintf(buf, sizeof(buf), "%03d%02d%c", int(deg), int(min), c);
+            }
+        }
+        break;
+    }
+            
+    default:
+        break;
+    }
+ 
+    return std::string(buf);
+}
+
+std::string formatGeodAsString(const SGGeod& geod, LatLonFormat format,
+                               DegreeSymbol degreeSymbol)
+{
+    const char ns = (geod.getLatitudeDeg() > 0.0) ? 'N' : 'S';
+    const char ew = (geod.getLongitudeDeg() > 0.0) ? 'E' : 'W';
+    
+    // no comma seperator
+    if (format == LatLonFormat::ICAO_ROUTE_DEGREES) {
+        return formatLatLonValueAsString(geod.getLatitudeDeg(), format, ns, degreeSymbol) +
+            formatLatLonValueAsString(geod.getLongitudeDeg(), format, ew, degreeSymbol);
+    }
+    
+    return formatLatLonValueAsString(geod.getLatitudeDeg(), format, ns, degreeSymbol) + ","
+        + formatLatLonValueAsString(geod.getLongitudeDeg(), format, ew, degreeSymbol);
+}
 
 } // end namespace strutils
 

simgear/misc/strutils.hxx

@@ -36,6 +36,9 @@
 
 typedef std::vector < std::string > string_list;
 
+// forward decls
+class SGGeod;
+
 namespace simgear {
   namespace strutils {
 
@@ -354,6 +357,68 @@ namespace simgear {
        *      /views[0]/view[4]/fig, /views[0]/view[1000]/flight
        */
       bool matchPropPathToTemplate(const std::string& path, const std::string& templatePath);
+      
+      bool parseStringAsLatLonValue(const std::string& s, double& result);
+      
+      /**
+       * Attempt to parse a string as a latitude,longitude input. Returns true
+       * or false based on success, and returns the SGGeod by pointer. Leading,
+       * trailing and internal white-space is skipped / ignored.
+       *
+       * Supported formats:
+       *   <signed decimal degrees latitude>,<signed decimal degress longitude>
+       *   <unsigned decimal degrees>[NS],<unsigned decimal degrees>[EW]
+       *   <degrees>*<decimal minutes>'[NS],<degrees>*<decimal minutes>'[EW]
+       *
+       * Latitude and longitude are parsed seperately so the formats for each
+       * do not need to agree. Latitude is assumed to precede longitude
+       * unless assumeLonLatOrder = true
+       *
+       * When NSEW characters are used, the order can be swapped and will be
+       * fixed correctly (longitude then latitude).
+       */
+      bool parseStringAsGeod(const std::string& string,
+                             SGGeod* result = nullptr,
+                             bool assumeLonLatOrder = false);
+      
+      // enum values here correspond to existing lon-lat format codes inside
+      // FlightGear (property: /sim/lon-lat-format )
+      // Don't re-order, just add new ones, or things may break
+      enum class LatLonFormat
+      {
+          DECIMAL_DEGREES = 0,          ///< 88.4N,4.54W,
+          DEGREES_MINUTES,             ///< 88 24.6'N, 4 30.5'W
+          DEGREES_MINUTES_SECONDS,
+          SIGNED_DECIMAL_DEGREES,          ///< 88.4,-4.54
+          SIGNED_DEGREES_MINUTES,
+          SIGNED_DEGREES_MINUTES_SECONDS,
+          ZERO_PAD_DECIMAL_DEGRESS,
+          ZERO_PAD_DEGREES_MINUTES,
+          ZERO_PAD_DEGREES_MINUTES_SECONDS,
+          TRINITY_HOUSE,            ///< dd* mm'.mmm X, ddd* mm'.mmm X (Trinity House Navigation standard).
+          DECIMAL_DEGREES_SYMBOL,        ///< 88.4*N,4.54*W
+          ICAO_ROUTE_DEGREES,              ///< 52N045W or 5212N04512W - precision auto-selected
+      };
+      
+      enum class DegreeSymbol
+      {
+          ASTERISK = 0,
+          SPACE,
+          LATIN1_DEGREE,
+          UTF8_DEGREE
+      };
+      
+      std::string formatLatLonValueAsString(double deg,
+                                            LatLonFormat format, char c,
+                                            DegreeSymbol degreeSymbol = DegreeSymbol::ASTERISK);
+
+      /**
+       * Format an SGGeod as a string according to the provided rule.
+       * if the SGGeod is invalid (default constructed), will return an empty string
+       */
+      std::string formatGeodAsString(const SGGeod& geod,
+                                     LatLonFormat format = LatLonFormat::DECIMAL_DEGREES,
+                                     DegreeSymbol degreeSymbol = DegreeSymbol::ASTERISK);
   } // end namespace strutils
 } // end namespace simgear
 

simgear/misc/strutils_test.cxx

@@ -20,6 +20,7 @@
 #include <simgear/misc/strutils.hxx>
 #include <simgear/structure/exception.hxx>
 #include <simgear/constants.h>
+#include <simgear/math/SGGeod.hxx>
 
 using std::string;
 using std::vector;
@@ -619,6 +620,101 @@ void test_utf8Convert()
     SG_VERIFY(a == aRoundTrip);
 }
 
+void test_parseGeod()
+{
+    SGGeod a;
+    SG_VERIFY(strutils::parseStringAsGeod("56.12,-3.0", &a));
+    SG_CHECK_EQUAL_EP(a.getLongitudeDeg(), -3.0);
+    SG_CHECK_EQUAL_EP(a.getLatitudeDeg(), 56.12);
+    
+    SG_VERIFY(strutils::parseStringAsGeod("56.12345678s,3.12345678w", &a));
+    SG_CHECK_EQUAL_EP(a.getLongitudeDeg(), -3.12345678);
+    SG_CHECK_EQUAL_EP(a.getLatitudeDeg(), -56.12345678);
+    
+    
+    // trailing degrees
+    SG_VERIFY(strutils::parseStringAsGeod("56.12*,-3.0*", &a));
+    SG_CHECK_EQUAL_EP(a.getLongitudeDeg(), -3.0);
+    SG_CHECK_EQUAL_EP(a.getLatitudeDeg(), 56.12);
+    
+    // embedded whitepace, DMS notation, NSEW notation
+    SG_VERIFY(strutils::parseStringAsGeod("\t40 30'50\"S,  12 34'56\"W ", &a));
+    SG_CHECK_EQUAL_EP(a.getLongitudeDeg(), -12.58222222);
+    SG_CHECK_EQUAL_EP(a.getLatitudeDeg(), -40.5138888);
+    
+    // embedded whitepace, DMS notation, NSEW notation, degrees symbol
+    SG_VERIFY(strutils::parseStringAsGeod("\t40*30'50\"S,  12*34'56\"W ", &a));
+    SG_CHECK_EQUAL_EP(a.getLongitudeDeg(), -12.58222222);
+    SG_CHECK_EQUAL_EP(a.getLatitudeDeg(), -40.5138888);
+    
+    // signed degrees-minutes
+    SG_VERIFY(strutils::parseStringAsGeod("-45 27.89,-12 34.56", &a));
+    SG_CHECK_EQUAL_EP(a.getLongitudeDeg(), -12.576);
+    SG_CHECK_EQUAL_EP(a.getLatitudeDeg(), -45.464833333);
+    
+    SG_VERIFY(strutils::parseStringAsGeod("") == false);
+    SG_VERIFY(strutils::parseStringAsGeod("aaaaaaaa") == false);
+    
+    // ordering tests
+    
+    // normal default order, but explicitly pass as lon,lat
+    // (should work)
+    SG_VERIFY(strutils::parseStringAsGeod("3.12345678w, 56.12345678s", &a));
+    SG_CHECK_EQUAL_EP(a.getLongitudeDeg(), -3.12345678);
+    SG_CHECK_EQUAL_EP(a.getLatitudeDeg(), -56.12345678);
+    
+
+    // different default order
+    // also some embedded whitespace for fun
+    SG_VERIFY(strutils::parseStringAsGeod(" -12 34.56,\n-45 27.89 ", &a, true));
+    SG_CHECK_EQUAL_EP(a.getLongitudeDeg(), -12.576);
+    SG_CHECK_EQUAL_EP(a.getLatitudeDeg(), -45.464833333);
+    
+    
+    // differnet default order, but still set explicitly so should
+    // use the lat,lon order
+    SG_VERIFY(strutils::parseStringAsGeod("\t40 30'50\"S,  12 34'56\"W ", &a, true));
+    SG_CHECK_EQUAL_EP(a.getLongitudeDeg(), -12.58222222);
+    SG_CHECK_EQUAL_EP(a.getLatitudeDeg(), -40.5138888);
+    
+    
+    // malformed inputs
+    
+    SG_VERIFY(strutils::parseStringAsGeod("12.345,", &a, true) == false);
+    double d;
+    SG_VERIFY(strutils::parseStringAsLatLonValue("", d) == false);
+}
+
+void test_formatGeod()
+{
+    SGGeod a = SGGeod::fromDeg(-3.46, 55.45);
+    SG_CHECK_EQUAL(strutils::formatGeodAsString(a, strutils::LatLonFormat::SIGNED_DECIMAL_DEGREES), "55.450000,-3.460000");
+    SG_CHECK_EQUAL(strutils::formatGeodAsString(a, strutils::LatLonFormat::DEGREES_MINUTES_SECONDS),
+                   "55*27'00.0\"N,3*27'36.0\"W");
+
+    
+    SG_CHECK_EQUAL(strutils::formatGeodAsString(a, strutils::LatLonFormat::ICAO_ROUTE_DEGREES),
+                   "5527N00327W");
+    SGGeod shortA = SGGeod::fromDeg(106, -34);
+    SG_CHECK_EQUAL(strutils::formatGeodAsString(shortA, strutils::LatLonFormat::ICAO_ROUTE_DEGREES),
+                   "34S106E");
+    
+    
+    const auto s = strutils::formatGeodAsString(a,
+                                                strutils::LatLonFormat::ZERO_PAD_DEGREES_MINUTES,
+                                                strutils::DegreeSymbol::LATIN1_DEGREE);
+    SG_CHECK_EQUAL(s, "55\xB0" "27.000'N,003\xB0" "27.600'W");
+    
+    // Jakarta, if you care
+    SGGeod b = SGGeod::fromDeg(106.8278, -6.1568);
+    const auto s2 = strutils::formatGeodAsString(b,
+                                                strutils::LatLonFormat::DECIMAL_DEGREES_SYMBOL,
+                                                strutils::DegreeSymbol::UTF8_DEGREE);
+    SG_CHECK_EQUAL(s2, "6.156800\xC2\xB0S,106.827800\xC2\xB0" "E");
+    
+    
+}
+
 int main(int argc, char* argv[])
 {
     test_strip();
@@ -639,6 +735,8 @@ int main(int argc, char* argv[])
     test_propPathMatch();
     test_readTime();
     test_utf8Convert();
+    test_parseGeod();
+    test_formatGeod();
     
     return EXIT_SUCCESS;
 }

simgear/nasal/lib.c

@@ -302,15 +302,18 @@ static char* dosprintf(char* f, ...)
     char* buf;
     va_list va;
     int olen, len = 16;
+    va_start(va, f);
     while(1) {
         buf = naAlloc(len);
-        va_start(va, f);
-        olen = vsnprintf(buf, len, f, va);
+        va_list vaCopy;
+        va_copy(vaCopy, va);
+        olen = vsnprintf(buf, len, f, vaCopy);
         if(olen >= 0 && olen < len) {
             va_end(va);
+            va_end(vaCopy);
             return buf;
         }
-        va_end(va);
+        va_end(vaCopy);
         naFree(buf);
         len *= 2;
     }

simgear/package/Catalog.cxx

@@ -81,17 +81,27 @@ bool checkVersion(const std::string& aVersion, SGPropertyNode_ptr props)
     }
     return false;
 }
+    
+SGPropertyNode_ptr alternateForVersion(const std::string& aVersion, SGPropertyNode_ptr props)
+{
+    for (auto v : props->getChildren("alternate-version")) {
+        for (auto versionSpec : v->getChildren("version")) {
+            if (checkVersionString(aVersion, versionSpec->getStringValue())) {
+                return v;
+            }
+        }
+    }
+    
+    return {};
+}
 
 std::string redirectUrlForVersion(const std::string& aVersion, SGPropertyNode_ptr props)
 {
-    for (SGPropertyNode* v : props->getChildren("alternate-version")) {
-        std::string s(v->getStringValue("version"));
-        if (checkVersionString(aVersion, s)) {
-            return  v->getStringValue("url");;
-        }
-    }
+    auto node = alternateForVersion(aVersion, props);
+    if (node)
+        return node->getStringValue("url");;
 
-    return std::string();
+    return {};
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -139,19 +149,15 @@ protected:
 
         std::string ver(m_owner->root()->applicationVersion());
         if (!checkVersion(ver, props)) {
-            SG_LOG(SG_GENERAL, SG_WARN, "downloaded catalog " << m_owner->url() << ", but version required " << ver);
-
             // check for a version redirect entry
-            std::string url = redirectUrlForVersion(ver, props);
-            if (!url.empty()) {
-                SG_LOG(SG_GENERAL, SG_WARN, "redirecting from " << m_owner->url() <<
-                       " to \n\t" << url);
-
-                // update the URL and kick off a new request
-                m_owner->setUrl(url);
-                Downloader* dl = new Downloader(m_owner, url);
-                m_owner->root()->makeHTTPRequest(dl);
+            auto alt = alternateForVersion(ver, props);
+            if (alt) {
+                SG_LOG(SG_GENERAL, SG_WARN, "have alternate version of package at:"
+                       << alt->getStringValue("url"));
+                m_owner->processAlternate(alt);
             } else {
+                SG_LOG(SG_GENERAL, SG_WARN, "downloaded catalog " << m_owner->url()
+                       << ", but app version " << ver << " is not comaptible");
                 m_owner->refreshComplete(Delegate::FAIL_VERSION);
             }
 
@@ -228,7 +234,7 @@ CatalogRef Catalog::createFromPath(Root* aRoot, const SGPath& aPath)
 
     bool versionCheckOk = checkVersion(aRoot->applicationVersion(), props);
     if (!versionCheckOk) {
-        SG_LOG(SG_GENERAL, SG_INFO, "catalog at:" << aPath << " failed version check: need version: "
+        SG_LOG(SG_GENERAL, SG_INFO, "catalog at:" << aPath << " failed version check: app version: "
                << aRoot->applicationVersion());
         // keep the catalog but mark it as needing an update
     } else {
@@ -598,6 +604,50 @@ bool Catalog::isEnabled() const
     }
 }
     
+void Catalog::processAlternate(SGPropertyNode_ptr alt)
+{
+    std::string altId;
+    const auto idPtr = alt->getStringValue("id");
+    if (idPtr) {
+        altId = std::string(idPtr);
+    }
+    
+    std::string altUrl;
+    if (alt->getStringValue("url")) {
+        altUrl = std::string(alt->getStringValue("url"));
+    }
+    
+    CatalogRef existing;
+    if (!altId.empty()) {
+        existing = root()->getCatalogById(altId);
+    } else {
+        existing = root()->getCatalogByUrl(altUrl);
+    }
+    
+    if (existing && (existing != this)) {
+        // we already have the alternate, so just go quiet here
+        changeStatus(Delegate::FAIL_VERSION);
+        return;
+    }
+
+    // we have an alternate ID, and it's differnt from our ID, so let's
+    // define a new catalog
+    if (!altId.empty()) {
+        SG_LOG(SG_GENERAL, SG_INFO, "Adding new catalog:" << altId << " as version alternate for " << id());
+        // new catalog being added
+        createFromUrl(root(), altUrl);
+
+        // and we can go idle now
+        changeStatus(Delegate::FAIL_VERSION);
+        return;
+    }
+    
+    SG_LOG(SG_GENERAL, SG_INFO, "Migrating catalog " << id() << " to new URL:" << altUrl);
+    setUrl(altUrl);
+    Downloader* dl = new Downloader(this, altUrl);
+    root()->makeHTTPRequest(dl);
+}
+    
 } // of namespace pkg
 
 } // of namespace simgear

simgear/package/Catalog.hxx

@@ -179,6 +179,8 @@ private:
 
     void changeStatus(Delegate::StatusCode newStatus);
 
+    void processAlternate(SGPropertyNode_ptr alt);
+    
     Root* m_root;
     SGPropertyNode_ptr m_props;
     SGPath m_installRoot;

simgear/package/CatalogTest.cxx

@@ -723,6 +723,130 @@ void testVersionMigrate(HTTP::Client* cl)
     }
 }
 
+void testVersionMigrateToId(HTTP::Client* cl)
+{
+    global_catalogVersion = 2; // version which has migration info
+    SGPath rootPath(simgear::Dir::current().path());
+    rootPath.append("cat_migrate_version_id");
+    simgear::Dir pd(rootPath);
+    pd.removeChildren();
+    
+    {
+        pkg::RootRef root(new pkg::Root(rootPath, "8.1.2"));
+        root->setHTTPClient(cl);
+        
+        pkg::CatalogRef c = pkg::Catalog::createFromUrl(root.ptr(), "http://localhost:2000/catalogTest1/catalog.xml");
+        waitForUpdateComplete(cl, root);
+        SG_VERIFY(c->isEnabled());
+        
+        // install a package
+        pkg::PackageRef p1 = root->getPackageById("org.flightgear.test.catalog1.b737-NG");
+        SG_CHECK_EQUAL(p1->id(), "b737-NG");
+        pkg::InstallRef ins = p1->install();
+        SG_VERIFY(ins->isQueued());
+        waitForUpdateComplete(cl, root);
+        SG_VERIFY(p1->isInstalled());
+    }
+    
+    // change version to an alternate one
+    {
+        pkg::RootRef root(new pkg::Root(rootPath, "7.5"));
+        root->setHTTPClient(cl);
+        
+        // this should cause the alternate package to be loaded
+        root->refresh(true);
+        waitForUpdateComplete(cl, root);
+        
+        pkg::CatalogRef cat = root->getCatalogById("org.flightgear.test.catalog1");
+        SG_VERIFY(!cat->isEnabled());
+        SG_CHECK_EQUAL(cat->status(), pkg::Delegate::FAIL_VERSION);
+        SG_CHECK_EQUAL(cat->id(), "org.flightgear.test.catalog1");
+        SG_CHECK_EQUAL(cat->url(), "http://localhost:2000/catalogTest1/catalog.xml");
+        
+        auto enabledCats = root->catalogs();
+        auto it = std::find(enabledCats.begin(), enabledCats.end(), cat);
+        SG_VERIFY(it == enabledCats.end());
+                
+        // ensure existing package is still installed
+        pkg::PackageRef p1 = root->getPackageById("org.flightgear.test.catalog1.b737-NG");
+        SG_VERIFY(p1 !=  pkg::PackageRef());
+        SG_CHECK_EQUAL(p1->id(), "b737-NG");
+        
+        // but not listed
+        auto packs = root->allPackages();
+        auto k = std::find(packs.begin(), packs.end(), p1);
+        SG_VERIFY(k == packs.end());
+        
+        // check the new catalog
+        auto altCat = root->getCatalogById("org.flightgear.test.catalog-alt");
+        SG_VERIFY(altCat->isEnabled());
+        SG_CHECK_EQUAL(altCat->status(), pkg::Delegate::STATUS_REFRESHED);
+        SG_CHECK_EQUAL(altCat->id(), "org.flightgear.test.catalog-alt");
+        SG_CHECK_EQUAL(altCat->url(), "http://localhost:2000/catalogTest1/catalog-alt.xml");
+        
+        it = std::find(enabledCats.begin(), enabledCats.end(), altCat);
+        SG_VERIFY(it != enabledCats.end());
+        
+        // install a parallel package from the new catalog
+        pkg::PackageRef p2 = root->getPackageById("org.flightgear.test.catalog-alt.b737-NG");
+        SG_CHECK_EQUAL(p2->id(), "b737-NG");
+        pkg::InstallRef ins = p2->install();
+        SG_VERIFY(ins->isQueued());
+        waitForUpdateComplete(cl, root);
+        SG_VERIFY(p2->isInstalled());
+        
+        // do a non-scoped lookup, we should get the new one
+        pkg::PackageRef p3 = root->getPackageById("b737-NG");
+        SG_CHECK_EQUAL(p2, p3);
+    }
+    
+    // test that re-init-ing doesn't mirgate again
+    {
+        pkg::RootRef root(new pkg::Root(rootPath, "7.5"));
+        root->setHTTPClient(cl);
+        
+        root->refresh(true);
+        waitForUpdateComplete(cl, root);
+        
+        pkg::CatalogRef cat = root->getCatalogById("org.flightgear.test.catalog1");
+        SG_VERIFY(!cat->isEnabled());
+        SG_CHECK_EQUAL(cat->status(), pkg::Delegate::FAIL_VERSION);
+        
+        auto altCat = root->getCatalogById("org.flightgear.test.catalog-alt");
+        SG_VERIFY(altCat->isEnabled());
+        
+        auto packs = root->allPackages();
+        SG_CHECK_EQUAL(packs.size(), 4);
+    }
+    
+    // and now switch back to the older version
+    {
+        pkg::RootRef root(new pkg::Root(rootPath, "8.1.0"));
+        root->setHTTPClient(cl);
+        root->refresh(true);
+        waitForUpdateComplete(cl, root);
+        
+        pkg::CatalogRef cat = root->getCatalogById("org.flightgear.test.catalog1");
+        SG_VERIFY(cat->isEnabled());
+        SG_CHECK_EQUAL(cat->status(), pkg::Delegate::STATUS_REFRESHED);
+        
+        auto altCat = root->getCatalogById("org.flightgear.test.catalog-alt");
+        SG_VERIFY(!altCat->isEnabled());
+
+        // verify the original aircraft is still installed and available
+        pkg::PackageRef p1 = root->getPackageById("org.flightgear.test.catalog1.b737-NG");
+        SG_VERIFY(p1 !=  pkg::PackageRef());
+        SG_CHECK_EQUAL(p1->id(), "b737-NG");
+        SG_VERIFY(p1->isInstalled());
+        
+        // verify the alt package is still installed,
+        pkg::PackageRef p2 = root->getPackageById("org.flightgear.test.catalog-alt.b737-NG");
+        SG_VERIFY(p2 !=  pkg::PackageRef());
+        SG_CHECK_EQUAL(p2->id(), "b737-NG");
+        SG_VERIFY(p2->isInstalled());
+    }
+}
+
 void testOfflineMode(HTTP::Client* cl)
 {
     global_catalogVersion = 0;
@@ -972,6 +1096,8 @@ int main(int argc, char* argv[])
     
     removeInvalidCatalog(&cl);
     
+    testVersionMigrateToId(&cl);
+    
     SG_LOG(SG_GENERAL, SG_INFO, "Successfully passed all tests!");
     return EXIT_SUCCESS;
 }

simgear/package/Install.cxx

@@ -36,10 +36,6 @@
 #include <simgear/misc/strutils.hxx>
 #include <simgear/io/iostreams/sgstream.hxx>
 
-extern "C" {
-    void fill_memory_filefunc (zlib_filefunc_def*);
-}
-
 namespace simgear {
 
 namespace pkg {
@@ -49,17 +45,16 @@ class Install::PackageArchiveDownloader : public HTTP::Request
 public:
     PackageArchiveDownloader(InstallRef aOwner) :
         HTTP::Request("" /* dummy URL */),
-        m_owner(aOwner),
-        m_downloaded(0)
+        m_owner(aOwner)
     {
         m_urls = m_owner->package()->downloadUrls();
         if (m_urls.empty()) {
             throw sg_exception("no package download URLs");
         }
 
-        if (m_owner->package()->properties()->hasChild("archive-type")) {
-            setArchiveTypeFromExtension(m_owner->package()->properties()->getStringValue("archive-type"));
-        }
+       // if (m_owner->package()->properties()->hasChild("archive-type")) {
+       //     setArchiveTypeFromExtension(m_owner->package()->properties()->getStringValue("archive-type"));
+        //}
         
         // TODO randomise order of m_urls
 
@@ -110,17 +105,18 @@ protected:
         Dir d(m_extractPath);
         d.create(0755);
 
+		m_extractor.reset(new ArchiveExtractor(m_extractPath));
         memset(&m_md5, 0, sizeof(SG_MD5_CTX));
         SG_MD5Init(&m_md5);
     }
 
     virtual void gotBodyData(const char* s, int n)
     {
-        m_buffer += std::string(s, n);
-        SG_MD5Update(&m_md5, (unsigned char*) s, n);
-
-        m_downloaded = m_buffer.size();
-        m_owner->installProgress(m_buffer.size(), responseLength());
+		const uint8_t* ubytes = (uint8_t*) s;
+        SG_MD5Update(&m_md5, ubytes, n);
+        m_downloaded += n;
+        m_owner->installProgress(m_downloaded, responseLength());
+		m_extractor->extractBytes(ubytes, n);
     }
 
     virtual void onDone()
@@ -151,7 +147,8 @@ protected:
             return;
         }
 
-        if (!extract()) {
+		m_extractor->flush();
+        if (m_extractor->hasError() || !m_extractor->isAtEndOfArchive()) {
             SG_LOG(SG_GENERAL, SG_WARN, "archive extraction failed");
             doFailure(Delegate::FAIL_EXTRACT);
             return;
@@ -207,151 +204,6 @@ protected:
     }
 
 private:
-    void setArchiveTypeFromExtension(const std::string& ext)
-    {
-        if (ext.empty())
-            return;
-        
-        if (ext == "zip") {
-            m_archiveType = ZIP;
-            return;
-        }
-        
-        if ((ext == "tar.gz") || (ext == "tgz")) {
-            m_archiveType = TAR_GZ;
-            return;
-        }
-    }
-    
-    void extractCurrentFile(unzFile zip, char* buffer, size_t bufferSize)
-    {
-        unz_file_info fileInfo;
-        unzGetCurrentFileInfo(zip, &fileInfo,
-            buffer, bufferSize,
-            NULL, 0,  /* extra field */
-            NULL, 0 /* comment field */);
-
-        std::string name(buffer);
-    // no absolute paths, no 'up' traversals
-    // we could also look for suspicious file extensions here (forbid .dll, .exe, .so)
-        if ((name[0] == '/') || (name.find("../") != std::string::npos) || (name.find("..\\") != std::string::npos)) {
-            throw sg_format_exception("Bad zip path", name);
-        }
-
-        if (fileInfo.uncompressed_size == 0) {
-            // assume it's a directory for now
-            // since we create parent directories when extracting
-            // a path, we're done here
-            return;
-        }
-
-        int result = unzOpenCurrentFile(zip);
-        if (result != UNZ_OK) {
-            throw sg_io_exception("opening current zip file failed", sg_location(name));
-        }
-
-        sg_ofstream outFile;
-        bool eof = false;
-        SGPath path(m_extractPath);
-        path.append(name);
-
-    // create enclosing directory heirarchy as required
-        Dir parentDir(path.dir());
-        if (!parentDir.exists()) {
-            bool ok = parentDir.create(0755);
-            if (!ok) {
-                throw sg_io_exception("failed to create directory heirarchy for extraction", path);
-            }
-        }
-
-        outFile.open(path, std::ios::binary | std::ios::trunc | std::ios::out);
-        if (outFile.fail()) {
-            throw sg_io_exception("failed to open output file for writing", path);
-        }
-
-        while (!eof) {
-            int bytes = unzReadCurrentFile(zip, buffer, bufferSize);
-            if (bytes < 0) {
-                throw sg_io_exception("unzip failure reading curent archive", sg_location(name));
-            } else if (bytes == 0) {
-                eof = true;
-            } else {
-                outFile.write(buffer, bytes);
-            }
-        }
-
-        outFile.close();
-        unzCloseCurrentFile(zip);
-    }
-
-    bool extract()
-    {
-        const std::string u(url());
-        const size_t ul(u.length());
-        
-        if (m_archiveType == AUTO_DETECT) {
-            if (u.rfind(".zip") == (ul - 4)) {
-                m_archiveType = ZIP;
-            } else if (u.rfind(".tar.gz") == (ul - 7)) {
-                m_archiveType = TAR_GZ;
-            }
-            // we will fall through to the error case now
-        }
-        
-        if (m_archiveType == ZIP) {
-            return extractUnzip();
-        } else if (m_archiveType == TAR_GZ) {
-            return extractTar();
-        }
-        
-        SG_LOG(SG_IO, SG_WARN, "unsupported archive format:" << u);
-        return false;
-    }
-
-    bool extractUnzip()
-    {
-        bool result = true;
-        zlib_filefunc_def memoryAccessFuncs;
-        fill_memory_filefunc(&memoryAccessFuncs);
-
-        char bufferName[128];
-        snprintf(bufferName, 128, "%p+%lx", m_buffer.data(), m_buffer.size());
-        unzFile zip = unzOpen2(bufferName, &memoryAccessFuncs);
-
-        const size_t BUFFER_SIZE = 32 * 1024;
-        void* buf = malloc(BUFFER_SIZE);
-
-        try {
-            int result = unzGoToFirstFile(zip);
-            if (result != UNZ_OK) {
-                throw sg_exception("failed to go to first file in archive");
-            }
-
-            while (true) {
-                extractCurrentFile(zip, (char*) buf, BUFFER_SIZE);
-                result = unzGoToNextFile(zip);
-                if (result == UNZ_END_OF_LIST_OF_FILE) {
-                    break;
-                } else if (result != UNZ_OK) {
-                    throw sg_io_exception("failed to go to next file in the archive");
-                }
-            }
-        } catch (sg_exception& ) {
-            result = false;
-        }
-
-        free(buf);
-        unzClose(zip);
-        return result;
-    }
-
-    bool extractTar()
-    {
-        TarExtractor tx(m_extractPath);
-        tx.extractBytes(m_buffer.data(), m_buffer.size());
-        return !tx.hasError() && tx.isAtEndOfArchive();
-    }
-
     void doFailure(Delegate::StatusCode aReason)
     {
         Dir dir(m_extractPath);
@@ -364,19 +216,13 @@ private:
         m_owner->installResult(aReason);
     }
 
-    enum ArchiveType {
-        AUTO_DETECT = 0,
-        ZIP,
-        TAR_GZ
-    };
     
     InstallRef m_owner;
-    ArchiveType m_archiveType = AUTO_DETECT;
     string_list m_urls;
     SG_MD5_CTX m_md5;
-    std::string m_buffer;
     SGPath m_extractPath;
-    size_t m_downloaded;
+    size_t m_downloaded = 0;
+	std::unique_ptr<ArchiveExtractor> m_extractor;
 };
 
 ////////////////////////////////////////////////////////////////////

simgear/package/Root.cxx

@@ -414,7 +414,7 @@ Root::Root(const SGPath& aPath, const std::string& aVersion) :
         if (cat && cat->isEnabled()) {
             d->catalogs.insert({cat->id(), cat});
         } else if (cat) {
-            SG_LOG(SG_GENERAL, SG_WARN, "Package-Root init: catalog is disabled: " << cat->id());
+            SG_LOG(SG_GENERAL, SG_DEBUG, "Package-Root init: catalog is disabled: " << cat->id());
         }
     } // of child directories iteration
 }
@@ -450,6 +450,17 @@ CatalogRef Root::getCatalogById(const std::string& aId) const
     return it->second;
 }
 
+CatalogRef Root::getCatalogByUrl(const std::string& aUrl) const
+{
+    auto it = std::find_if(d->catalogs.begin(), d->catalogs.end(),
+                           [aUrl](const CatalogDict::value_type& v)
+                           { return (v.second->url() == aUrl); });
+    if (it == d->catalogs.end())
+        return {};
+    
+    return it->second;
+}
+    
 PackageRef Root::getPackageById(const std::string& aName) const
 {
     size_t lastDot = aName.rfind('.');
@@ -594,6 +605,12 @@ void Root::scheduleToUpdate(InstallRef aInstall)
     if (!aInstall) {
         throw sg_exception("missing argument to scheduleToUpdate");
     }
+    
+    auto it = std::find(d->updateDeque.begin(), d->updateDeque.end(), aInstall);
+    if (it != d->updateDeque.end()) {
+        // already scheduled to update
+        return;
+    }
 
     PackageList deps = aInstall->package()->dependencies();
     for (Package* dep : deps) {

simgear/package/Root.hxx

@@ -132,6 +132,8 @@ public:
     
     CatalogRef getCatalogById(const std::string& aId) const;
     
+    CatalogRef getCatalogByUrl(const std::string& aUrl) const;
+    
     void scheduleToUpdate(InstallRef aInstall);
     
     /**

simgear/package/catalogTest1/catalog-alt.xml

@@ -0,0 +1,141 @@
+<?xml version="1.0"?>
+
+<PropertyList>
+    <id>org.flightgear.test.catalog-alt</id>
+    <description>Alternate test catalog</description>
+    <url>http://localhost:2000/catalogTest1/catalog-alt.xml</url>
+    <catalog-version>4</catalog-version>
+
+    <version>7.*</version>
+
+
+    <package>
+        <id>alpha</id>
+        <name>Alpha package</name>
+        <revision type="int">9</revision>
+        <file-size-bytes type="int">593</file-size-bytes>
+
+        <md5>a469c4b837f0521db48616cfe65ac1ea</md5>
+        <url>http://localhost:2000/catalogTest1/alpha.zip</url>
+
+        <dir>alpha</dir>
+    </package>
+
+    <package>
+        <id>c172p</id>
+        <name>Cessna 172-P</name>
+        <dir>c172p</dir>
+        <description>A plane made by Cessna</description>
+        <revision type="int">42</revision>
+        <file-size-bytes type="int">860</file-size-bytes>
+
+        <tag>cessna</tag>
+        <tag>ga</tag>
+        <tag>piston</tag>
+        <tag>ifr</tag>
+
+        <rating>
+          <FDM type="int">3</FDM>
+          <systems type="int">4</systems>
+          <model type="int">5</model>
+          <cockpit type="int">4</cockpit>
+        </rating>
+
+
+        <preview>
+          <type>exterior</type>
+          <path>thumb-exterior.png</path>
+          <url>http://foo.bar.com/thumb-exterior.png</url>
+        </preview>
+
+        <preview>
+          <type>panel</type>
+          <path>thumb-panel.png</path>
+          <url>http://foo.bar.com/thumb-panel.png</url>
+        </preview>
+
+        <preview>
+          <path>thumb-something.png</path>
+          <url>http://foo.bar.com/thumb-something.png</url>
+        </preview>
+
+        <variant>
+            <id>c172p-2d-panel</id>
+            <name>C172 with 2d panel only</name>
+        </variant>
+
+        <variant>
+            <id>c172p-floats</id>
+            <name>C172 with floats</name>
+
+            <preview>
+              <type>exterior</type>
+              <path>thumb-exterior-floats.png</path>
+              <url>http://foo.bar.com/thumb-exterior-floats.png</url>
+            </preview>
+
+            <preview>
+              <type>panel</type>
+              <path>thumb-panel.png</path>
+              <url>http://foo.bar.com/thumb-panel.png</url>
+            </preview>
+        </variant>
+
+        <variant>
+            <id>c172p-skis</id>
+            <name>C172 with skis</name>
+
+            <preview>
+              <type>exterior</type>
+              <path>thumb-exterior-skis.png</path>
+              <url>http://foo.bar.com/thumb-exterior-skis.png</url>
+            </preview>
+
+            <preview>
+              <type>panel</type>
+              <path>thumb-panel.png</path>
+              <url>http://foo.bar.com/thumb-panel.png</url>
+            </preview>
+        </variant>
+
+        <md5>ec0e2ffdf98d6a5c05c77445e5447ff5</md5>
+        <url>http://localhost:2000/catalogTest1/c172p.zip</url>
+
+    </package>
+
+    <package>
+        <id>b737-NG</id>
+        <name>Boeing 737 NG</name>
+        <dir>b737NG</dir>
+        <description>A popular twin-engined narrow body jet</description>
+        <revision type="int">112</revision>
+        <file-size-bytes type="int">860</file-size-bytes>
+
+        <tag>boeing</tag>
+        <tag>jet</tag>
+        <tag>ifr</tag>
+
+        <rating>
+          <FDM type="int">5</FDM>
+          <systems type="int">5</systems>
+          <model type="int">4</model>
+          <cockpit type="int">4</cockpit>
+        </rating>
+
+        <md5>a94ca5704f305b90767f40617d194ed6</md5>
+        <url>http://localhost:2000/catalogTest1/b737.tar.gz</url>
+
+      </package>
+
+    <package>
+        <id>dc3</id>
+        <name>DC-3</name>
+        <revision type="int">9</revision>
+        <file-size-bytes type="int">593</file-size-bytes>
+
+        <md5>a469c4b837f0521db48616cfe65ac1ea</md5>
+        <url>http://localhost:2000/catalogTest1/alpha.zip</url>
+
+        <dir>dc3</dir>
+    </package>
+</PropertyList>

simgear/package/catalogTest1/catalog-v2.xml

@@ -15,6 +15,12 @@
       <url>http://localhost:2000/catalogTest1/catalog-v10.xml</url>
     </alternate-version>
     
+      <alternate-version>
+        <version>7.*</version>
+        <id>org.flightgear.test.catalog-alt</id>
+        <url>http://localhost:2000/catalogTest1/catalog-alt.xml</url>
+      </alternate-version>
+
     <package>
         <id>alpha</id>
         <name>Alpha package</name>

simgear/props/props.hxx

@@ -751,7 +751,7 @@ typedef SGSharedPtr<const SGPropertyNode> SGConstPropertyNode_ptr;
 
 namespace simgear
 {
-typedef std::vector<SGPropertyNode_ptr> PropertyList;
+    using PropertyList = std::vector<SGPropertyNode_ptr>;
 }
 
 /**

simgear/props/propsfwd.hxx

@@ -1,3 +1,20 @@
+// Copyright (C) 2018  James Turner - <james@flightgear>
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+//
+
 /** \file
  *
  * Forward declarations for properties (and related structures)
@@ -7,12 +24,18 @@
 #define SG_PROPS_FWD_HXX
 
 #include <simgear/structure/SGSharedPtr.hxx>
+#include <vector>
 
 class SGPropertyNode;
 
 typedef SGSharedPtr<SGPropertyNode> SGPropertyNode_ptr;
 typedef SGSharedPtr<const SGPropertyNode> SGConstPropertyNode_ptr;
 
+namespace simgear
+{
+    using PropertyList = std::vector<SGPropertyNode_ptr>;
+}
+
 class SGCondition; 
 
 #endif // of SG_PROPS_FWD_HXX

simgear/scene/dem/SGMesh.cxx

@@ -125,7 +125,7 @@ SGMesh::SGMesh( const SGDemPtr dem,
 
     ::std::vector<SGGeod> geodes(grid_width*grid_height);
 
-    // session can't be paralell yet - save alts in geode array
+    // session can't be parallel yet - save alts in geode array
     fprintf( stderr, "SGMesh::SGMesh - create session - num dem roots is %d\n", dem->getNumRoots() );
     SGDemSession s = dem->openSession( wo, so, eo, no, lvl, true );
     s.getGeods( wo, so, eo, no, grid_width, grid_height, skipx, skipy, geodes, Debug1, Debug2 );
@@ -159,10 +159,10 @@ SGMesh::SGMesh( const SGDemPtr dem,
         index.push_back( src_idx );
     }
 
-    // we can convert to cartesian in paralell
-    unsigned int nv = geodes.size();
+    // we can convert to cartesian in parallel
+    long nv = geodes.size();
 #pragma omp parallel for
-    for (unsigned int i = 0; i < nv; i++) {
+    for (long i = 0; i < nv; i++) {
         (*vertices)[i].set( toOsg( SGVec3f::fromGeod( geodes[i] ) ) );
     }
 
@@ -195,7 +195,7 @@ SGMesh::SGMesh( const SGDemPtr dem,
 
     // translate pos after normals computed
 #pragma omp parallel for
-    for ( unsigned int i=0; i < nv; i++ ) {
+    for ( long i=0; i < nv; i++ ) {
         (*vertices)[i].set( transform.preMult( (*vertices)[i]) );
     }
 
@@ -245,7 +245,7 @@ SGMesh::SGMesh( const SGDemPtr dem,
     osg::Geometry* geometry = new osg::Geometry;
 
     char geoName[64];
-    snprintf( geoName, sizeof(geoName), "tilemesh (%u,%u)-(%u,%u):level%d,%d", 
+    snprintf( geoName, sizeof(geoName), "tilemesh (%u,%u)-(%u,%u):level%u,%u", 
                 wo, so, eo, no,
                 widthLevel, heightLevel );
     geometry->setName(geoName);
@@ -364,9 +364,9 @@ void SGMesh::need_normals()
         // need_faces();
         if ( !faces.empty() ) {
             // Compute from faces
-            int nf = faces.size();
+            long nf = faces.size();
 #pragma omp parallel for
-            for (int i = 0; i < nf; i++) {
+            for (long i = 0; i < nf; i++) {
                 const osg::Vec3 &p0 = (*vertices)[faces[i][0]];
                 const osg::Vec3 &p1 = (*vertices)[faces[i][1]];
                 const osg::Vec3 &p2 = (*vertices)[faces[i][2]];
@@ -384,9 +384,9 @@ void SGMesh::need_normals()
         }
 
         // Make them all unit-length
-        unsigned int nn = normals->size();
+        long nn = normals->size();
 #pragma omp parallel for
-        for (unsigned int i = 0; i < nn; i++)
+        for (long i = 0; i < nn; i++)
             (*normals)[i].normalize();
     }
 }

simgear/scene/material/TextureBuilder.cxx

@@ -257,7 +257,8 @@ bool setAttrs(const TexTuple& attrs, Texture* tex,
         return false;
 
     osgDB::ReaderWriter::ReadResult result;
-    result = osgDB::readImageFile(imageName, options);
+
+    result = osgDB::readRefImageFile(imageName, options);
     osg::ref_ptr<osg::Image> image;
     if (result.success())
         image = result.getImage();
@@ -590,27 +591,27 @@ Texture* CubeMapBuilder::build(Effect* effect, Pass* pass, const SGPropertyNode*
             osg::Image* image = result.getImage();
             cubeTexture->setImage(TextureCubeMap::POSITIVE_X, image);
         }
-        result = osgDB::readImageFile(_tuple.get<1>(), options);
+        result = osgDB::readRefImageFile(_tuple.get<1>(), options);
         if(result.success()) {
             osg::Image* image = result.getImage();
             cubeTexture->setImage(TextureCubeMap::NEGATIVE_X, image);
         }
-        result = osgDB::readImageFile(_tuple.get<2>(), options);
+        result = osgDB::readRefImageFile(_tuple.get<2>(), options);
         if(result.success()) {
             osg::Image* image = result.getImage();
             cubeTexture->setImage(TextureCubeMap::POSITIVE_Y, image);
         }
-        result = osgDB::readImageFile(_tuple.get<3>(), options);
+        result = osgDB::readRefImageFile(_tuple.get<3>(), options);
         if(result.success()) {
             osg::Image* image = result.getImage();
             cubeTexture->setImage(TextureCubeMap::NEGATIVE_Y, image);
         }
-        result = osgDB::readImageFile(_tuple.get<4>(), options);
+        result = osgDB::readRefImageFile(_tuple.get<4>(), options);
         if(result.success()) {
             osg::Image* image = result.getImage();
             cubeTexture->setImage(TextureCubeMap::POSITIVE_Z, image);
         }
-        result = osgDB::readImageFile(_tuple.get<5>(), options);
+        result = osgDB::readRefImageFile(_tuple.get<5>(), options);
         if(result.success()) {
             osg::Image* image = result.getImage();
             cubeTexture->setImage(TextureCubeMap::NEGATIVE_Z, image);
@@ -634,7 +635,7 @@ Texture* CubeMapBuilder::build(Effect* effect, Pass* pass, const SGPropertyNode*
             return cubeTexture.release();
 
         osgDB::ReaderWriter::ReadResult result;
-        result = osgDB::readImageFile(texname, options);
+        result = osgDB::readRefImageFile(texname, options);
         if(result.success()) {
             osg::Image* image = result.getImage();
             image->flipVertical();   // Seems like the image coordinates are somewhat funny, flip to get better ones

simgear/scene/material/mat.cxx

@@ -227,7 +227,7 @@ SGMaterial::read_properties(const SGReaderWriterOptions* options,
             }
             else
             {
-                osg::Image* image = osgDB::readImageFile(fullMaskPath, options);
+                osg::Image* image = osgDB::readRefImageFile(fullMaskPath, options);
                 if (image && image->valid())
                 {
                     Texture2DRef object_mask = new osg::Texture2D;

simgear/scene/model/ModelRegistry.cxx

@@ -280,19 +280,21 @@ ModelRegistry::readImage(const string& fileName,
 }
 
 
-osg::Node* DefaultCachePolicy::find(const string& fileName,
-                                    const Options* opt)
+osg::ref_ptr<osg::Node> DefaultCachePolicy::find(const string& fileName, const Options* opt)
 {
     Registry* registry = Registry::instance();
-    osg::Node* cached
-        = dynamic_cast<Node*>(registry->getFromObjectCache(fileName));
-    if (cached)
-        SG_LOG(SG_IO, SG_BULK, "Got cached model \""
-               << fileName << "\"");
+#if OSG_VERSION_LESS_THAN(3,4,0)
+    osg::ref_ptr<osg::Object> cachedObject = registry->getFromObjectCache(fileName);
+#else
+    osg::ref_ptr<osg::Object> cachedObject = registry->getRefFromObjectCache(fileName);
+#endif
+
+    ref_ptr<osg::Node> cachedNode = dynamic_cast<osg::Node*>(cachedObject.get());
+    if (cachedNode.valid())
+        SG_LOG(SG_IO, SG_BULK, "Got cached model \"" << fileName << "\"");
     else
-        SG_LOG(SG_IO, SG_BULK, "Reading model \""
-               << fileName << "\"");
-    return cached;
+        SG_LOG(SG_IO, SG_BULK, "Reading model \"" << fileName << "\"");
+    return cachedNode;
 }
 
 void DefaultCachePolicy::addToCache(const string& fileName,

simgear/scene/model/ModelRegistry.hxx

@@ -132,7 +132,7 @@ struct DefaultProcessPolicy {
 
 struct DefaultCachePolicy {
     DefaultCachePolicy(const std::string& extension) {}
-    osg::Node* find(const std::string& fileName,
+    osg::ref_ptr<osg::Node> find(const std::string& fileName,
                     const osgDB::Options* opt);
     void addToCache(const std::string& filename, osg::Node* node);
 };

simgear/scene/model/SGReaderWriterXML.cxx

@@ -335,7 +335,7 @@ sgLoad3DModel_internal(const SGPath& path,
 
         options->setDatabasePath(texturepath.local8BitStr());
         osgDB::ReaderWriter::ReadResult modelResult;
-        modelResult = osgDB::readNodeFile(modelpath.local8BitStr(), options.get());
+        modelResult = osgDB::readRefNodeFile(modelpath.local8BitStr(), options.get());
         if (!modelResult.validNode())
             throw sg_io_exception("Failed to load 3D model:" + modelResult.message(),
                                   modelpath);
@@ -481,7 +481,7 @@ sgLoad3DModel_internal(const SGPath& path,
         }
     }
 
-    if (dbOptions->getPluginStringData("SimGear::PARTICLESYSTEM") != "OFF") {
+    if (GlobalParticleCallback::getEnabled()){//dbOptions->getPluginStringData("SimGear::PARTICLESYSTEM") != "OFF") {
         std::vector<SGPropertyNode_ptr> particle_nodes;
         particle_nodes = props->getChildren("particlesystem");
         for (unsigned i = 0; i < particle_nodes.size(); ++i) {

simgear/scene/model/model.cxx

@@ -43,9 +43,9 @@ SGLoadTexture2D(bool staticTexture, const std::string& path,
 {
   osg::Image* image;
   if (options)
-    image = osgDB::readImageFile(path, options);
+    image = osgDB::readRefImageFile(path, options);
   else
-    image = osgDB::readImageFile(path);
+    image = osgDB::readRefImageFile(path);
   osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
   texture->setImage(image);
   if (staticTexture)
@@ -141,7 +141,7 @@ Texture2D* TextureUpdateVisitor::textureReplace(int unit, const StateAttribute*
     // If it is empty or they are identical then there is nothing to do
     if (fullLiveryFile.empty() || fullLiveryFile == *fullFilePath)
         return 0;
-    Image* newImage = readImageFile(fullLiveryFile);
+    Image* newImage = readRefImageFile(fullLiveryFile);
     if (!newImage)
         return 0;
     CopyOp copyOp(CopyOp::DEEP_COPY_ALL & ~CopyOp::DEEP_COPY_IMAGES);

simgear/scene/model/modellib.cxx

@@ -161,33 +161,69 @@ SGModelLib::loadDeferredModel(const string &path, SGPropertyNode *prop_root,
     return proxyNode;
 }
 
+
+/*
+ * Load a set of models at different LOD range_nearest
+ *
+ */
 osg::PagedLOD*
-SGModelLib::loadPagedModel(const string &path, SGPropertyNode *prop_root,
-                           SGModelData *data)
+SGModelLib::loadPagedModel(SGPropertyNode *prop_root, SGModelData *data, SGModelLOD model_lods)
 {
+    unsigned int simple_models = 0;
     osg::PagedLOD *plod = new osg::PagedLOD;
-    plod->setName("Paged LOD for \"" + path + "\"");
-    plod->setFileName(0, path);
-    plod->setRange(0, 0.0, 50.0*SG_NM_TO_METER);
-    plod->setMinimumExpiryTime( 0, prop_root->getDoubleValue("/sim/rendering/plod-minimum-expiry-time-secs", 180.0 ) );
 
     osg::ref_ptr<SGReaderWriterOptions> opt;
     opt = SGReaderWriterOptions::copyOrCreate(osgDB::Registry::instance()->getOptions());
     opt->setPropertyNode(prop_root ? prop_root: static_propRoot.get());
     opt->setModelData(data);
     opt->setLoadPanel(static_panelFunc);
-    std::string lext = SGPath(path).lower_extension();
-
-    if ((lext == "ac") || (lext == "obj")) {
-        opt->setInstantiateEffects(true);
-    }
-
     if (!prop_root || prop_root->getBoolValue("/sim/rendering/cache", true))
         opt->setObjectCacheHint(osgDB::Options::CACHE_ALL);
     else
         opt->setObjectCacheHint(osgDB::Options::CACHE_NONE);
+
+    for(unsigned int i = 0; i < model_lods.getNumLODs(); i++) {
+      SGModelLOD::ModelLOD lod = model_lods.getModelLOD(i);
+      plod->setName("Paged LOD for \"" + lod.path + "\"");
+      plod->setFileName(i, lod.path);
+      plod->setRange(i, lod.min_range, lod.max_range);
+      plod->setMinimumExpiryTime(i, prop_root->getDoubleValue("/sim/rendering/plod-minimum-expiry-time-secs", 180.0 ) );
+
+      std::string lext = SGPath(lod.path).lower_extension();
+      if ((lext == "ac") || (lext == "obj")) {
+        simple_models++;
+      }
+    }
+
+    // If all we have are simple models, then we can instantiate effects in
+    // the loader.
+    if (simple_models == model_lods.getNumLODs()) opt->setInstantiateEffects(true);
+
     plod->setDatabaseOptions(opt.get());
+
     return plod;
 }
 
+osg::PagedLOD*
+SGModelLib::loadPagedModel(const string &path, SGPropertyNode *prop_root,
+                           SGModelData *data)
+{
+    SGModelLOD model_lods;
+    model_lods.insert(path, 0.0, 50.0*SG_NM_TO_METER);
+    return SGModelLib::loadPagedModel(prop_root, data, model_lods);
+}
+
+osg::PagedLOD*
+SGModelLib::loadPagedModel(std::vector<string> paths, SGPropertyNode *prop_root,
+                           SGModelData *data)
+{
+    SGModelLOD model_lods;
+    for(unsigned int i = 0; i < paths.size(); i++) {
+      // We don't have any range data, so simply set them all up to full range.
+      // Some other code will update the LoD ranges later.  (AIBase::updateLOD)
+      model_lods.insert(paths[i], 0.0, 50.0*SG_NM_TO_METER);
+    }
+    return SGModelLib::loadPagedModel(prop_root, data, model_lods);
+}
+
 // end of modellib.cxx

simgear/scene/model/modellib.hxx

@@ -39,6 +39,7 @@ namespace osg {
 namespace simgear {
 
 class SGModelData; // defined below
+class SGModelLOD;  // defined below
 
 /**
  * Class for loading and managing models with XML wrappers.
@@ -51,9 +52,9 @@ public:
     static void init(const std::string &root_dir, SGPropertyNode* root);
 
     static void resetPropertyRoot();
-    
+
     static void setPanelFunc(panel_func pf);
-    
+
     // Load a 3D model (any format)
     // data->modelLoaded() will be called after the model is loaded
     static osg::Node* loadModel(const std::string &path,
@@ -72,17 +73,24 @@ public:
     // the model file. Once the viewer steps onto that node the
     // model will be loaded. When the viewer does no longer reference this
     // node for a long time the node is unloaded again.
+    static osg::PagedLOD* loadPagedModel(SGPropertyNode *prop_root,
+                                      SGModelData *data,
+                                      SGModelLOD model_lods);
     static osg::PagedLOD* loadPagedModel(const std::string &path,
                                      SGPropertyNode *prop_root = NULL,
                                      SGModelData *data=0);
 
-    static std::string findDataFile(const std::string& file, 
+   static osg::PagedLOD* loadPagedModel(std::vector<string> paths,
+                                    SGPropertyNode *prop_root = NULL,
+                                    SGModelData *data=0);
+
+    static std::string findDataFile(const std::string& file,
       const osgDB::Options* opts = NULL,
-      SGPath currentDir = SGPath()); 
+      SGPath currentDir = SGPath());
 protected:
     SGModelLib();
     ~SGModelLib ();
-    
+
 private:
   static SGPropertyNode_ptr static_propRoot;
   static panel_func static_panelFunc;
@@ -102,6 +110,39 @@ public:
     virtual SGModelData* clone() const = 0;
 };
 
+/*
+ * Data for a model with multiple LoD versions
+ */
+
+class SGModelLOD {
+public:
+  struct ModelLOD {
+    ModelLOD(const string &p, float minrange, float maxrange) :
+      path(p), min_range(minrange), max_range(maxrange)
+      { }
+    const string &path;
+    float min_range;
+    float max_range;
+  };
+typedef std::vector<ModelLOD> ModelLODList;
+
+void insert(const ModelLOD& model)
+{
+  _models.push_back(model);
+}
+
+void insert(const string &p, float minrange, float maxrange)
+{
+  insert(ModelLOD(p, minrange, maxrange));
+}
+
+unsigned getNumLODs() const { return _models.size(); }
+const ModelLOD& getModelLOD(unsigned i) const { return _models[i]; }
+
+private:
+  ModelLODList _models;
+};
+
 }
 
 #endif // _SG_MODEL_LIB_HXX

simgear/scene/sky/cloud.cxx

@@ -485,9 +485,11 @@ SGCloudLayer::rebuild()
 // repaint the cloud layer colors
 bool SGCloudLayer::repaint( const SGVec3f& fog_color ) {
     osg::Vec4f combineColor(toOsg(fog_color), cloud_alpha);
-    osg::TexEnvCombine* combiner
-        = dynamic_cast<osg::TexEnvCombine*>(layer_root->getStateSet()
-                                            ->getTextureAttribute(1, osg::StateAttribute::TEXENV));
+    osg::StateAttribute* textureAtt = layer_root->getStateSet()->getTextureAttribute(1, osg::StateAttribute::TEXENV);
+    osg::TexEnvCombine* combiner = dynamic_cast<osg::TexEnvCombine*>(textureAtt);
+
+    if (combiner == nullptr)
+        return false;
     combiner->setConstantColor(combineColor);
 
     // Set the fog color for the 3D clouds too.

simgear/scene/tgdb/ReaderWriterSPT.cxx

@@ -208,7 +208,7 @@ ReaderWriterSPT::readObject(const std::string& fileName, const osgDB::Options* o
         imageFileName = osgDB::concatPaths(imageFileName, "Globe");
         imageFileName = osgDB::concatPaths(imageFileName, "world.topo.bathy.200407.3x4096x2048.png");
     }
-    if (osg::Image* image = osgDB::readImageFile(imageFileName, options)) {
+    if (osg::Image* image = osgDB::readRefImageFile(imageFileName, options)) {
         osg::Texture2D* texture = new osg::Texture2D;
         texture->setImage(image);
         texture->setWrap(osg::Texture2D::WRAP_S, osg::Texture2D::REPEAT);

simgear/simgear_config_cmake.h.in

@@ -25,5 +25,7 @@
 
 #cmakedefine SYSTEM_EXPAT
 #cmakedefine ENABLE_SOUND
+#cmakedefine USE_AEONWAVE
 #cmakedefine ENABLE_SIMD
+#cmakedefine ENABLE_SIMD_CODE
 #cmakedefine ENABLE_GDAL

simgear/sound/soundmgr.hxx

@@ -314,7 +314,7 @@ public:
     /**
      * Get a list of available playback devices.
      */
-    std::vector<const char*> get_available_devices();
+    std::vector<std::string> get_available_devices();
 
     /**
      * Get the current OpenAL vendor or rendering backend.

simgear/sound/soundmgr_aeonwave.cxx

@@ -8,7 +8,7 @@
 // Modified for the new SoundSystem by Erik Hofman, October 2009
 //
 // Copyright (C) 2001  Curtis L. Olson - http://www.flightgear.org/~curt
-// Copyright (C) 2009 Erik Hofman <erik@ehofman.com>
+// Copyright (C) 2009-2019 Erik Hofman <erik@ehofman.com>
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License as
@@ -75,10 +75,6 @@ public:
 
     ~SoundManagerPrivate()
     {
-        for (auto it = _devices.begin(); it != _devices.end(); ++it) {
-            free((void*)*it);
-        }
-        _devices.clear();
         _sample_groups.clear();
     }
 
@@ -125,8 +121,6 @@ public:
     }
 
     sample_group_map _sample_groups;
-
-    std::vector<const char*> _devices;
 };
 
 
@@ -424,8 +418,8 @@ void SGSoundMgr::release_source( unsigned int source )
     {
         aax::Emitter& emitter = source_it->second;
         enum aaxState state = emitter.state();
-        if (state == AAX_PLAYING || state == AAX_SUSPENDED) {
-           TRY( emitter.set(AAX_STOPPED) );
+        if (state != AAX_PROCESSED) {
+           TRY( emitter.set(AAX_PROCESSED) );
            TRY( d->_aax.remove(emitter) );
         }
         TRY( emitter.remove_buffer() );
@@ -444,7 +438,7 @@ unsigned int  SGSoundMgr::request_buffer(SGSoundSample *sample)
         std::string sample_name = sample->get_sample_name();
 
         aax::Buffer& buf = d->_aax.buffer(sample_name);
-        if (!buf) {
+        if (sample->is_file() && !buf) {
             SG_LOG(SG_SOUND, SG_ALERT,
                    "Unable to create buffer: " << sample_name);
             sample->set_buffer( SGSoundMgr::FAILED_BUFFER );
@@ -595,8 +589,7 @@ void SGSoundMgr::sample_stop( SGSoundSample *sample )
         if ( sample->is_looping() && !stopped) {
 #ifdef ENABLE_SOUND
             aax::Emitter& emitter = d->get_emitter(source);
-            TRY( emitter.set(AAX_STOPPED) );
-            TRY( d->_aax.remove(emitter) );
+            TRY( emitter.set(AAX_PROCESSED) );
 #endif          
             stopped = is_sample_stopped(sample);
         }
@@ -615,8 +608,7 @@ void SGSoundMgr::sample_destroy( SGSoundSample *sample )
         unsigned int source = sample->get_source();
         if ( sample->is_playing() ) {
             aax::Emitter& emitter = d->get_emitter(source);
-            TRY( emitter.set(AAX_STOPPED) );
-            TRY( d->_aax.remove(emitter) );
+            TRY( emitter.set(AAX_PROCESSED) );
         }
         release_source( source );
 #endif
@@ -646,39 +638,46 @@ void SGSoundMgr::update_sample_config( SGSoundSample *sample, SGVec3d& position,
     aax::Emitter& emitter = d->get_emitter(sample->get_source());
     aax::dsp dsp;
 
-    aax::Vector64 pos = position.data();
-    aax::Vector ori = orientation.data();
-    aax::Vector vel = velocity.data();
+    if (emitter != d->nullEmitter)
+    {
+        aax::Vector64 pos = position.data();
+        aax::Vector ori = orientation.data();
+        aax::Vector vel = velocity.data();
 
-    aax::Matrix64 mtx(pos, ori);
-    TRY( emitter.matrix(mtx) );
-    TRY( emitter.velocity(vel) );
+        aax::Matrix64 mtx(pos, ori);
+        TRY( emitter.matrix(mtx) );
+        TRY( emitter.velocity(vel) );
 
-    dsp = emitter.get(AAX_VOLUME_FILTER);
-    TRY( dsp.set(AAX_GAIN, sample->get_volume()) );
-    TRY( emitter.set(dsp) );
-
-    dsp = emitter.get(AAX_PITCH_EFFECT);
-    TRY( dsp.set(AAX_PITCH, sample->get_pitch()) );
-    TRY( emitter.set(dsp) );
-
-    if ( sample->has_static_data_changed() ) {
-        dsp = emitter.get(AAX_ANGULAR_FILTER);
-        TRY( dsp.set(AAX_INNER_ANGLE, sample->get_innerangle()) );
-        TRY( dsp.set(AAX_OUTER_ANGLE, sample->get_outerangle()) );
-        TRY( dsp.set(AAX_OUTER_GAIN, sample->get_outergain()) );
+        dsp = emitter.get(AAX_VOLUME_FILTER);
+        TRY( dsp.set(AAX_GAIN, sample->get_volume()) );
         TRY( emitter.set(dsp) );
 
-        dsp = emitter.get(AAX_DISTANCE_FILTER);
-        TRY( dsp.set(AAX_REF_DISTANCE, sample->get_reference_dist()) );
-        TRY( dsp.set(AAX_MAX_DISTANCE, sample->get_max_dist()) );
+        dsp = emitter.get(AAX_PITCH_EFFECT);
+        TRY( dsp.set(AAX_PITCH, sample->get_pitch()) );
         TRY( emitter.set(dsp) );
+
+        if ( sample->has_static_data_changed() ) {
+            dsp = emitter.get(AAX_ANGULAR_FILTER);
+            TRY( dsp.set(AAX_INNER_ANGLE, sample->get_innerangle()) );
+            TRY( dsp.set(AAX_OUTER_ANGLE, sample->get_outerangle()) );
+            TRY( dsp.set(AAX_OUTER_GAIN, sample->get_outergain()) );
+            TRY( emitter.set(dsp) );
+
+            dsp = emitter.get(AAX_DISTANCE_FILTER);
+            TRY( dsp.set(AAX_REF_DISTANCE, sample->get_reference_dist()) );
+            TRY( dsp.set(AAX_MAX_DISTANCE, sample->get_max_dist()) );
+            TRY( emitter.set(dsp) );
+       }
+    }
+    else {
+        SG_LOG( SG_SOUND, SG_ALERT, "Error: source: " << sample->get_source() << " not found");
     }
 }
 
 
-vector<const char*> SGSoundMgr::get_available_devices()
+vector<std::string> SGSoundMgr::get_available_devices()
 {
+    vector<std::string> devices;
 #ifdef ENABLE_SOUND
     std::string on = " on ";
     std::string colon = ": ";
@@ -690,12 +689,12 @@ vector<const char*> SGSoundMgr::get_available_devices()
                 else if (*r) name += on + r;
                 else if (*i) name += colon + i;
 
-                d->_devices.push_back( strdup(name.c_str()) );
+                devices.push_back( name );
             }
         }
     }
 #endif
-    return d->_devices;
+    return devices;
 }
 
 

simgear/sound/soundmgr_openal.cxx

@@ -340,7 +340,7 @@ void SGSoundMgr::suspend()
         for ( auto current = d->_sample_groups.begin();
                    current != d->_sample_groups.end(); ++current ) {
             SGSampleGroup *sgrp = current->second;
-            sgrp->stop();
+            sgrp->suspend();
         }
         _active = false;
     }
@@ -821,9 +821,9 @@ bool SGSoundMgr::load( const std::string &samplepath,
     return true;
 }
 
-vector<const char*> SGSoundMgr::get_available_devices()
+vector<std::string> SGSoundMgr::get_available_devices()
 {
-    vector<const char*> devices;
+    vector<std::string> devices;
 #ifdef ENABLE_SOUND
     const ALCchar *s;
 

simgear/sound/xmlsound.cxx

@@ -83,6 +83,9 @@ SGXmlSound::~SGXmlSound()
     if (_sample)
         _sample->stop();
 
+    if (_sgrp && (_name != ""))
+        _sgrp->remove(_name);
+
     _volume.clear();
     _pitch.clear();
 }

simgear/structure/event_mgr.cxx

@@ -119,6 +119,14 @@ void SGEventMgr::removeTask(const std::string& name)
   }
 }
 
+void SGEventMgr::dump()
+{
+    SG_LOG(SG_GENERAL, SG_INFO, "EventMgr: sim-time queue:");
+    _simQueue.dump();
+    SG_LOG(SG_GENERAL, SG_INFO, "EventMgr: real-time queue:");
+    _rtQueue.dump();
+}
+
 ////////////////////////////////////////////////////////////////////////
 // SGTimerQueue
 // This is the priority queue implementation:
@@ -270,3 +278,11 @@ SGTimer* SGTimerQueue::findByName(const std::string& name) const
   
   return NULL;
 }
+
+void SGTimerQueue::dump()
+{
+    for (int i=0; i < _numEntries; ++i) {
+        const auto t = _table[i].timer;
+        SG_LOG(SG_GENERAL, SG_INFO, "\ttimer:" << t->name << ", interval=" << t->interval);
+    }
+}

simgear/structure/event_mgr.hxx

@@ -38,6 +38,8 @@ public:
     double   nextTime()  { return -_table[0].pri; }
 
     SGTimer* findByName(const std::string& name) const;
+    
+    void dump();
 private:
     // The "priority" is stored as a negative time.  This allows the
     // implementation to treat the "top" of the heap as the largest
@@ -119,6 +121,8 @@ public:
 
 
     void removeTask(const std::string& name);
+    
+    void dump();
 private:
     friend class SGTimer;
 

simgear/structure/subsystem_mgr.cxx

@@ -253,6 +253,7 @@ SGSubsystemGroup::incrementalInit()
 {
     // special case this, simplifies the logic below
     if (_members.empty()) {
+        _state = State::INIT;
         return INIT_DONE;
     }
 
@@ -440,6 +441,8 @@ SGSubsystemGroup::set_subsystem (const string &name, SGSubsystem * subsystem,
     if (name.empty()) {
         SG_LOG(SG_GENERAL, SG_DEV_WARN, "adding subsystem to group without a name");
         // TODO, make this an exception in the future
+    } else if (subsystem->name().empty()) {
+        subsystem->set_name(name);
     } else if (name != subsystem->name()) {
         SG_LOG(SG_GENERAL, SG_DEV_WARN, "adding subsystem to group with name '" << name
                << "', but name() returns '" << subsystem->name() << "'");
@@ -453,14 +456,25 @@ SGSubsystemGroup::set_subsystem (const string &name, SGSubsystem * subsystem,
     subsystem->set_group(this);
     notifyDidChange(subsystem, State::ADD);
     
-    if (_state != State::INVALID) {
-        SG_LOG(SG_GENERAL, SG_DEV_WARN, "TODO: implement SGSubsystemGroup transition when adding after init");
+    if (_state != State::INVALID && (_state <= State::POSTINIT)) {
         // transition to the correct state
-        // bind
+        if (_state >= State::BIND) {
+            notifyWillChange(subsystem, State::BIND);
+            subsystem->bind();
+            notifyDidChange(subsystem, State::BIND);
+        }
         
-        // init
+        if (_state >= State::INIT) {
+            notifyWillChange(subsystem, State::INIT);
+            subsystem->init();
+            notifyDidChange(subsystem, State::INIT);
+        }
         
-        // post-init
+        if (_state == State::POSTINIT) {
+            notifyWillChange(subsystem, State::POSTINIT);
+            subsystem->postinit();
+            notifyDidChange(subsystem, State::POSTINIT);
+        }
     }
 }
 
@@ -502,11 +516,17 @@ SGSubsystemGroup::remove_subsystem(const string &name)
         
         if (_state != State::INVALID) {
             // transition out correctly
-            SG_LOG(SG_GENERAL, SG_DEV_WARN, "TODO: implement SGSubsystemGroup transition when removing before shutdown");
-
-            // shutdown
+            if ((_state >= State::INIT) && (_state < State::SHUTDOWN)) {
+                notifyWillChange(sub, State::SHUTDOWN);
+                sub->shutdown();
+                notifyDidChange(sub, State::SHUTDOWN);
+            }
             
-            // unbind
+            if ((_state >= State::BIND) && (_state < State::UNBIND)) {
+                notifyWillChange(sub, State::UNBIND);
+                sub->unbind();
+                notifyDidChange(sub, State::UNBIND);
+            }
         }
         
         notifyWillChange(sub, State::REMOVE);
@@ -1150,10 +1170,9 @@ namespace {
                      group,
                      minTime);
         
-        if (arg->getBoolValue("do-bind-init", false)) {
-            sub->bind();
-            sub->init();
-        }
+        // we no longer check for the do-bind-init flag here, since set_subsystem
+        // tracks the group state and will transition the added subsystem
+        // automatically
 
         return true;
     }
@@ -1168,11 +1187,7 @@ namespace {
             SG_LOG(SG_GENERAL, SG_ALERT, "do_remove_subsystem: unknown subsytem:" << name);
             return false;
         }
-        
-        // is it safe to always call these? let's assume so!
-        instance->shutdown();
-        instance->unbind();
-        
+                
         // unplug from the manager (this also deletes the instance!)
         manager->remove(name.c_str());
         return true;

simgear/structure/subsystem_mgr.hxx

@@ -301,6 +301,10 @@ public:
     /// get the parent group of this subsystem
     SGSubsystemGroup* get_group() const;
     
+    // ordering here is exceptionally important, due to
+    // liveness of ranges. If you're extending this consider
+    // carefully where the new state lies and position it correctly.
+    // Also extend the tests to ensure you handle all cases.
     enum class State {
         INVALID = -1,
         ADD = 0,
@@ -310,8 +314,8 @@ public:
         REINIT,
         SUSPEND,
         RESUME,
-        UNBIND,
         SHUTDOWN,
+        UNBIND,
         REMOVE
     };
     

simgear/structure/subsystem_test.cxx

@@ -314,6 +314,7 @@ void testIncrementalInit()
     instruments->set_subsystem(radio1);
     instruments->set_subsystem(radio2);
     
+    
     manager->bind();
     for ( ; ; ) {
         auto status = manager->incrementalInit();
@@ -338,9 +339,34 @@ void testIncrementalInit()
     
     SG_VERIFY(d->hasEvent("fake-radio.nav2-will-init"));
     SG_VERIFY(d->hasEvent("fake-radio.nav2-did-init"));
+}
 
+void testEmptyGroup()
+{
+    // testing the assert described here:
+    // https://sourceforge.net/p/flightgear/codetickets/2043/
+    // when an empty group is inited, we skipped setting the state
+    
+    SGSharedPtr<SGSubsystemMgr> manager = new SGSubsystemMgr;
+    auto d = new RecorderDelegate;
+    manager->addDelegate(d);
+    
+    auto mySub = manager->add<MySub1>(SGSubsystemMgr::POST_FDM);
+    auto anotherSub = manager->add<AnotherSub>(SGSubsystemMgr::POST_FDM);
+    auto instruments = manager->add<InstrumentGroup>(SGSubsystemMgr::POST_FDM);
+    
+    manager->bind();
+    for ( ; ; ) {
+        auto status = manager->incrementalInit();
+        if (status == SGSubsystemMgr::INIT_DONE)
+            break;
+    }
+    manager->postinit();
+    
+    SG_VERIFY(mySub->wasInited);
 
-
+    SG_VERIFY(d->hasEvent("instruments-will-init"));
+    SG_VERIFY(d->hasEvent("instruments-did-init"));
 }
 
 void testSuspendResume()
@@ -439,6 +465,75 @@ void testPropertyRoot()
     SG_CHECK_EQUAL(props->getIntValue("anothersub/bar"), 172);
 }
 
+void testAddRemoveAfterInit()
+{
+    SGSharedPtr<SGSubsystemMgr> manager = new SGSubsystemMgr;
+    auto d = new RecorderDelegate;
+    manager->addDelegate(d);
+    
+    auto group = manager->add<InstrumentGroup>();
+    SG_VERIFY(group);
+
+    auto radio1 = manager->createInstance<FakeRadioSub>("nav1");
+    group->set_subsystem(radio1);
+
+    auto com1 = manager->createInstance<FakeRadioSub>("com1");
+    group->set_subsystem(com1);
+    auto com2 = manager->createInstance<FakeRadioSub>("com2");
+    group->set_subsystem(com2);
+    
+    manager->bind();
+    manager->init();
+    
+    SG_VERIFY(d->hasEvent("fake-radio.nav1-will-init"));
+    SG_VERIFY(d->hasEvent("fake-radio.nav1-did-bind"));
+
+    auto radio2 = manager->createInstance<FakeRadioSub>("nav2");
+    group->set_subsystem(radio2);
+    
+    SG_VERIFY(d->hasEvent("fake-radio.nav2-will-init"));
+    SG_VERIFY(d->hasEvent("fake-radio.nav2-did-init"));
+    SG_VERIFY(d->hasEvent("fake-radio.nav2-did-bind"));
+    
+    bool ok = manager->remove("fake-radio.nav1");
+    SG_VERIFY(ok);
+    SG_VERIFY(d->hasEvent("fake-radio.nav1-will-shutdown"));
+    SG_VERIFY(d->hasEvent("fake-radio.nav1-did-shutdown"));
+    SG_VERIFY(d->hasEvent("fake-radio.nav1-will-unbind"));
+    SG_VERIFY(d->hasEvent("fake-radio.nav1-did-unbind"));
+    SG_VERIFY(d->hasEvent("fake-radio.nav1-will-remove"));
+    SG_VERIFY(d->hasEvent("fake-radio.nav1-did-remove"));
+    
+    manager->shutdown();
+    
+    SG_VERIFY(d->hasEvent("fake-radio.nav2-will-shutdown"));
+    SG_VERIFY(d->hasEvent("fake-radio.nav2-did-shutdown"));
+    SG_VERIFY(d->hasEvent("fake-radio.com1-will-shutdown"));
+    SG_VERIFY(d->hasEvent("fake-radio.com1-did-shutdown"));
+    
+    d->events.clear();
+    
+    ok = manager->remove("fake-radio.com1");
+    SG_VERIFY(d->hasEvent("fake-radio.com1-will-remove"));
+    SG_VERIFY(d->hasEvent("fake-radio.com1-did-remove"));
+    SG_VERIFY(d->hasEvent("fake-radio.com1-will-unbind"));
+    SG_VERIFY(d->hasEvent("fake-radio.com1-did-unbind"));
+    SG_VERIFY(!d->hasEvent("fake-radio.com1-will-shutdown"));
+    SG_VERIFY(!d->hasEvent("fake-radio.com1-did-shutdown"));
+    
+    manager->unbind();
+    
+    SG_VERIFY(d->hasEvent("fake-radio.com2-will-unbind"));
+    SG_VERIFY(d->hasEvent("fake-radio.com2-did-unbind"));
+    
+    d->events.clear();
+    manager->remove("fake-radio.com2");
+    SG_VERIFY(!d->hasEvent("fake-radio.com2-will-unbind"));
+    SG_VERIFY(!d->hasEvent("fake-radio.com2-did-unbind"));
+    SG_VERIFY(d->hasEvent("fake-radio.com2-will-remove"));
+    SG_VERIFY(d->hasEvent("fake-radio.com2-did-remove"));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 
@@ -450,6 +545,8 @@ int main(int argc, char* argv[])
     testIncrementalInit();
     testSuspendResume();
     testPropertyRoot();
+    testAddRemoveAfterInit();
+    testEmptyGroup();
     
     cout << __FILE__ << ": All tests passed" << endl;
     return EXIT_SUCCESS;

version

@@ -1 +1 @@
-2018.3.0
+2018.3.4